04、Java数组（狂神说）

• 数组是相同类型数据的有序集合

• 数组描述的是相同类型的若干数据，按一定的先后次序排列组合而成

• 其中，每一个数据称作一个数组元素，每个数组元素可通过一个下标访问

01数组的声明和创建

声明：int[] arrays;

创建：arrays=new int[10];

定义：

数据类型[] 数组名=new 数据类型[数组大小];

eg;int[] arrays=new int[10];

数组长度：数组名.length

02Java内存分析

堆：

• 存放new对象和数组

• 可以被所有线程共享，不会存放别的对象的引用

栈：

• 存放基本变量类型（包含这个基本变量的具体数值）

• 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区：

• 可以被所有线程共享

• 包含所有class和static变量

03数组初始化

 //静态初始化
 int[] a={1,2,3};
 Man[] mans={new Man(1,1),new Man(2,2)};
 ​
 //动态初始化
 int[] b=new int[2];
 a[0]=1;
 a[1]=2;

04数组的基本特点

• 长度确定。数组一旦被创建，大小就不可以改变

• 所有元素必须是相同类型，类型可以是任意类型

• 数组变量属于引用类型，数组是对象，数组对象在堆中

05二维数组

 //定义一个两行五列的数组
 int[][] array={{1,2,3},{4,5,6}};
 ​
 //打印二维数组
 for (int i = 0; i < array.length; i++) {
     for (int j = 0; j < array[i].length; j++) {
         System.out.println(array[i][j]);
     }
 }

06Arrays类

方法：

• 打印数组元素：Arrays.toString()

• 数组元素升序排序：Arrays.sort()

eg：

 int[] a={1,2,3,4,999,234};
 //打印数组元素
 System.out.println(Arrays.toString(a));
 //数组元素升序排列
 Arrays.sort(a);
 System.out.println(Arrays.toString(a));

07冒泡排序

1. 比较数组中两个相邻的元素，若第一个元素比第二个大，则交换他们的位置

2. 每次比较都会产生一个最大或最小的元素

3. 下一轮可以减少依次排序

4. 依次循环，直到结束！

 //临时变量
 int temp=0;
 ​
 //外层循环，判断要走多少次
 for (int i = 0; i < array.length-1; i++) {
     //内层循环：比较两个数，若第一个数大于第二个数，交换位置
     for (int j = 0; j < array.length - 1 - i; j++) {
         //array[j+1]>array[j]:降序
         //array[j+1]<array[j]:升序
         if(array[j+1]>array[j]){
             temp=array[j];
             array[j]=array[j+1];
             array[j+1]=temp;
         }
     }
 }

08稀疏数组

• 当一个数组中大部分元素为0，或为同一值时，可以用稀疏数组保存该数组

 int[][] array1=new int[11][11];
 array1[1][2]=1;
 array1[2][3]=2;
 ​
 System.out.println("输出原始数组：");
 ​
 for (int[] ints:array1){
     for (int anInt:ints){
         System.out.print(anInt+"\t");
     }
     System.out.println();
 }
 ​
 //转换为稀疏数组保存
 //获取有效值的个数
 int sum=0;
 for (int i = 0; i < 11; i++) {
     for (int j = 0; j < 11; j++) {
         if (array1[i][j]!=0){
             sum++;
         }
     }
 }
 System.out.println("有效值的个数为："+sum);
 ​
 //创建一个稀疏数组的数组
 int[][] array2=new int[sum+1][3];
 ​
 array2[0][0]=11;
 array2[0][1]=11;
 array2[0][2]=sum;
 ​
 //遍历二维数组，将非零的值，存放在稀疏数组中
 int count=0;
 for (int i = 0; i < array1.length; i++) {
     for (int j = 0; j < array1[i].length; j++) {
         if (array1[i][j]!=0){
             count++;
             array2[count][0]=i;
             array2[count][1]=j;
             array2[count][2]=array1[i][j];
         }
     }
 }
 ​
 //输出稀疏数组
 System.out.println("稀疏数组：");
 for (int i = 0; i < array2.length; i++) {
     for (int j = 0; j < array2[i].length; j++) {
         System.out.print(array2[i][j]+"\t");
     }
     System.out.println();
 }
 ​
         //读取稀疏数组
         int[][] array3=new int[array2[0][0]][array2[0][1]];
 ​
         for (int i = 1; i < array2.length; i++) {
             array3[array2[i][0]][array2[i][1]]=array2[i][2];
         }
 ​
         System.out.println("输出还原数组：");
 ​
         for (int[] ints:array3){
             for (int anInt:ints){
                 System.out.print(anInt+"\t");
             }
             System.out.println();
         }