java数组专栏——狂神说Java基础笔记

java数组

创建和声明数组

package com.liu.array;

public class ArrayDemo01 {
    // 变量类型  变量名 = 变量值
    // 数组类型
    public static void main(String[] args) {
        int[] nums; //1、声明---首选
        //int nums2[];

        nums = new int[10]; //2、创建
        int sum = 0;

        //3、赋值
        for (int i = 0; i <= 9; i++) {
            nums[i] = i+1;
            sum+=nums[i];
            System.out.println(nums[i]);
        }
        System.out.println("总和为：" + sum); // 5
    }
}

声明创建内存图示 + 下标越界错误提示：

三种初始化

package com.liu.array;

public class ArrayDemo02 {
    public static void main(String[] args) {
        //静态初始化  创建+赋值
        int[] a = {1,2,3,4,5,6,7,8};
        System.out.println(a[0]);

        //引用类型
        Man[] mans = {new Man(), new Man()};

        //动态初始化：包含默认初始化  int:0
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]); //10
        System.out.println(b[1]); //0
    }
}

总结：

数组的使用

1、和及最大最小值：

package com.liu.array;

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

        //打印全部数组元素
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
        System.out.println("================================");

        //计算所有元素的和
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println("和为：" + sum); //15
        System.out.println("================================");

        //查找最大元素
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max < array[i]){
                max = array[i];
            }
        }
        System.out.println("最大值为：" + max); //5
        System.out.println("================================");
    }
}

2、for（没有下标:只适合打印输出）、for-each

package com.liu.array;

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

        //JDK1.5   没有下标:只适合打印输出
        for (int array : arrays) {
            System.out.print(array + "  ");
        }
        System.out.println();

        //打印数组元素
        printArray(arrays);
        System.out.println();

        //反转数组
        int[] reverse = reverse(arrays);
        printArray(reverse);
        System.out.println();
    }

    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + "  ");
        }
    }

    //反转数组
    public static int[] reverse(int[] arrays){
        int[] result = new int[arrays.length];

        //反转的操作
        for (int i = 0, j = result.length - 1; i < arrays.length; i++, j--) {
            result[j] = arrays[i];
        }
        return result;
    }
}

多维数组

图示：

package com.liu.array;

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

        printArray(array[0]);

        System.out.println(array[0][1]);
        System.out.println("=================");

        //遍历多维数组
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j]+ "\t");
            }
            System.out.println();
        }
    }
    //打印数组元素
    public static void printArray(int[] arrays){
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] + "\t");
        }
    }
}

Arrays类

package com.liu.array;

import java.util.Arrays;

public class ArrayDemo06 {
    public static void main(String[] args) {
        int[] a= {1,2,3,456,5657,53,214,4,2,1};
        System.out.println(a); //[I@1b6d3586

        //打印数组元素Arrays.toString
        System.out.println(Arrays.toString(a));
        
        //排序
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

        //填充
        Arrays.fill(a, 0);
        System.out.println(Arrays.toString(a));
    }
}

冒泡排序

package com.liu.array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {
        int[] a = {1,2,43,2,23,5,2,5};
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    //冒泡排序

    public static void sort(int[] a){
        int temp = a[0];

        //排序轮数，最后一个数不要排。因此要length-1
        for (int i = 0; i < a.length-1; i++) {
            boolean flag = false; //通过flag标识减少没有意义的比较
            for (int j = i+1; j < a.length; j++) {
                if (a[i] < a[j]){
                    temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                    flag = true;
                }
            }
            if (flag == false){
                break;
            }
        }
    }
}

稀疏数组

package com.liu.array;

public class ArrayDemo08 {
    public static void main(String[] args) {
        // 创建一个二维数组 11*11   1：黑棋  0：白棋
        int[][] a1 = new int[11][11];
        a1[1][2] = 1;
        a1[2][3] = 2;

        // 输出原始数组
        System.out.println("输出原始数组:");
        // 快捷键：a1.for
        for (int[] ints : a1) {
            // 快捷键：ints.for
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }
        System.out.println("=======================");

        //转换为稀疏数组保存

        //1、获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (a1[i][j] != 0){
                    sum++;
                }
            }
        }

        //打印有效值的个数
        System.out.println("有效值的个数：" + sum);

        //2、创建一个稀疏数组
        int[][] a2 = new int[sum+1][3];
        a2[0][0] = 11;
        a2[0][1] = 11;
        a2[0][2] = sum;

        //遍历二维数组，将非0的值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < a1.length; i++) {
            for (int j = 0; j < a1[i].length; j++) {
                if (a1[i][j] != 0){
                    count++;
                    a2[count][0] = i; // 横坐标
                    a2[count][1] = j; // 纵坐标
                    a2[count][2] = a1[i][j]; //值
                }
            }
        }

        //输出稀疏数组
        System.out.println("输出稀疏数组:");
        for (int i = 0; i < a2.length; i++) {
            for (int j = 0; j < a2[i].length; j++) {
                System.out.print(a2[i][j] + "\t");
            }
            System.out.println();
        }
        /*
            输出稀疏数组:
            11 11 2
            1  2  1
            2  3  2
         */

        System.out.println("======================");

        //还原
        System.out.println("还原");

        //1、读取稀疏数组
        int[][] a3 = new int[a2[0][0]][a2[0][1]];

        //给其中的元素还原值
        for (int i = 1; i < a2.length; i++) {
            a3[a2[i][0]][a2[i][0]] = a2[i][2];
        }

        //打印
        System.out.println("输出还原数组:");
        for (int i = 0; i < a3.length; i++) {
            for (int j = 0; j < a3[i].length; j++) {
                System.out.print(a3[i][j] + "\t");
            }
            System.out.println();
        }
    }
}