Day6-笔记（数组、稀疏数组、冒泡排序、内存分析-堆-栈）

数组

数组的定义： 数据类型 [] 数组名

数组的四个基本特点：

1、长度确定，不可变，如果越界则报 ArrayIndexOuttoBoundsExpection

2、类型相同。数组是相同数据类型的有序集合

3、数组中的元素可以是任何数据类型。包括基本类型和引用类型。

4、数组变量属于引用类型，数组可以看成是对象，数组中的每个元素相当于该对象的成员变量。

数组本身是在堆中的。

       public static void main(String[] args) {
        int[] nums;   // 定义  ----首选方法   数据类型 [] 数组名
        int nums2[];  //效果相同，但是不是首选方法
        nums = new int[10];  //可以存放十个 int类型的数字   定义之后需要new一个数组出来。
        System.out.println("length:" + nums.length);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i * i;
            sum = sum + nums[i];
            System.out.println("nums[" + i + "]:" + nums[i]);
        }
        //System.out.println(nums[10]);   数组下标越界异常
        System.out.println("sum:" + sum);
    }

public static void main(String[] args) {
        //静态初始化
        int[] arrys = {1, 2, 3, 4, 5, 6, 7, 8};
        //动态初始化
        int[] arrys2 = new int[10];   //默认值 int初始化为0
        arrys2[0] = 100;
    	//取不到下标，JDK1.5 以上可以使用
        for (int b : arrys2) {
            System.out.println(b);
        }
        System.out.println(arrys2[0]);
        for (int arry : arrys) {    //增强for,  数据类型  变量: 数组或者集合
            System.out.println(arry);
        }
    }

arrays.for 可以自动生成for each 循环

内存分析

JAVA内存分析：

堆：存放new的对象和数组。可以被所有的线程共享，不会存放别的对象引用

栈：存放基本变量类型（包含这个基本类型的具体数值）

​ 引用对象的变量（会存放这个引用在堆里面的具体地址）

方法区：可以被所有线程共享，包含了所有的class和static变量。

java.lang.ArrayIndexOutOfBoundsException: 10 数组下标越界异常

数组的使用及反转

    public static void main(String[] args) {
        int[] arrays = {1, 2, 3, 4, 5};

        printArray(arrays);
        int[] reArrays = reverseArray(arrays);  //接收返回的数组并打印
        printArray(reArrays);
    }

    //反转数组，数组做返回值
    public static int[] reverseArray(int[] arrays) {
        int[] result = new int[arrays.length];
        for (int i = 0, j = result.length - 1; i < result.length; i++, j--) {
            result[i] = arrays[j];
        }
        return result;
    }

    //打印数组，增强for无法使用下标
    public static void printArray(int[] arrays) {
        for (int array : arrays) {
            System.out.print(array + " ");
        }
        System.out.println();
    }

多维数组

 public static void main(String[] args) {
        //[4][2]   4行两列
        int[][] arrays = {{0, 0}, {1, 1}, {2, 2}, {3, 3}};
        printArray(arrays[0]);
        printArray1(arrays[1]);
        //循环打印二维数组
        for (int i = 0; i < arrays.length; i++) {
            for (int j = 0; j < arrays[i].length; j++) {
                System.out.print(" " + arrays[i][j]);
            }
            System.out.println();
        }
    }
    //方法要写在main外面才能调用，不要在犯错了。
    //for循环打印数组
    public static void printArray ( int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.println("arrays[" + i + "]:" + arrays[i]);
        }
        System.out.println();
    }
    //增强for打印数组
    public static void printArray1 ( int[] arrays){
        for (int array : arrays) {
            System.out.print(array + " ");
        }
        System.out.println();
        System.out.println();
    }

多维数组可以看成每个数组下标里再包含一个数组。

冒泡排序

 public static void main(String[] args) throws InterruptedException {
        int[] array = {1, 2, 5, 6, 990, 880, 3457, 980, 8980, 34894, 340596};

//        System.out.println(array); //[I@7f31245a---hashCode
//        Arrays.sort(array);  //升序排序
        System.out.println(Arrays.toString(array));
        long starttime = System.currentTimeMillis();   //程序开始运行时间
        Thread.sleep(300);  //让线程休眠0.3秒
        printMPPX(array);
        long endtime = System.currentTimeMillis();     //程序结束运行时间
        //程序实际运行时间
        double upTime = new BigDecimal(endtime - starttime).divide(new BigDecimal(1000)).doubleValue();
        System.out.println("排序后：" + Arrays.toString(array));
        System.out.println("用时：" + upTime);
    }

    //冒泡排序
    public static int[] printMPPX(int[] array) {
        int temp = 0;
        boolean flag = false;  //通过标识位减少不必要的判断
        //外层循环，控制总共走多少次，因为数组从0开始，所以是长度-1
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，控制每次排序多少趟，依次递减
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] > array[j]) {   //后边的比前边的大，交换，大的在前面，小的在后面
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    flag = true;
                }
                if (flag == true)
                    break;
            }
        }
        return array;
    }

稀疏数组

稀疏数组的创建以及还原

//1.创建一个二维数组，0无棋子，1：黑棋，2：白棋
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 1;
        array1[3][4] = 1;
        array1[2][4] = 2;
        //输出原始的数组
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        //获取有效值的个数，并转换为稀疏数组保存
        int sum = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1.length; j++) {
                if (array1[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数：" + sum);

        //创建一个稀疏数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
        //遍历二维数组，将非零的值存到稀疏数组里
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j] != 0) {
                    count++;
                    array2[count][0] = i; //行
                    array2[count][1] = j; //列
                    array2[count][2] = array1[i][j]; //值
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t" + array2[i][1] + "\t" + array2[i][2] + "\t");
        }
        //稀疏数组还原
        System.out.println("===============================================");
        // 1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]]; //array2行的长度以及列的长度赋给array3
        // 2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
        // 3.打印还原后的稀疏数组
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

Day7-笔记