Java数组基础 # 笔记

目录

1、Java数组概念

2、数组的创建

一维数组

1、数组声明的两种方式：

2、数组的创建

值得注意的是：

3、数组的最大值

4、数组的访问和迭代

1、数组元素的访问：

2、数组的迭代（遍历）

1、第一种：for循环

2、第二种：增强for循环

 5、数组的排序

1、冒泡排序：

2、选择排序

二维数组

1、二维数组定义

2、二维数组的声明

3、二维数组的创建

4、二维数组的遍历 

---

1、Java数组概念

• 数组是一组相同数据类型元素的集合，是一个容器。
• 数组本身是引用数组类型，是一个对象。
• 数组可以存储基本数据类型，也可以存储引用数据类型。
• 数组创建时必须指定长度，且长度不可变。
• 数组中每个元素空间是连续的。

2、数组的创建

• 一维数组

1、数组声明的两种方式：

1. 数据类型 [ ]  数组名字
2. 数据类型  数据的名字 [ ]

   //声明
    int[] array;
    int arr[];

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

2、数组的创建

• 创建一个容量为5的一个数组,使用默认值对其进行初始化 。

        int[] ary0 = new int[5];

• 创建数组同时将其用指定的值初始化,有几个元素容量就是多少。

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

        还可以简化为下面写法

        int[] ary2 = {1, 2, 3, 4, 5}

       public static void main(String[] args) {
        //1.声明 创建数组
        int[] a = new int[5];//new 创建一个数组，并指定数组的长度（容量）每个空间会赋值一个默认值0
        System.out.println(a);//地址：[I@1b6d3586 数组在内存中的地址(hash值)
        //Arrays类，Java语言中提供的用于操作数组的工具类，提供排序，二分查找，数组复制....
        System.out.println(Arrays.toString(a));//[0, 0, 0, 0, 0] toString(): 把数组以字符串的形式返回，便于调试查看


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


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


        String[] strings = new String[6];//引用类型的默认值都是null
        System.out.println(Arrays.toString(strings));//[null, null, null, null, null, null]


        boolean[] d = new boolean[5];//boolean类型的默认值都是false
        System.out.println(Arrays.toString(d));//[false, false, false, false, false]

    }

值得注意的是：

int类型的默认值：0

boolean类型的默认值：false

String引用类型的默认值：null

3、数组的最大值

数组长度最大值就是int的最大值Integer.MAX_VALUE {-2^31~2^31 - 1}（有上限）

报错：OutOfMemoryError：超出系统的最大值

报错:  NegativeArraySizeException:  超出数组的最大值

public static void main(String[] args) {
        //数组最大值
        int[] a = new int[Integer.MAX_VALUE];//报错：OutOfMemoryError
        int[] b = new int[Integer.MAX_VALUE+1];//报错: NegativeArraySizeException
    }

4、数组的访问和迭代

1、数组元素的访问：

  数组名[索引/下标]  例如：a[0],a[1];

• 注意

      数组的索引从0开始。

      索引的数据类型是整数（int）

      数组长度最大值就是int的最大值Integer.MAX_VALUE {-2^31~2^31 - 1}（有上限）

      数组最大索引=长度-1

• 获取数组长度

        数组名.length

2、数组的迭代（遍历）

1、第一种：for循环

public static void main(String[] args) {
        int[] a = new int[5];
        a[4] = 10;
        //for循环遍历数组
        for (int i = 2; i < a.length; i++) {
            System.out.println(a[i]);
        }
}

2、第二种：增强for循环

 增强for循环遍历数组：适合挨个的遍历每一个元素。索引默认从0开始。

  for (数组元素的类型   临时变量名字  ： 数组的名字 ) {

         System.out.println(临时变量名字 );

}

       
        //a: 遍历的数组
        //int t:声明一个临时的变量，用来接收每次循环时，从数组中取出的元素，索引默认从0开始
        for (int t : a) {
            System.out.println(t);
        }

 5、数组的排序

