一.概念:
数组: 相同类型的数据的组合
1) 数组定义:
定义数组:
* 数组定义的第一种形式
* 类型[] 数组名 = { 元素1,元素2,元素3,...}
* array[下标] 下标就是该元素的位置
* 数组中的下标从 0 开始 array[0] --> 元素1 array[1] -->元素2 ....
* array.length 数组的长度 也是数组中元素的个数
* 改变数组里的内容 array[i] = 233;
* 数组的类型有: 基本数据类型 八种
* 数组定义的第二种形式
* int arr[] = {2,3,4,5,21};
* 定义数组的第三种方式
* 类型[] 数组名 = new 类型[数组长度];
2）数组变量：是引用类型变量（不是基本类型）,引用变量通过数组的内存地址位置引用了一个数组（数组对象），就像栓到数组对象的绳子。
eg：数组变量的赋值
int[] ary = new int[3];// ary----->{0,0,0}<----ary1
int[] ary1 = ary;// ary 的地址赋值给ary1，ary 与 ary1 绑定了同一个数组
//ary[1] 与 ary1[1] 是同一个元素，数组变量不是数组,是一个引用(数组在内存中的地址)
3）数组（数组对象）有3种创建（初始化）方式：
①new int[10000] 给元素数量，适合不知道具体元素，或元素数量较多时
②new int[]{3,4,5} 不需要给出数量，直接初始化具体元素适合知道数组的元素。
③ {2,3,4} 静态初始化，是②简化版，只能用在声明数组变量的时候直接初始化，不能用于赋值等情况。
eg：数组初始化
int[] ary1 = new int[]{2,3,4};//创建数组时候直接初始化元素
int[] ary2 = {2,3,4};//数组静态初始化，只能在声明变量的同时直接赋值
//ary2 = {4,5,6};//编译错误，不能用于赋值等情况
ary2 = new int[]{4,5,6};
4）数组元素的访问：
①数组长度：长度使用属性访问，ary.length 获取数组下标。
②数组下标：范围：0 ~ length-1就是[0,length)，超范围访问会出现下标越界异常。
③使用[index] 访问数组元素：ary[2]。④迭代（遍历）：就是将数组元素逐一处理一遍的方法。
5）数组默认初始化值：
根据数组类型的不同，默认初始化值为：0（整数）、0.0（浮点数）、false（布尔类型）、u0000（char字符类型，显示无效果，相当于空格，编码为0的字 符是控制字符，强转为int时显示0）、null（string类型，什么都没有，空值的意思）。
6）数组的复制：
数组变量的赋值，是并不会复制数组对象，是两个变量引用了同一个数组对象。数组复制的本质是创建了新数组，将原数组的内容复制过来。
7）数组的扩容：
创建新数组，新数组容量大于原数组，将原数组内容复制到新数组，并且丢弃原数组，简单说：就是更换更大的数组对象。System.arraycopy() 用于复制数组内容，简化版的数组复制方法：Arrays.copyOf()方法，但需JKD1.5以上版本。
二. 数组排序问题
1.冒泡排序
//由小到大排序 int[] a = {5, 2, 3, 4, 15, 6, 7, 8, 9, 10}; int n = a.length; for (int i = 0; i < n-1 ; i++) { for (int j = 0; j < n -1 - i; j++) { //n-1-i 比 n-1 循环次数更少 节约系统时间 if (a[j] > a[j + 1]) { int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); } //由大到小排序 for (int i = n-1; i >0 ; i--) { for (int j = 0; j < n -i- 1; j++) { if (a[j] < a[j + 1]) { int temp = a[j]; a[j] = a[j + 1]; a[j + 1] = temp; } } } for (int i = 0; i < a.length; i++) { System.out.print(a[i] + " "); }
2.选择排序
int[] arr1 = {5, 2, 3, 4, 15, 6, 7, 8, 9, 10}; //由小到大排序 for (int i = 0; i < arr1.length - 1; i++) { int min = i; for (int j = i + 1; j < arr1.length; j++) { if (arr1[min] > arr1[j]) { min = j; } } if (min != i) { int temp = arr1[i]; arr1[i] = arr1[min]; //把小的数放到前面 大的数往后挪 arr1[min] = temp; } } for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); } System.out.println(); //由大到小排序 for (int i = 0; i < arr1.length - 1; i++) { int max = i; for (int j = i + 1; j < arr1.length; j++) { if (arr1[max] < arr1[j]) { max = j; } } if (max != i) { int temp = arr1[i]; arr1[i] = arr1[max]; arr1[max] = temp; } } for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); }
3. 插入排序算法
//由小到大排序 int[] arr1 = {5, 2, 3, 4, 15, 6, 7, 8, 9, 10}; for(int i=1;i<arr1.length;i++){ for(int j=i;j>0;j--){ if (arr1[j]<arr1[j-1]){ int temp=arr1[j-1]; arr1[j-1]=arr1[j]; arr1[j]=temp; }else break; } } for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); } System.out.println(); //由大到小排序 for(int i=1;i<arr1.length;i++){ //大循环每次循环增加一位 for(int j=i;j>0;j--){ if (arr1[j]>arr1[j-1]){ //每次循环 向后增加一位 增加的那位和前面的所有位比较 int temp=arr1[j-1]; arr1[j-1]=arr1[j]; arr1[j]=temp; }else break; } } for (int i = 0; i < arr1.length; i++) { System.out.print(arr1[i] + " "); }
4. 还有一种方法就是用Arrays.sort()方法
int[] n1 = {4,1,5,6,8,9,7,12,18}; Arrays.sort(n1); //默认由小到大排序 for (int k = 0; k < n1.length; k++) { System.out.print(n1[k] + " "); }
5.设置两层循环
int[] arrayOfInts = {45, 9, 458, 51, 6, 45, 87, 5, 1}; for (int i = 0; i < arrayOfInts.length; i++) { for (int j = i + 1; j < arrayOfInts.length; j++) { if (arrayOfInts[i] > arrayOfInts[j]) { int a = arrayOfInts[i]; arrayOfInts[i] = arrayOfInts[j]; arrayOfInts[j] = a; } } } for (int i = 0; i < arrayOfInts.length; i++) { System.out.print(" " + arrayOfInts[i]); }
6.字符串排序，先大写后小写
String[] strArray = new String[]{ "z", "a", "C" }; Arrays.sort(strArray); // 输出： [C, a, z] 严格按字母表顺序排序，也就是忽略大小写排序 Case-insensitive sort Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); // 输出： [a, C, z]
7.反向排序， Reverse-order sort
Arrays.sort(strArray, Collections.reverseOrder()); // 输出：[z, a, C] // 忽略大小写反向排序 Case-insensitive reverse-order sort Arrays.sort(strArray, String.CASE_INSENSITIVE_ORDER); Collections.reverse(Arrays.asList(strArray)); // 输出： [z, C, a]
小栗子:
/** * 定义一个整型数组，保存10个数据，利用程序完成将最大值保存在数组中第一个元素，依次递减。 */ Scanner input = new Scanner(System.in); System.out.println("请输入10个整数"); int[] arr = new int[10]; for (int i = 0; i < arr.length; i++) { arr[i] = input.nextInt(); //将整数存入数组 } for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1; j++) { if (arr[j] < arr[j + 1]) { int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } System.out.println(Arrays.toString(arr));