自学JAVA-数组、二维数组、数组练习

数组

1.为什么需要数组
    定义26个char类型变量，分别放置26个字母，并把这些变量值打印出来
    
2.数组的概念
    数组是多个相同类型数据的组合，实现对这些数据的统一管理
    数组中的元素可以是任意数据类型，包括基本类型和引用类型，但是不能混用
    可以一次性定义很多变量，并把这些变量从0开始编号(下标/索引),方便存取，
    举例：房间
    
3.数组的语法
    动态初始化
        元素类型[] 数组名 = new 元素类型[数组长度];
        int[] arr = new int[5];
        
    静态初始化
        元素类型[] 数组名 = new 元素类型[]{元素，元素...};
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr = {1,2,3,4,5};
        相当于
        int[] arr = new int[5]
        arr[0]=1;arr[1]=2;arr[2]=3;arr[3]=4;arr[4]=5;

4.数组创建后，没有赋值，那么就是默认值。
    long/int/short/byte 0
    float/double 0.0
    char/ \u0000
    boolean false
    String null
    
5.数组使用步骤
    声明数组
    开辟空间
    给数组各个元素赋值
    使用数组
    
6.数组成员(元素)的赋值和读取

7.数组下标从0开始，下标越界会抛异常
    数组下标越界异常
        int[] arr = new int[3];
        System.out.println(arr[3]);
    空指针异常
        int[] arr;
        
8.数组遍历
    获取数组长度
    获取数组中最大的值
    数组扩容
    
9.数组拷贝
    数组也是一种数据类型，引用类型
    
10.值传递与引用传递
    a.栈内存
        存储局部变量，离开作用域，自动释放
    b.堆内存
        数组和对象，通过new建立的实例都存放在堆内存中
        当没有任何引用指向实例的时候，gc会不定是回收
        实例中的变量都有默认初始化值，建议手动初始化
        引用类型初始化为null
    c.方法区、本地方法区
    
    
public class Hello {
    public static void main(String[] args) {

        // 定义一个char类型的数组

        // 静态初始化
        char[] chars01 = {'a', 'b', 'c', 'd'};
        char chars02[] = {'a', 'b', 'c', 'd'};
        char chars03[] = new char[]{'a', 'b', 'c', 'd'};
        char[] chars04 = new char[]{'a', 'b', 'c', 'd'};
        System.out.println(chars01[0]);
        chars01[0] = 'A';
        System.out.println(chars01[0]);


        // 动态初始化
        char[] chars05 = new char[3];
        chars05[0] = 'a';
        chars05[1] = 'b';
        chars05[2] = 'c';

        char chars06[] = new char[3];
        chars06[0] = 'a';
        chars06[1] = 'b';
        chars06[2] = 'c';

        char chars07[]; // 声明数组
        chars07 = new char[3]; // 开辟空间，数组里面有三个成员
        chars06[0] = 'a';
        chars06[1] = 'b';
        chars06[2] = 'c';


        // 初始化完毕，没赋值的效果
        char[] chars08 = new char[3];
        System.out.println("chars08=" + chars08[0]);


        // 获取数组长度
        char[] chars09 = new char[3];
        System.out.println(chars09.length); // 3

        // 遍历数组
        chars09[0] = 'a';
        chars09[1] = 'b';
        chars09[2] = 'c';

        for (int i = 0; i < chars09.length; i++) {
            System.out.println(chars09[i]);
        }

        int i = 0;
        while (i < chars09.length) {
            System.out.println(chars09[i]);
            i++;
        }


        // 获取数组最大值
        int[] ints01 = new int[5];
        ints01[0] = 100;
        ints01[1] = 200;
        ints01[2] = 300;
        ints01[3] = 400;
        ints01[4] = 500;

        int max_int = ints01[0]; // 假设最大值为第一个成员

        for (int ii = 0; ii < ints01.length; ii++) {
            if (ints01[ii] > max_int) {
                max_int = ints01[ii];
            }
        }
        System.out.println("最大值为:" + max_int);


        // 扩容空间
        // 假设给ints01扩容，必须要新创建一个容器
        int[] ints02 = new int[6];
        for (int iii = 0; iii < ints01.length; iii++) {
            ints02[iii] = ints01[iii];
        }
        ints01 = null;
        ints02[ints02.length - 1] = 600;
        for (int iii = 0; iii < ints02.length; iii++) {
            System.out.println(ints02[iii]);
        }


        // 数组拷贝

        // 值传递
        int a = 100;
        int b = a;
        a = 200;
        System.out.println(a);
        System.out.println(b);

        //引用传递，数组属于引用传递,如果要拷贝一个新的从来，就用到上面的数组扩容
        int[] ints03 = new int[5];
        ints03[0] = 100;
        ints03[1] = 200;
        ints03[2] = 300;
        ints03[3] = 400;
        ints03[4] = 500;

        int[] ints04 = ints03;
        ints04[4] = 300;

        for (int iii = 0; iii < ints03.length; iii++) {
            System.out.println(ints03[iii]);
        }

        
    }
}

二维数组

1.二维数组的定义
    int[][] arr = new int[2][3];
    arr[0][1] = 78;
    
    int[][] arr = new int[2][];
    arr[0] = new int[2];
    arr[1] = new int[3];
    int[][] arr = {{1,2,3},{4,5,6}};
    
2.二维数组的长度
    arr.length // 二维数组长度3
    arr[0].length // 二维数组中第一个一维数组长度
    
3.二维数组的遍历