1、冒泡排序：

每次取出相邻的两个元素进行比较，将较大的向后移，每比较一趟，可以找出一个最大值。

例如：
5,4,3,2,1
第一趟
4,3,2,1,5
第二趟
3,2,1,4,(不用比较)5
第三趟
2,1,3,(不用比较)4,5
第四趟
1,2,3,4,5

public static void main(String[] args) {
        int a[]={5,4,3,2,1};
        for(int i=0;i< a.length-1;i++){//外层循环 控制比较的趟数
            for(int j=0;j<a.length-1-i;j++){//内层循环，相邻的两个元素进行比较 j j+1
                if(a[j]>a[j+1]){
                    int temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }

2、选择排序

 选择排序：
        从当前元素开始，与之后的每一个元素进行比较，将较小的交换到当前位置，

例如：

5，4，3，2，1

第一趟

1，5，4，3，2(45321,35421,25431,15432)

第二趟

1，2，5，4，3(14532,13542,12543)

第三趟

1，2，3，5，4(12453,12354)

第四趟

1，2，3，4，5(12345)

public class D_5selectSort {
    public static void main(String[] args) {
        int a[] = {5, 4, 3, 2, 1};
        //交换的次数较多
        for (int i = 0; i < a.length - 1; i++) {//控制比较的趟数
            for (int j = i + 1; j < a.length; j++) {
                if (a[i] > a[j]) {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(a));
        System.out.println("-----------优化------------");
        for (int i = 0; i < a.length - 1; i++) {
            int minindex = i;
            for (int j = i + 1; j < a.length; j++) {
                if (a[minindex] > a[j]) {
                    minindex = j;//记录最小值的位置，先不做交换
                }
            }
            //将最小值和第一个没有排序的位置交换
            int t = a[i];
            a[i] = a[minindex];
            a[minindex] = t;
        }
        System.out.println(Arrays.toString(a));
    }
}

• 二维数组

1、二维数组定义

二维数组(或者多维数组)：数组的数组，数组中的每一个元素又是一个一维数组

例如：int [ ][ ]a ={ {1，2，3}，{1，2，3}，{1，2，3} };

2、二维数组的声明

int[][] a;//声明一个二维数组
int b[][];//这种方式也对，但是不建议使用，容易混淆a的数据类型

3、二维数组的创建

1、int[][] a = new int[3][5];
/*
   [3]:表示二维数组的长度为3
   [5]:表示二维数组中，每一个一维数组的长度是5
   {{0，0，0，0，0}，{0，0，0，0，0}，{0，0，0，”0“，0}}
       0                1              2
*/

2、int[][] a = new int[3][];//这种也是正确的
/*
   只声明了二维数组的长度是3，并没有声明二维数组中的一维数组的长度，也就不会创建一维数组。数组本身其实是引用类型。初始值为null
   {null,null,null

*/

 public static void main(String[] args) {
        //初始化1
        int[][] a1 = new int[3][5];
        //初始化1.2
        int[][] a = new int[3][];
        //给每一个二维数组单独的赋值一个一维数组
        b[0] = new int[]{1,2,3};
        b[1] = new int[]{4,0,0};
        b[2] =new int[]{3,4,0};
}

给每一个二维数组单独的赋值一个一维数组，可得结果如下：

 

3、int[][] c = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

4、int[][] d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        //初始化2
        int[][] c = new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        //初始化3
        int[][] d = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        System.out.println(c[2][1]);//8
        System.out.println(d[0][1]);//2

4、二维数组的遍历 

利用forfor循环

 public static void main(String[] args) {

        int[][] a = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
        for (int i = 0; i < a.length; i++) {//对二维数组进行遍历
            for (int j = 0; j < a.length; j++) {
                System.out.print(a[i][j] + "\t");
            }
            System.out.print("\n");
        }
    }