(五)Java数组---狂神说Java

1.数组概念

2.数组内存分析

3数组初始化：

创建main注意：一个java文件只有一个public类

class Man{}
public class Demo1 {
    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
    }

4 数组下标越界及小结

数组四个基本特点

数组边界

5.数组的使用

快捷键 fori回车 快速写循环

1. 普通for循环
2. for each
3. 数组作为入参
4. 作为返回值
   数组打印，查找最大值

       int[] array = {1,2,3,4,5};
        //打印全部数组元素
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        //查找最大元素
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(max < array[i]){
                max = array[i];
            }

数组打印

//JDK1.5   没有下标:只适合打印输出
        for (int x : arrays) {
            System.out.print(x+ "  ");
        }
**```
反转数组**

```java
//反转数组
    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;
    }

6.多维数组

public class ArrayDemo2 {
    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");
        }
    }
}

7.Arrays类

点进类看见源码，点击structure看见方法

import java.util.Arrays;

public class ArrayDemo3 {
    public static void main(String[] args) {
        int[] a= {14,26,3,456,56,53,6666,4,2,1};
        System.out.println(a); //[I@1b6d3586,输出对象，hash处理

        //打印数组元素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));
    }

输出

[I@14ae5a5
[14, 26, 3, 456, 56, 53, 6666, 4, 2, 1]
[1, 2, 3, 4, 14, 26, 53, 56, 456, 6666]
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

8.冒泡排序

package array;

import java.util.Arrays;

public class ArrayDemo4 {
    public static void main(String[] args) {
        int[] a = {14,2,443,2,23,54,26,57};
        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;
            }
        }
    }

}

8.稀疏数组

记录有效的坐标

package array;

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

        // 输出原始数组
        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();
        }
    }

}