数组[java]

⛳️数组的基本概念及作用

概念：存储一组数据类型相同的元素，在内存中空间是连续的，长度一旦给定，就不能改变了。

作用：数组属于引用类型数据，即对象。可以存储基本数据类型，也可以存储引用数据类型。

⛳️数组的创建

数组的声明的两种方式：

① 数据类型 [] 数组名字

例如：

int [] a;//推荐使用

② 数据类型 数组的名字 []

例如：

int a [];

注意： Java中两种声明方法没有任何区别，但是建议使用第一种， 避免混淆a的数据类型。

数组创建的三种方式：

① 动态数组：声明数组的同时，根据指定的长度分配内存，但数组中元素值都为默认的初始化值

int [] a = new int[10];//创建一个长度为10的连续空间
System.out.println(Arrays.toString(a));
//[0,0,0,0,0,0,0,0,0,0]
float [] f = new float[10];
System.out.println(Arrays.toString(f));
//[0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0]
char [] c = new char[10];
System.out.println(Arrays.toString(c));
//[ , , , , , , , , , ]
boolean [] b = new boolean[10];
System.out.println(Arrays.toString(b));
//[false,false,false,false,false,false,false,false,false,false]
String [] s = new String[10];
System.out.println(Arrays.toString(s));
//[null,null,null,null,null,null,null,null,null,null]

②方式2：创建数组的同时，为数组每个空间赋值，同时确定了数组的长度

int[] b = new int[]{1，2，3，4，5};
System.out.println(Arrays.toString(b));
//[1,2,3,4,5]

③方式3：隐式创建

int[] c = {1，2，3，4，5};//数量固定已知时使用
System.out.println(Arrays.toString(c));
//[1,2,3,4,5]
String [] s = new String[]{"a","b","c"};//引用类型存储
System.out.println(Arrays.toString(s));
//[a,b,c]

动态数组和静态数组：

动态创建数组：没有为元素赋值，可以结合for循环进行赋值

char[] chAry = new char[10]; 

静态创建数组：在创建的时候，即为每个元素赋初值

int[] ary1 = new int[]{1, 2, 3, 4, 5}; 

数组的长度：length

int [] b1 = new int []{1,2,3,4,5,6,7}; 
System.out.println(b1.length);

⛳️数组的访问与迭代

数组元素的访问：

数组名字[索引]

数组索引：就是每一个空间的标号。

[0,0,0,0,0,0,0,0,0,0]
 0 1 2 3 4 5 6 7 8 9 

int[] a = new int[4];
//为数组指定空间位置赋值
a[0]=1;
a[3]=4;
//[1,0,0,4]
System.out.println(Arrays.toString(a));
//1  获得数组指定位置的值
System.out.println(a[1]);

 

注意：

①数组的索引从0开始

②索引的数据类型是整型

③索引最大值：length-1

数组迭代的两种方式：

①for循环 ：更加灵活，可以精确的控制。

数组元素的遍历：使用循环生成数组的索引，获取每一个位置的值。

int[] a = {1,2,3,4,5,6,7}
for(int i = 0; i < a.length; i++){
   System.out.println(a[i]);
}

②增强for循环：

//int i :每次循环声明一个变量
//a是要遍历的数组
//没循环一次，从数组中挨个取出一个元素，赋值给t
int[] a = {1,2,3,4,5,6,7}
for(int t : a){
   System.out.println(t);
}

⛳️数组排序

冒泡排序：每次拿出两个相邻的比较大小，满足条件交换位置。

原数组 4，5，2，3，1
      4，2，3，1，5//第一趟
      2，3，1，4，5//第二趟
      2，1，3，4，5//第三趟
      1，2，3，4，5//第四趟

代码：

public static void main(String[] arges) {
   int [] a = {4,5,2,3,1};
   //外层循环控制循环的次数 length-1
   for(int i = 0; i < a.length; i++){
      //内层循环：比较相邻元素
      for(int j = 0; i < a.length-1-i; i++){
        if(a[j]>a[j+1]){
            int temp = a[j];
            a[j+1] = temp;
        }
     }
  }
    System.out.println(Arrays.toString(a));
}

选择排序：

public static void main(String[] arges) {
     int [] a = {4,5,2,3,1};
    //循环次数，拿出从第0个到length-1个
     for (int i = 0; i < a.length-1; i++){
         //循环制造比较的数，i+1到最后一个
         for (int j = i+1; ja[j]){
             int temp = a[i];
             a[i] = a[j];
             a[j] = temp;
         }
      } 
   }
    System.out.println(Arrays.toString(a));//[1,2,3,4,5]
}

优化后：

public static void main(String[] arges) {
     int [] a = {3,4,2,5,1};
     for (int i = 0; i < a.length-1; i++){
         int minIndex = i;
         for (int j = i+1; ja[j]){
             minIndex = j;//记录较小的值的位置
         }
      } 
      int temp = a[minIndex];
      a[minIndex] = a[i];
      a[i] = temp;
   }
    System.out.println(Arrays.toString(a));//[1,2,3,4,5]
}

IDE中debug调试功能：

断点：开始调试程序的位置

以debug模式启动程序

常用快捷键：F8(一行一行执行),F9(程序运行结束)

⛳️二维数组(多维数组)

定义：数组中的每一个元素又是一个数组。

例如：

int [][]a = {{1,2,3},{1,2,3},{1,2,3}};
int [][]b = new int[][]{{1,2,3},{1,2,3},{1,2,3}};

二维数组声明的两种方式：

int [][] a;
int a2[][];

例如：

//3表示二维数组长度(里面有几个一维数组)
//4表示一维数组长度
//{{0,0,0,0}{0,0,0,0}{0,0,0,0}}
//  0,1,2,3  0,1,2,3  0,1,2,3
//     0         1        2 
int [][] a = new int[3][4];
​
int [][] b = {{1,2,3},{4,5,6},{7,8,9}};
//6 第一个位置的一维数组的第二个位置的值
System.out.println(b[1][2]);

注意：一维数组可以不给长度,每个一维数组的长度不固定时可以使用这种声明方式。

例如：

//表示二维数组长度是3，里面的一维数组为null,没有创建，运行时根据需要创建一维数组
int [][] a = new int[3][];
//a[0] = new int[4];
//a[1] = new int[5];
//a[1] = new int[6];
System.out.println(Arrays.toString(a));//[null,null,null]

二维数组的迭代：

public static void main(String[] arges) {
int[][] b = {{1,2,3},{4,5,6},{7,8,9}};
    for(int i = 0; i < b.length; i++){
        System.out.print(b[i][j]+" ");
    }
    System.out.print();
    //1 2 3
    //4 5 6
    //7 8 9    
}