Java 数组

import java.lang.reflect.Array;
import java.sql.SQLOutput;
import java.util.Arrays;

public class Test4 {
    public static void main(String[] args) {
        // 1、数组
//        String a = null;
//        a = "123"; // String的长度是 length()方法 返回int
//        System.out.println(a);
//        int[] b = new int[10]; // 数组的长度 是 length属性 返回int
//        System.out.println(b.length);

        // 数组一旦创建就不能在改变它的大小（尽管可以改变它的每一个数组元素）
//        String[] s = new String[3];
//        for(int i=0;i<3;i++)
//        {
//            s[i] = "a";
//        }
//        for(int i=0;i<3;i++)
//        {
//            s[i] = "b";
//        }
//        System.out.println(s[0]);

        // String类型不可变的理解
        /*
        String对象一旦创建，实体是不可以变化的，即内容不可以修改。
        过程：
        1、new操作 在堆内存中开辟一块空间 存放“123”;
        2、将空间的起始地址赋值给 栈内存 中的 a, a中存放的是String对象"123"的内存起始地址
        3、对a进行重新赋值的过程，改变的是a中指向的地址。并不是对堆内存中的空间进行修改。
        4、一段时间过后，JVM会对String“123”进行回收。
         */
//        String a = new String("123");
//        System.out.println(a);
//        a = "465";
//        System.out.println(a);
//        a = "2313";
//        System.out.println(a);
        // 数组的 for each 循环，没有 auto
//        int[] a = new int[3];
//        for(int i : a)
//        {
//            System.out.println(i);
//        }

        // 一个简单的打印所有值得方法, Arrays.toString(数组名) 工具类的静态方法
        // 返回一个包含数组元素的字符串，这些元素被放置在括号内，并用逗号分割
//        int[] a = {2, 3, 5, 6, 11, 13};
//        System.out.println(Arrays.toString(a)); // [2, 3, 5, 6, 11, 13]


        // 2、数组拷贝
        // Java中， 允许将一个数组变量拷贝给另一个数组变量。这时两个变量将引用同一个数组。
        // 即修改一个 另一个也会发生改变。
        /*
        浅拷贝：浅拷贝只复制指向某个对象的指针，而不复制对象本身，新旧对象还是共享同一块内存。
        深拷贝：拷贝会另外创造一个一模一样的对象，新对象跟原对象不共享内存，修改新对象不会改到原对象。
         */
//        int[] a = {1, 2, 3};
//        int[] b = a;
//        System.out.println(Arrays.toString(b)); // [1, 2, 3]
//        a[0] = 100;
//        System.out.println(Arrays.toString(b)); // [100, 2, 3]
        // 深拷贝
        // 新建一个数组手动复制，或者Arrays.copyOf()
        //如果数组元素是数值型，那么多余的元素将被赋值为 0 ; 如果数组元素是布尔型，则将赋值
        //为 false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
//        int[] a = {1, 2, 3};
//        int[] b = Arrays.copyOf(a, a.length);
//        System.out.println(Arrays.toString(b)); // [1, 2, 3]
//        a[0] = 100;
//        System.out.println(Arrays.toString(b)); // [1, 2, 3]


        // 3、数组排序
//        int[] a = {3, 2, 1};
//        Arrays.sort(a);
//        System.out.println(Arrays.toString(a)); // [1, 2, 3]
        // Math.random方法将返回一个0到1之间（包含0、不包含1）的随机浮点数。
        // 用 n 乘以这个浮点数，就可以得到从 0 到 n-1 之间的一个随机数。
//        int r = (int) (Math.random() * 10); // r 为 0 ~ 10 包括0 不包括10的随机数。
//        System.out.println(r);

        // 二维数组
//        int[][] a = {
//                {1,2,3},
//                {3,4,5}
//        };
//        // Arrays.deepToString(a) 快速遍历二维数组a
//        System.out.println(Arrays.deepToString(a)); // [[1, 2, 3], [3, 4, 5]]

        // 不规则数组
        /*
        double[][] balances = new double[10][6]; // Java
        等价于
        double** balances = new double*[10]; // C++
         */
        // Java数组可以交换
//        int[] a = {1,2,3};
//        int[] b = {22,33,33};
//        int[] t = a;
//        a = b;
//        b = t;
//        System.out.println(Arrays.toString(a)); // [22, 33, 33]
//        System.out.println(Arrays.toString(b)); // [1, 2, 3]

//        int[][] a = new int[3][]; // 初始化 二维数组的行数
//        for(int i = 0; i < 3; i++)
//        {
//            a[i] = new int[i+1]; // 对每一行初始化数量
//        }
//        for(int i = 0; i < 3; i++)
//        {
//            for(int j = 0; j <= i; j++)
//            {
//                a[i][j] = 45;
//            }
//        }
//        System.out.println(Arrays.deepToString(a)); // [[45], [45, 45], [45, 45, 45]]


    }
}