第三章、Java基础——数组

3.1  数组的概念

目录

3.1  数组的概念

3.2  数组的创建

3.3  数组的访问及遍历

3.3 数组排序

1. 冒泡排序

2. 选择排序

3.4 二维数组（多维数组）

---

定义：相同数据类型元素的集合（一组相同数据类型的数）

数组是引用数据类型数据，即对象，可以存储基本类型数据，也可以存储引用类型数据。

特点：存储在内存中的空间是连续的。

声明：

• 数组类型 []   数组名； 

 int []  a;  // 数据类型[] 数组名;（这一种是最好使用的）

• 数组类型   数组名[];   

  int     a[];

  int  表示数组中存储的数据类型。

3.2  数组的创建

//数组创建的三种方式：
//        第一种表示方式：
//        注：默认输出的是对象在内存中的地址。创建数组时，必须为其指定长度，
//而且长度一旦定义了，就不能够改变
        int[] x = new int[6];//在内存在创建了一个长度为6的数组对象。
        System.out.println(Arrays.toString(x));
//        [0, 0, 0, 0, 0, 0]
        double[] y = new double[6];
        System.out.println(Arrays.toString(y));
//        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        float[] z = new float[6];
        System.out.println(Arrays.toString(z));
//        [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
        char[] v = new char[6];
        System.out.println(Arrays.toString(v));
//         [ ,  ,  ,  ,  ,  ]
        String[] w = new String[6];
        System.out.println(Arrays.toString(w));
//        [null, null, null, null, null, null]
//        第二种表示方式：
        int[] r1 = new int[]{1,2,3,4,5,6};//创建数组对象的同时为每个空间赋值。
//        第三种表示方式：（隐式创建）
        int[] r2 = {1,2,3,4,5,6};//为每一个空间赋值，同时确定了数组的长度

3.3  数组的访问及遍历

数组索引（即下标）：就是每一个空间的标号，最小为0，最长为长度减1。

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

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

1. for循环

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

2. 增强for循环：

int t   每次循环声明一个变量，a是要遍历的数组，每循环一次，从数组中挨个取出一个元素，赋值给 t 。

int[] r = {1,2,3,4,5,6};
 for (int t: r
             ) {
            System.out.print(t);
        }

3.3 数组排序

1. 冒泡排序

每一次选择相邻的位置进行比较，满足条件交换位置。

冒泡排序的过程

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

public class Main {
    public static void main(String[] args) {
        int[] maoPao = {5,3,2,4,1};
       //外层循环控制排序的躺数 length-1
        for (int i = 0; i < maoPao.length -1; i++) {
           //内层循环控制每一次，相邻元素之间的比较
            for (int j = 0; j < maoPao.length- 1 - i; j++) {
               if(maoPao[j+1] < maoPao[j]){
                    t = maoPao[j];
                    maoPao[j] = maoPao[j+1];
                    maoPao[j+1] = t;
                }
            }
        }
        System.out.println(Arrays.toString(maoPao));
     }
}
//[5, 4, 3, 2, 1]

  结论： 最多躺数：length- 1（n -1）  最多比较次数：2*length(2*n)

2. 选择排序

选择排序的过程

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

public class Main {
    public static void main(String[] args) {

        int[] paixu = {4,5,3,2,1};
      //循环次数，拿出从第0个位置直到length-1个
        for (int i = 0; i < paixu.length -1; i++) {
            //循环进行比较，第i+1个到最后一个，符合条件进行置换。
            for (int j = i+1; j < paixu.length; j++) {
                if (paixu[i] > paixu[j]) {
                    t = paixu[i];
                    paixu[i] = paixu[j];
                    paixu[j] = t;
                }
            }
        }
        System.out.println(Arrays.toString(paixu));
    }
}
//[1, 2, 3, 4, 5]

结论：最多躺数：length- 1（n -1）  最多比较次数：2*length(2*n)

3.4 二维数组（多维数组）

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

声明：int[][]  a;(建议使用)     int a[][];

public class Main {
    public static void main(String[] args) {

        int[][] a = new int[3][4];
        //3-表示二维数组的长度（里面有几个一维数组）  4-表示一维数组的长度
        //{{0,0,0,0},{0,0,0,0},{0,0,0,0}}
        a[0][1]= 3; //表示0,1位置的值为3
        //二维数组的创建
        int[][] b = new int[3][];
        //二维数组长度为3，里面有三个一维数组，且一维数组的长度可变，
        //可根据需要来创建一位数组的长度
        b[0] = new int[4];
        int[][] c = new int[][]{{1,2,3},{4,5,6},{7,8,9}};
        int[][] d= {{1,2,3},{4,5,6},{7,8,9}};
        System.out.println(Arrays.toString(a[1]));//[0, 0, 0, 0]
        System.out.println(Arrays.toString(b[1]));//null
        System.out.println(Arrays.toString(c[1]));//[4, 5, 6]
        System.out.println(Arrays.toString(d[0]));//[1, 2, 3]
          //二维数组的遍历：
        for (int i = 0; i < d.length; i++) {
            for (int j = 0; j < d[i].length; j++) {
                System.out.print(d[i][j] + " ");
            }
            System.out.println();
        }
              //1 2 3 
              //4 5 6 
              //7 8 9 
    }
}