(java)数组 - 悦读

为了存储同一类型的多个数据，我们引入数组。

1. 一维数组

1.1 数组定义方式

语法格式：数据类型[] 数组名 = {数据1,数据2,数据3}; 或数据类型[] 数组名 = new 数据类型[] {数据1,数据2,数据3};

数组中的存储的每一个数据，我们叫元素。

//第一种定义数组   
//数组的命名可以根据存储的数据类型 例如存储的是数字，可以使用 int[] numbers = {1,2,3};
int[] arr = {12,13,14};//简写
int[] numbers = new int[]{1,2,3};//完整写法

注意: “数据类型[] 数组名”也可写成 “数据类型数组名[] ”，我们一般写在数据类型之后。

另一种定义方式，先定义，后赋值：

定义时，需要明确数组的数据类型和长度

//第二种定义数组   
 int[] arr =new int[3];//提前定义数组长度为3 ，这也就为什么说数组的长度是被写死的。

注意：此时的数组如果在控制台查看数组是可以看到初值的，堆中的数据都有初值，栈中的数据没有初值。

针对不同的数据类型，数组会给与不同的初值，对于数字类整数型为0，小数型为0.0，布尔值为false，引用数据类型为null

1.2 数组存储原理

对于数组的存储，可以看到
在这里插入图片描述

此时直接打印数组arr,结果为[I@776ec8df ，输出的arr是其地址，不是数据，其中[表示数组，I表示存储int类型，@为分隔符，后面为存储地址。

案例：数据存储原理

        int[] arr1 = new int[]{1,2,3,4,5,6,7,8,9};
        int[] arr2 = new int[]{1,2,3,4,5,6,7,8,9};
        arr1 = arr2;
        arr1[0] =100;
        arr1[0] =200;
        System.out.println(arr1[0]);
        System.out.println(arr2[0]);

根据计算机原理：arr1 = arr2; 作用是把arr2的地址给arr1，也就是说，arr1和arr2存储的都是在堆中存储的数组{1,2,3,4,5,6,7,8,9}的地址。

补充：引用数据类型—字符串的特殊性。

//字符串虽然为引用数据类型，却比较特殊
        String str1 = "aaa";
        String str2 = "bbb";
        str2 = str1;
        str1 = "ccc";
        System.out.println(str2);//aaa
//此处的str1 = "ccc";意思先创造一个"ccc"字符串，之后把其地址给str1

1.3 数组元素访问/数组属性

定义数组之后，通过对于数组中数据进行从0开始的编号，如果我们需要访问其中的数据，可以通过索引进行访问

语法格式：数组名[索引号]

//数组元素输出、输入、以及数据length属性

int[] arr = {1, 24, 22};
System.out.println(arr[0]);//1 输出
arr[0] = 100;
System.out.println(arr[0]);//100 存储
System.out.println(arr.length);//3 输出的是数组属性，不是方法，输出结果为数组长度

1.4 数组遍历

对于一共数组而言，用fori循环，i从0开始，到arr.length结束，用arr[i]对数组遍历是最常见的方法

语法缩写：数组名.fori 或 数组名.for

//遍历数组  fori循环 
int[] arr = {1,2,3,4,5};
for (int i = 0; i < arr.length; i++) {
     System.out.println(arr[i]);
}

//遍历数组 增强型for循环(for-each)
for (int nums:arr){
     System.out.println(nums);
}

数组案例:随机生成1-100，用一个10个数的数组装填，要求没有重复【难】

//案例—个人做法
//因为每次都选择遍历数组全部内容，运算比较笨拙，且效率不高。
public class Firstjava {
    public static void main(String[] args) {
        Random r = new Random();
        int[] arr = new int[10];
        int count = 0;
        //判断是否相同
        wc:while (count<10) {
            int num = r.nextInt(100) + 1;
            //此for只用来进行相等判断
            for (int i = 0; i < arr.length; i++) {
                if (arr[i] == num) {
                    break wc;
                }
            }
            arr[count] = num;
            count++;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

老师做法（一）：

//案例-老师做法
public class Firstjava {
    public static void main(String[] args) {
        Random r = new Random();
        int[] arr = new int[10];
        int i;
        int j;
//开始进行循环判断
        for (i= 0;i <arr.length; ) {
            int num = r.nextInt(100) + 1;
            for (j = 0; j < i; j++) {
                if (arr[j] == num) {
                    //判断
                    break;
                }
            }//内层循环
            if (i == j) {
                arr[i] = num;
                i++;
            }
        }//外层循环
        cheng(arr);
    }//main
    public static  void cheng(int[] arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

老师做法（二）：

 public static void main(String[] args) {
        int[] numbers = new int[10];
        Random r = new Random();
        boolean isFind = false;
        for (int i = 0; i < numbers.length; ) {
            int num = r.nextInt(10) + 1;
            numbers[i] = num;
            isFind = false;
            for (int j = 0; j < i; j++) {
                //这个循环让 j从0到 i-1,说明了就是拿刚生成的随机数numbers[i]与前面的所有数进行比较
                //numbers[i]就是刚生成的随机数
                if (numbers[i] == numbers[j]) {
                    //说明有重复
                    isFind = true;
                    break;
                }
            }
            //跳出循环时,是比较完都不同,还是因为有相同跳出了循环
            if (!isFind) {
                i++;
            }
        }//wc for
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }

2. 二维数组

2.1 数组命名

语法：数据类型[][] 数组名 = new 数据类型[][]{{数组1}, {数组2}, {数组3}, …};

访问语法：数组名称[行索引] [列索引];

整体上根一维数组极为相似，但是是两个中括号表示两个维度

//二维数组第一种命名方法
int[][] arr = {{1,2,3,},{4,5,6},{7,8,9}};
System.out.println(arr[2][0]);//7

另一种命名方法：定义时，行数必须，列数非必须

//定义数组时，直接规定行数和列数
int[][] arr1 = new int[3][4];//如果定义时，直接规定行和列，接下来可以直接调用数组中的具体空间进行赋值


//定义数组时，只先规定行数，后规定列数
int[][] arr2 = new int[3][];//只定义行，先不定义列
arr2[0] = new int[4];//对于某一特定行，重新规定其列数
arr2[0][3] = 5;//此时可以访问第0行的元素
arr2[1][0] = 6;//但是此时第1行没有列，所以运行会报错

//补充：对于二维数组的列来说，其定义方式只能写完整写法
int[][] arr = new int[3][];
arr[0] = new int[]{1, 2, 3};
arr[1] = {1,2,3};//错误写法

2.2 数组遍历

二维数组遍历—关键在于表达第二层for循环

第二层for循环缩写可以写为： arr[i].fori

        int[][] arr = {{1,2,3},{4,5,6},{7,8,9},{7,8,9}};
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }

例子：二维数组的打乱—关键在于生成的随机位置的横竖坐标。

public class Firstjava {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9,10,11}};
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                int row = r.nextInt(arr.length);//生成随机行
                int colomn = r.nextInt(arr[row].length );//生成随机行所对应的列数
                int emp = arr[i][j];
                arr[i][j] = arr[row][colomn] ;
                arr[row][colomn] = emp;
            }
        }
        
        //遍历输出
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+"\t");
            }
            System.out.println();
        }