数组
数组的定义
(相关资料图)
数组的声明创建
必须先声明数组变量，才可以在程序中使用数组
int[] array; //首选的方法int array[];
java语言中使用new操作符来创建数组
int[] array = new int[10];
数组的元素是通过索引访问的，数组索引从0开始。：array[0]获取数组长度 ：arrays.length
例:
public class ArrayDemo01 {public static void main(String[] args) {int[] nums; //1、声明一个数组 nums = new int [10]; //2、创建一个数组 int sum = 0; //3、给数组赋值 for (int i = 0; i<NUMS.LENGTH ;="" i++)="" {nums[i]= (i+1); } //4、计算所有元素的和 for (int i = 0; iSystem.out.print(nums[i]+" "); } System.out.println(); //5、获取数组长度 array.length for (int i = 0; isum = sum + nums[i]; } System.out.println("和为 "+sum); }}//执行结果1 2 3 4 5 6 7 8 9 10 和为 55Java 的 for each 循环Java可以用一个功能来依次处理数组中的每个元素（其他类型的元素集合亦可）而不必为指定下标值分心。 这种增强的for循环格式为：for (变量类型 新变量名:数组名) System.out.println(新变量名);int[] a = {1, 3, 8};for (int element: a) System.out.println(element);//执行结果138
打印数组 a 的每一个元素，一个元素占一行。 (优势)这个循环应该被读作“循环a中的每一个元素”(for each element in a)。当然，传统的for循环也可以获得的同样的效果，但是需要花费精力去关心下标的起始值和终止值。 去关心下标的起始值和终止值。
内存分析
三种初始化
静态初始化
int [] a = {1,2,3,4,5,6};
动态初始化
int [] b = new int[10]; b[0]=1; b[1]=2;
数组的默认初始化
数组为引用类型，元素相当于类的实例变量，因此数组如果被分配了空间，其中的每个元素也被按照实力变量同样的方式被隐式初始化。
数组的四个基本特点
其长度是确定的。数组一旦被创建，大小不能改变。其元素必须是相同类型数组中的元素可以是任何的类型，包括引用类型和基本类型数组变量为引用类型，可以看其为对象。数组中元素看其为对象的成员变量。数组本身就是对象，Java中对象在堆中，故数组无论是原始类型还是其他对象类型，数组对象本身都在堆中。
数组边界
下标的合法区间：[0,lenght-1]数组就是相同类型的有序集合数组也是对象，数组元素相当于对象的成员变量数组长度的确定，不可变的，如果越界，报错：java.lang.ArrayIndexOutOfBoundsException:数组越界错误
数组的使用
public class ArrayDemo04 {public static void main(String[] args) {int[] nums = {1,2,3,4,5,6,7,8,9,10};//用for-each 增强型循环遍历数组，但是不可以操控下标值 for (int num : nums) {System.out.print(num+" "); } System.out.println(); System.out.println("======================================="); int[] fan = resever(nums); print(nums); System.out.println(); print(fan); }//反转数组 public static int[] resever(int[] arrays){int[] result = new int[arrays.length]; for (int i = 0,j=result.length-1; i<ARRAYS.LENGTH ;="" {result[j] = arrays[i]; } return result; }//输出数组方法 public static void print(int[] arrays){for (int i = 0; i<ARRAYS.LENGTH ;="" i++)="" {System.out.print(arrays[i]+" "); } }}//执行结果1 2 3 4 5 6 7 8 9 10 =======================================1 2 3 4 5 6 7 8 9 10 10 9 8 7 6 5 4 3 2 1多维数组二维数组int a[][] = new int[2][5];练习：public class ArrayDemo05 {public static void main(String[] args) {//定义二维数组 int[][] a = {{1,3,4},{2,7,6},{7,5,3},{8,5,3}}; //遍历二维数组 for (int i = 0; i <A.LENGTH ;="" i++)="" {for (int j = 0; j System.out.print(a[i][j]+" "); } System.out.println(); } }}Arrays类数组的工具类 ava.util.Arrays;对数据对象进行基本操作查看JDK帮助文档Arrays类中的方法都是static修饰的静态方法，在使用的时候可以使用类名进行调用，不用使用对象来调用（是不用不是不能）常用功能给数组赋值： 通过fill方法给数组排序： 通过sort方法，按升序比较数组：通过equals方法比较数组中元素是否相等。查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。练习：public class ArrayDemo06 {public static void main(String[] args) {int[] a = {1,3,42,7,7,5,38,5,3}; //遍历数组 System.out.println(Arrays.toString(a)); //排序，升序 Arrays.sort(a); System.out.println(Arrays.toString(a)); //给数组赋值 Arrays.fill(a,2,7,22);//第2到第7之间元素被22填充 System.out.println(Arrays.toString(a)); }}
冒泡排序
外层循环：决定排序趟数
内层循环：决定该趟的比较次数。
练习：
package com.array;import java.util.Arrays;public class ArrayDemo07 {public static void main(String[] args) {int[] arrays = {3, 2, 5, 89, 8, 4, 10, 32, 167}; sort(arrays); System.out.println(Arrays.toString(arrays)); } public static void sort(int[] array) {int max = array[0]; int t = 0; //外层循环决定排序多少趟。 for (int i = 0; i < array.length - 1; i++) {boolean flag = false; //内层循环决定每趟比较多少次 for (int j = 0; j < array.length - 1-i; j++) {if (array[j] < array[j + 1]) {t = array[j]; array[j] = array[j + 1]; array[j + 1] = t; flag = true; } if (flag == false ){break; } } } }}//执行结果[167, 89, 32, 10, 8, 5, 4, 3, 2]
稀疏数组
例：
package com.array;import java.util.Arrays;public class ArrayDemo08 {public static void main(String[] args) {//定义初始数组 int[][] begin = new int[10][10]; begin[2][3] = 1; begin[3][4] = 2; begin[4][5] = 3; //输出初始数组 System.out.println("起始数组："); for (int i = 0; i<BEGIN.LENGTH ;="" i++)="" {for (int j = 0; jSystem.out.print(begin[i][j]+"\t"); } System.out.println(); } System.out.println("============================="); //*****转换成稀疏数组 //1、先获取有效值 int sum=0; for (int i = 0; ifor (int j = 0; jif (begin[i][j]!=0){sum++; } } } //2、创建稀疏数组。 int[][] over = new int[sum+1][3]; over[0][0]=10; over[0][1]=10; over[0][2]=sum; //3、赋值 int count = 0; for (int i = 0; i<BEGIN.LENGTH ;="" i++)="" {for (int j = 0; jif (begin[i][j]!=0){count++; over[count][0]=i; over[count][1]=j; over[count][2]=begin[i][j]; } } } //输出稀疏数组 System.out.println("输出稀疏数组："); for (int i = 0; i<OVER.LENGTH ;="" i++)="" {for (int j = 0; j<OVER[0].LENGTH ;="" {System.out.print(over[i][j]+"\t"); } System.out.println(); } System.out.println("============================="); //返回原数组 //创建一个数组； int[][] array = new int[over[0][0]][over[0][1]]; //赋值 for (int i = 1; i<OVER.LENGTH ;="" i++)="" {array[over[i][0]][over[i][1]]=over[i][2]; } //输出数组 System.out.println("输出还原的数组："); for (int i = 0; i<ARRAY.LENGTH ;="" i++)="" {for (int j = 0; j<ARRAY[0].LENGTH ;="" {System.out.print(array[i][j]+"\t"); } System.out.println(); } }}//执行结果起始数组：0000000000000000000000010000000000200000000003000000000000000000000000000000000000000000000000000000=============================输出稀疏数组：10103231342453=============================输出还原的数组：0000000000000000000000010000000000200000000003000000000000000000000000000000000000000000000000000000
