百木园
数组介绍：
- 可以存放同一类型的数据，包括基本数据类型和引用类型
- 数组也是一种数据类型，引用类型
数组的声明和创建：
- 动态初始化创建 --> 数据类型[] 数组名 = new 数据类型[大小]
- 静态初始创建 --> 数据类型[] 数组名 = {参数1，参数2,.........}
- length获取数组长度 --> 数组名.length
- [0],[1]通过下标赋值和获取 --> 赋值：数组名[0] = 1,获取：print(数组名[i])
-
//静态初始化数组
int[] max = {1,2,3,4}; //静态初始化数组 System.out.println(max.length); System.out.println(max[0]+\" \"+max[1]); //max = {9,8,6}; 数组一旦创建，大小是不可以被改变的
//动态初始化数组 int[] scores = new int[10];//1.动态初始化一个大小为10的数组 scores[0] = 1; //2.通过下标给数组赋值 scores[1] = 2; scores[2] = 3; scores[3] = 4; int sum = 0; for (int i = 0; i < scores.length; i++) { System.out.println(scores[i]);//3.数组中没有赋值的数默认为0 sum+= scores[i];//求数组中的和 } System.out.println(sum); //通过声明数组数组 int[] nums;//声明一个数组 nums = new int[10]//设置数组大小
数组赋值机制：
数组的小细节：
- 数组一旦创建，大小是不能被改变的
- 数组中的元素必须相同，不能出现混合类型
- 数组的元素可以是任意数据类型，包括基本数据类型和引用类型
- 创建数组没有赋值，默认值是0
- 数组下标必须是指定内的，不然下标越界异常 ArrayIndexOutOfBoundsException
for-Each循环：
- 大多用来输出数组中的元素，因为无法操作下标
int[] nums = {4,-1,9, 10,23}; //for-Each循环，nums表示数组，num表示数组里的每一个元素 for (int num : nums) { System.out.println(num); }
反转数组：
- 思路：数组长度一共为5，那么代表下标4-0换，3-1换，一共循环2次
- 定义一共变量，暂时保存替换的数，当下标4和下标0换时，把其中一共下标的数保存到变量中，另一共下标的数替换到，被、保存下标数的位置
- 当替换完成，那么在把保存的数，替换到空下标位
int[] nums = {4,-1,9, 10,23}; int temp = 0; //暂时保存 for (int i = 0; i < nums.length/2; i++) { temp = nums[nums.length - 1 -i ];//保存4下标 nums[nums.length -1 -i] = nums[i];//把0下标给4下标 nums[i] = temp;//0下标获取4下标 } for (int num : nums) { System.out.println(num); }
数组拷贝：
int[] num = {4,-1,9, 10,23};//被拷贝 int[] nums = new int[num.length];//创建一共和被拷贝数组一样大小数组 for (int i = 0; i < nums.length; i++) { nums[i] = num[i];//拷贝 } nums[0] = 200;//改变nums的数，不会影响到num for (int i = 0; i < nums.length; i++) { System.out.println(nums[i]); }
二维数组：
- 理解：文件夹中创建文件夹 等于 二维数组
- 文件夹中创建文件夹在创建文件夹 等于 三维数组 -- 可以一直嵌套
int[][] nums = {{1,2},{3,4},{5,6}};//创建二维数组 System.out.println(nums.length);//长度为3，因只是算一个一个大括号 System.out.println(nums[0][0]);//获取第一个二维数组中，的第一个数组元素 for (int i = 0; i < nums.length; i++) {//循环3次 0-1-2 for (int j = 0; j < nums.length -1; j++) { //循环2次 0-1 System.out.println(nums[i][j]);//获取二维数组所有元素 } }
Arrays[儿微史]工具类：
- 作用：用来操作数组，快捷方便只需要调用封装好的方法即可
- Arrays.toString(nums) --> 输入数组所有元素
- Arrays.sort(nums) ---> 升序排序
- Arrays.fill(nums,2,5,0) ---> 数组填充
double[] nums = {1.1,1.2,66,6,99.9}; System.out.println(Arrays.toString(nums));//输出数组所有元素 Arrays.sort(nums);//给数组排序 System.out.println(Arrays.toString(nums)); Arrays.fill(nums,0);//给数组填充，结果就是全部是0 Arrays.fill(nums,2,4,0);//给数组填充2-4的下标 System.out.println(Arrays.toString(nums));
- 可以通过查看源代码，查看该工具类中有什么方法使用
冒泡排序(重点)：
- 冒泡排序 - 从小到大 - 从大到小的排序
- 思路：如：大-小，拿出一个元素，和元素+1比较，那么比较了所有就会得到最大的数，下一次在比较就可以省略该数，所有每次比较-1
- 优化：数组是顺序，就不进行比较，知道if返回是布尔型通过返回的类型，得知是否进入到if，false代表顺序，true代表进入if不是顺序，flase就跳出循环
//冒泡排序 - 从小到大 - 从大到小 //优化：通过boolean类型变量来判断数组是否是顺序 int[] ares = {1,2,3,4,5,6,7}; int temp = 0;//暂时保存 for (int i = 0; i < ares.length - 1; i++) {//循环4次,-1是因为长度是7，实际循环6次，从0开始所以-1 boolean king = false; //没有交换位置为false for (int j = 0; j < ares.length - i - 1; j++) { // if(ares[j] > ares[j+1]){ //if条件不成立返回false System.out.println(\"参数是否交换\"); temp = ares[j]; //暂时保存 ares[j] = ares[j+1]; ares[j+1] = temp; king = true; //交换位置了为true,if判断返回的值是false和true，不满足条件肯定是false } } if(!king){ System.out.println(\"参数代码\");//输出此代码，代表没有交换 break; } } System.out.println(Arrays.toString(ares));
稀疏数组：
- 压缩信息记录有效信息，如图：把；获取有效值，并获取坐标就好
int[][] ares = new int[11][11]; // 列[9]---行[11] ares[1][2] = 1; ares[2][3] = 2; //1.输出数组 for (int[] are: ares) {//11给元素 for (int a : are) {//11个元素里面的元素 System.out.print(a+\"\\t\");//打印11个元素 } System.out.println(); } //2.转换为稀疏数组-就是获取有值的个数 int num = 0; for (int i = 0; i < ares.length; i++) { for (int j = 0; j < ares.length; j++) { if(ares[i][j]!=0){ num++; } } } System.out.println(\"有效值:\"+num); //3.创建一个存放稀疏数组的，数组 int[][] array2 = new int[num+1][3]; array2[0][0] = 11; array2[0][1] = 11; array2[0][2] = num; //3.1.遍历数组,将非零的值放到稀疏数组 //{{11111111...},{1111...},.....} int count = 0;//记录应该放到稀疏数组的第几行 for (int i = 0; i < ares.length; i++) {//遍历的是每一个二维数组里面的一维数组 // System.out.println(i);//遍历11次 for (int j = 0; j < ares[i].length; j++) {//ares[i].length;遍历的是一维数组里面的元素 //获取有效元素 if(ares[i][j]!=0){//判断了整个二维数组，不等于零的值 ++count;//count变量是记录每增加一行数据，应该放到哪一列中 array2[count][0] = i; System.out.println(\"::::\"+count); array2[count][1] = j; array2[count][2] = ares[i][j]; } } } //4.输出稀疏数组 System.out.println(\"稀疏数组\"); for (int i = 0; i < array2.length; i++) { System.out.println(array2[i][0]+\"\\t\"+ array2[i][1]+\"\\t\"+ array2[i][2]+\"\\t\"); } //还原稀疏数组 System.out.println(\"=====还原稀疏数组=====\"); //1.读取稀疏数组 int[][] array3 = new int[array2[0][0]][array2[0][1]];//大小11,11 //2.给其中元素还原它的值 for (int i = 1; i < array2.length; i++) {//遍历稀疏数组 array3[array2[i][0]][array2[i][1]] = array2[i][2];//给坐标，赋值操作，0是列坐标，1行坐标，2是值 } //3.打印还原数组 for (int[] are: array3) {//11给元素 for (int a : are) {//11个元素里面的元素 System.out.print(a+\"\\t\");//打印11个元素 } System.out.println(); }
案例应用：
//保存26之母到数组 //char是用unicode码，所有可以通过加1来实现字母的赋值 char[] chars = new char[26]; for (int i = 0; i < chars.length; i++) { //循环26次 chars[i] = (char)(\'A\'+i); //i是int类型使用要强转 } for (int i = 0; i < chars.length; i++) { System.out.println(chars[i]); } //求出最大的数，得到下标 int[] nums = {4,-1,9, 10,23}; int max = nums[0]; //假设一个最大值 int maxIndex= 0; //获取下标 for (int i = 0; i < nums.length; i++) { if(max < nums[i]){ max = nums[i]; maxIndex = i; } } System.out.println(max); System.out.println(maxIndex);
来源：https://www.cnblogs.com/Mr-shne/p/16482334.html
本站部分图文来源于网络，如有侵权请联系删除。