4.二维数组的其他定义方式
    一维：int[] x;int x[];
    二维：int[][] y;int y[][];
    int[] y[];
    
    int[] x,y[]; // 定义两个数组，x是一维的，y是二维的
    // 中括号跟着变量类型走，一起定义的变量都有效
    // 中括号跟着变量名中，只有当前变量名有效
    // 总结这两句话：
    int a,b; // a，b都是int类型
    int[] a,b; // a，b都是int[]类型
    int[] a,b[]; // a是int[]类型 b是int[][]类型
    
    

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

        // 动态初始化
        int[][] arr = new int[2][3];
        arr[0][0] = 100;
        // arr[0] 是一个数组int[]，arr[0][0] 是int
        arr[0][1] = 78;
        System.out.println(arr[0][0]);
        System.out.println(arr[0][2]);


        // 动态初始化一半
        int[][] arr2 = new int[2][];
        // 完成另一半
        arr2[0] = new int[2];
        arr2[1] = new int[3];


        // 静态初始化
        int[][] arr3 = {
                {1, 2, 3},
                {4, 5, 6}
        };


        // 二维数组的长度
        System.out.println(arr.length);
        System.out.println(arr[0].length);
        System.out.println(arr[1].length);


        // 二维数组遍历
        for (int i = 0; i < arr3.length; i++) {
            for (int j = 0; j < arr3[i].length; j++) {
                System.out.println(arr3[i][j]);
            }
        }


    }
}
    
    

数组练习

import java.util.ArrayList;

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

        // 1.下面数组定义正确的有
//        String strs[] = {'a', 'b', 'c'}; // 不正确，String类型的但是给的是char类型的
//        String strs[] = {"a", "b", "c"}; // 正确，String类型的并且也是给的String类型的，静态定义
//        String strs[] = new String { "a", "b", "c" } ; //不正确，后面跟的是new String，正确写法是String strs[] = new String[]{"a", "b", "c"};
//        String strs[] = new String[]{"a""b""c"}; // 不正确，没逗号
//        String[] strs = new String[3]{"a", "b", "c"}; //不正确，正确写法new String[]{"a", "b", "c"};

        // 2.输出的结果是
        String foo = "blue";
        boolean[] bar = new boolean[2];
        if (bar[0]) {
            foo = "green";
        }
        // boolean的默认值为false
        System.out.println(foo); // blue
        System.out.println("=========");


        // 3.输出的结果是
        char[] arr1 = {'a', 'b', 'c', 'd'};
        char[] arr2 = arr1;
        arr2[2] = 'x';
        // 引用传递，如果不影响arr1的话就要用到数组扩容，也就是新建一个数组
        System.out.println(arr1[2]); // x
        System.out.println("=========");


        // 4.随机生成十个整数，存入数组，倒序打印、求均值、求最大值和最大值下标
        System.out.println(Math.random());
        System.out.println(Math.random() * 100);
        System.out.println((int) (Math.random() * 100));
        System.out.println("=========");

        // 存入数组
        int[] arr = new int[10];
        for (int i = 0; i < 10; i++) {
            arr[i] = (int) (Math.random() * 100);
        }

        // 正序打印
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        System.out.println("=========");

        // 倒序打印
        for (int i = arr.length - 1; i >= 0; i--) {
            System.out.println(arr[i]);
        }
        System.out.println("=========");


        // 求均值
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum / arr.length);
        System.out.println("=========");

        // 求最大值
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
        System.out.println(max);
        System.out.println("=========");


        // 最大值下标
        int max_index = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[max_index] < arr[i]) {
                max_index = i;
            }
        }
        System.out.println(max_index);
        System.out.println("=========");


        // 5.声明int[] x,y[],一下选项允许通过的是
//        int[] x, y[];
//        x = new int[3];
//        y = new int[];
        // 题目
//        x[0] = y; // int[][]->int，报错，首先x是int[]，y是int[][]，x[0]=y，int[][] 无法放入int[]
//        y[0] = x; // int[]->int[],正常
//        y[0][0] = x; // int[]->int，报错
//        y[0][0] = y; // 报错
//        y[0][0] = x[0]; // int->int，正常


        // 6.十进制转十六进制-将该数不断除以16，直到商为0，每步得到的余数倒过来，就是对应的十六进制
        // 32 / 16
        // 1 ... 15
        // 1 / 16
        // 0 ... 1
        // 115
        // 1F


        // 版本1
//        int a = 31;
//        // 集合
//        ArrayList arrayList = new ArrayList();
//
//        while (a > 0) {
//            int temp = a % 16;
//            if (temp == 15) {
//                arrayList.add("F");
//            } else if (temp == 14) {
//                arrayList.add("E");
//            } else if (temp == 13) {
//                arrayList.add("D");
//            } else if (temp == 12) {
//                arrayList.add("C");
//            } else if (temp == 11) {
//                arrayList.add("B");
//            } else if (temp == 10) {
//                arrayList.add("A");
//            }else {
//                arrayList.add(temp);
//            }
//            a = a / 16;
//        }
//        System.out.println(arrayList);


        // 版本2
//        int a = 31;
//        // 集合
//        ArrayList arrayList = new ArrayList();
//        char[] chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
//
//        while (a > 0) {
//            int index = a % 16;
//            arrayList.add(chars[index]);
//            a = a / 16;
//        }
//        System.out.println(arrayList);


        // 版本3
        int a = 31;
        StringBuffer stringBuffer = new StringBuffer();
        char[] chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
        while (a != 0) {
            int index = a % 16;
            char temp = chars[index];
            stringBuffer.append(temp);
            a = a / 16;
        }
        System.out.println(stringBuffer.reverse().toString());

    }
}