sgg_01

Java_数组（引用数据类型）

概述

• 是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据同一管理
• 数组的常见概念
  • 数组名
  • 下标 （或索引）
  • 元素
  • 数组的长度
• 数组的特点：
  • 数组是有序的
  • 数组的元素可以是基本数据类型，也可以是引用数据类型
  • 在内存中开辟一整块连续的空间
  • 数组的长度一旦确定，就不能修改
• 数组的分类
  • 按照维度分为：一维数组，多维数组
  • 按照数组元素的类型：基本数据类型数据，引用数据类型元素的数组

一维数组

1. 一维数组的声明和初始化

public class ArrayTest {
	public static void main(String[] args) {
		int[] ids;//声明
		// 静态初始化：数组的初始化和赋值操作同时进行
		ids = new int[] {1001,1002,1003};  
		// 动态初始化：数组的初始化和赋值分开进行
		String[] names = new String[5];
		// 总结：数组一旦初始化完成其长度就确定了。
	}
}

2. 调用数组的指定位置的元素

public class ArrayTest {
	public static void main(String[] args) { 
		String[] names = new String[5];  
		// 通过下标的方式调用
		// 数组的下标是从0开始的，到数组的长度-1结束
		names[0] = "第一个";
		names[1] = "第二个";
		names[2] = "第三个";
		names[3] = "第四个";
		names[4] = "第五个"; 
	}
}

3. 遍历数组

public class ArrayTest {
	public static void main(String[] args) { 
		String[] names = new String[5];   
		names[0] = "第一个";
		names[1] = "第二个";
		names[2] = "第三个";
		names[3] = "第四个";
		names[4] = "第五个";    
		// 遍历
		for(int i = 0; i < names.length; i++) {
			System.out.println(names[i]);
		}
		
	}
}

4. 获取数组的长度

public class ArrayTest {
	public static void main(String[] args) { 
		String[] names = new String[5];  
		// 通过下标的方式调用
		// 数组的下标是从0开始的，到数组的长度-1结束
		names[0] = "第一个";
		names[1] = "第二个";
		names[2] = "第三个";
		names[3] = "第四个";
		names[4] = "第五个";  
		// 获取数组的长度
		System.out.println(names.length);
	}
}

5. 数组元素的默认初始化值

• 整形数组：默认初始化值都是0
• 浮点型数组：0.0
• char型数组: 0 或 “\u0000”
• 布尔型数组：false
• 引用数据型数组：null

6.数组的内存解析

左边栈，右边是堆（大概）,

​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VMTGoTsb-1663075066605)(C:\Users\coder\AppData\Roaming\Typora\typora-user-images\image-20220912225358471.png)]

多维数组

• java中提供了支持多维数组的语法
• 如果一维是线性图形，二维数组就是表格
• 数组的元素还是一个数组

1.二维数组的声明和初始化

public class ArrayTest02 {
	public static void main(String[] args) {
		int[] arr = new int[] {1,2,3};
		int[][] arr1 = new int[][] {{1,2},{1,1,5,6},{2,1}};
		String[][] arr2 = new String[3][2];
		String[][] arr3 = new String[3][]; 
	}
}

2.调用数组的指定位置的元素

和一维数组一样也是通过数组的下标进行访问，只是二维数组要多一个下标指定

public class ArrayTest02 {
	public static void main(String[] args) {
		int[] arr = new int[] {1,2,3};
		int[][] arr1 = new int[][] {{1,2},{1,1,5,6},{2,1}};
		String[][] arr2 = new String[3][2];
		String[][] arr3 = new String[3][]; 
		// 访问
		System.out.println(arr1[2][1]);
	}
}

3. 遍历数组

和一维数组一致，for循环遍历，二维嵌套循环

4. 获取数组的长度

只看第一层的长度

5.数组元素的默认初始化值

• 第一层数组默认值是：地址值

• 第二层数组根据初始化的类型不同：默认初始值不同

  
  public class ArrayTest03 {
  	public static void main(String[] args) {
  		int[][] arr = new int[4][3];
  		System.out.println(arr[0]); // 地址
  		System.out.println(arr[0][0]); // 0
          
          
          int[][] arr1 = new int[4][];
          System.out.println(arr1[1]); // null
          System.out.println(arr1[1][0]); // 空指针报错
          
  	}
  }
  
  

6.二维数组的内存解析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PeT2pBhZ-1663075066606)(C:\Users\coder\AppData\Roaming\Typora\typora-user-images\image-20220913122735892.png)]

练习

• 一维数组的两种初始化方式

  int[] arr = new int[5];        // 动态
  int[] arr1 = new int[]{1,2,1}; // 静态  
  

• 二维数组初始化的两种方式

  int[][] arr1 = new int[][] {{1,2},{1,1,5,6},{2,1}};
  String[][] arr2 = new String[3][2];
  

• 遍历二维数组

  public class ArrayTest03 {
  	public static void main(String[] args) {
  		int[][] arr = new int[][] {{1,2,3},{4,5},{6,7,8}};
  		for(int i = 0;i<arr.length;i++) {
  			for(int x =0;x<arr[i].length;x++) {
  				System.out.print(arr[i][x]+"\t");
  			}
  			System.out.println();
  		}
  	}
  }
  

常见算法

1.数组元素的赋值（杨辉三角，回形数）

2.求数值型数组中元素的最大值、最小值、平均数

3.数组的复制，反转，查找（线性查找，二分法查找）

public class ArrayTest06 {
	public static void main(String[] args) {
		int[] arr1,arr2;
		arr1 = new int[] {2,3,5,7,11,13,17,19};
		
		// 数组的复制
		arr2 = new int[arr1.length];
		for(int i = 0; i < arr1.length;i++) {
			 arr2[i] = arr1[i];
		}
		
		// 数组的反转
		for(int i = 0;i<arr1.length/2;i++) {
			int temp = arr1[i];
			arr1[i] = arr1[arr1.length -i -1];
			arr1[arr1.length -i -1] = temp;
 		}
		
		// 数组的查找
		
		// 线性查找：
		int dest = 10;
		boolean isFlag = true;
		for(int i = 0;i<arr1.length;i++) {
			if(arr1[i] == dest) {
				System.out.println("True");
				isFlag = false;
				break;
			}
		}

		if(isFlag) {
			System.out.println("false");
		}
		
		// 二分法查找（有序）
		int [] arr3 = new int[] {1,2,3,85,564,4321,8464,5468465,6546485,21313599,2131548999};
		int dest1 = 85;
		int head = 0; 
		int end = arr3.length - 1;
		boolean isFlag1 = true;
		while(head <= end) {
			int mid = (head + end )/2; 
			if (dest1 == arr3[mid]) {
				System.out.println("true");
				isFlag1 = false;
				break;
			}else if (dest1 > arr3[mid] ) {
				head = mid + 1;
			}else if (dest1 < arr3[mid]) {
				end = mid - 1;
			}
		}
		if (isFlag1) {
			System.out.println("false");
		}
	}
}

4.数组元素的排序算法

• 算法的优劣衡量：事件复杂度，空间复杂度，稳定性

1.冒泡排序

public class ArrrayTest07 {
	public static void main(String[] args) {
		int[] arr = new int[] {1,2165,54,1,2,6,87,7,95,64};
		for(int i = 0;i<arr.length-1;i++) { 
			for(int j = 0;j<arr.length - 1 - i;j++) {
				if(arr[j] > arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
				}
			}
		}
		for(int i = 0;i<arr.length;i++) {
			System.out.println(arr[i]);
		}
	}
}

2.快速排序

…