一、数组概念（最简单的数据结构）

数组是相同类型数据的有序集合。
数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。
其中每一个数据称作一个数组元素，每个数组元素可以通过一个下标来访问它们。

二、数组声明创建

首先必须声明数组变量，才能在程序中使用数组。语法：

变量类型[] 变量名;  //首选的方法

变量类型 变量名[];  //效果相同，但不是首选

Java 使用 new 操作符来创建数组。语法：

数据类型[] 变量名 = new 数据类型[数组大小];

数组的元素是通过索引访问的，数组索引从 0 开始。
获取数组长度： arrays.length

public class Array {

    public static void main(String[] args) {

        //变量类型（数组类型） 变量名 = 值;

        //1.定义数组

        int[] arra1;  // Java 风格

        int arra2[];  // C / C++ 语言风格

        //2.创建数组（这里面可以存放 10 个 int 类型的数字）

        //假如没有数组要定义 10 个变量，有了数组通过 1 个变量就可以村 10 个数字了

        arra1 = new int[10];

//        int[] arra1 = new int[10];

        //3.给数组元素中赋值

        arra1[0] = 1;

        arra1[1] = 1;

        arra1[2] = 1;

        arra1[3] = 1;

        System.out.println(arra1[0]);

        System.out.println(arra1[4]);  //0，默认值

        //计算所有元素的和

        int sum = 0;

        for (int i = 0; i < arra1.length; i++) {

            sum += arra1[i];

        }

        System.out.println("所有元素的和：" + sum);

    }

}

三、内存分析

1.Java 内存分析：

写代码画图分析内存：

public class MemoryAnalysis_ArrayIndexOutOfBoundsException {

    public static void main(String[] args) {

        //1.定义数组

        int[] array = null;

        // 2.创建数组

        array = new int[10];

        // 3.给数组元素中赋值

        array[0] = 1;

        array[1] = 1;

        array[2] = 1;

        array[3] = 1;

        System.out.println(array[10]);  //ArrayIndexOutOfBoundsException

    }

}

声明的时候数组并不存在，通过 new 关键字创建的时候，数组才产生，给里面赋值的时候才有值，没有赋值的话就是默认元素

方法在栈，实例在堆

2.三种初始化

静态初始化

int[] array = {1, 2, 3};

Man[] mans = {new Man(1, 1), new Man(2, 2)};

动态初始化

int[] array = new int[2];

array[0] = 1;

array[1] = 2;

数组的默认初始化
- 数组是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化。

public class ThreeKindsOfInitialization {

    public static void main(String[] args) {

        //1.静态初始化：创建 + 赋值

        int[] array = {1, 2, 3};

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

        //引用类型数组

        Man[] mans = {new Man(), new Man()};

        //2.动态初始化：包含默认初始化

        int[] array2 = new int[3];

        array2[0] = 1;

        array2[1] = 2;

        System.out.println(array2[1]);  //2

        //3.数组的默认初始化

        System.out.println(array2[2]);  //0

    }

}

class Man{}

3.数组的四个基本特点

其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
其元素必须是相同类型，不允许出现混合类型。
数组中的元素可以是任何数据类型，包括基本类型和引用类型。
数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象， Java 中对象是在堆中的，因此数组无论保存原始类型还是其它对象类型，数组对象本身是在堆中的。

4.数组边界

下标的合法区间： [0, length - 1] ，如果越界就会报错：

public static void main(String[] args) {

        int[] array = new int[2];

        System.out.println(array[2]);

    }

ArrayIndexOutOfBoundsException ：数组下标越界异常！

5.小结

数组是相同数据类型（数据类型可以为任意类型）的有序集合
数组也是对象。数组元素相当于对象的成员变量
数组长度是确定的，不可变的。如果越界，则报： ArrayIndexOutOfBoundsException

四、数组使用

1.普通的for循环（使用最多）

要从数组中取出一些数据或下标进行操作

public class Fori_Exer {

    public static void main(String[] args) {

        int[] arrays = {1, 2, 3};

        //打印全部的数组元素

        for (int i = 0; i < arrays.length; i++) {

            System.out.println(arrays[i]);

        }

        System.out.println();

        //计算所有元素的和

        int sum = 0;

        for (int i = 0; i < arrays.length; i++) {

            sum += arrays[i];

        }

        System.out.println(sum);

        System.out.println();

        //查找最大元素

        int max = arrays[0];

        for (int i = 1; i < arrays.length; i++) {

            if (arrays[i] > max){

                max = arrays[i];

            }

        }

        System.out.println(max);

    }

}

2.foreach循环

用来打印结果

public class ForEach_Exer {

    public static void main(String[] args) {

        int[] arrays = {1, 2, 3};

        //增强型for循环，JDK1.5，没有下标，适合打印输出

        for (int array : arrays) {

            System.out.println(array);

        }

    }

}

3.数组作方法入参

可以对数组进行一些操作

public class ArrayAsMethodInputParameter_Exer {

    public static void main(String[] args) {

        int[] arrays = {1, 2, 3};

        printArray(arrays);

    }

    //打印全部的数组元素

    public static void printArray(int[] arrays){

        for (int i = 0; i < arrays.length; i++) {

            System.out.println(arrays[i]);

        }

    }

}

4.数组作返回值

把数组进行修改，然后返回新的数组

public class ArrayAsTheReturnValue_Exer {

    public static void main(String[] args) {

        int[] arrays = {1, 2, 3};

        int[] array = reverseArray(arrays);

        for (int i : array) {

            System.out.println(i);

        }

    }

    //反转数组

    public static int[] reverseArray(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;

    }

}

五、多维数组（数组的升级）（坐标）

多维数组可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
二维数组
```
int arrays[][] = new int[2][5];
```
- 解析：二维数组 arrays 可以看成一个两行五列的数组
思考：多维数组的使用？
- Java 并不会使用多维数组进行操作，面向对象编程，会把一个东西变成一个对象

public class TwoDimensionalArray_Exer {

    public static void main(String[] args) {

        /*

        [2][3]

        1, 2, 3  arrays[0]

        4, 5     arrays[1]

         */

        int[][] arrays = {{1, 2, 3}, {4, 5}};

        System.out.println(arrays[0]);  //[I@1540e19d  对象，数组

        for (int i : arrays[0]) {

            System.out.print(i);  //123

        }

        System.out.println();

        for (int i = 0; i < arrays.length; i++) {

            for (int j = 0; j < arrays[i].length; j++) {

                System.out.print(arrays[i][j]);  //12345

            }

        }

    }

}

六、Arrays 类（专门操作数组的类）

数组的工具类 java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但 API 中提供了一个工具类 Arrays 供我们使用，从而可以对数据对象进行一些基本的操作。
查看 JDK 帮助文档
Arrays 类中的方法都是 static 修饰的静态方法，在使用的时候可以直接使用类名进行调用，而不用使用对象来调用（注意：是“不用”，而不是“不能”）
具有以下常用功能：
- 给数组赋值：通过 fill() 方法，数组填充。
- 对数组排序：通过 sort() 方法，按升序。
- 比较数组：通过 equals() 方法，比较数组中元素值是否相等。
- 查找数组元素：通过 binarySearch() 方法，能对排序好的数组进行二分查找法操作。

public class Arrays_Exer {

    public static void main(String[] args) {

        int[] a = {7, 2, 4, 1, 0, 6};

        //打印数组元素

        System.out.println(Arrays.toString(a));  //[7, 2, 4, 1, 0, 6]

        //自定义 打印数组元素

        printArray(a);  //[7, 2, 4, 1, 0, 6]

        //对数组排序

        Arrays.sort(a);

        System.out.println(Arrays.toString(a));  //[0, 1, 2, 4, 6, 7]

        //给数组赋值：数组填充

        Arrays.fill(a, 0);

        System.out.println(Arrays.toString(a));  //[0, 0, 0, 0, 0, 0]

        Arrays.fill(a, 2, 4, 6);  // 2~4 之间被 6 填充

        System.out.println(Arrays.toString(a));  //[0, 0, 6, 6, 0, 0]

    }

    //打印数组元素

    //重复造轮子：别人做好的事，不建议重新做，但是要了解原理

    public static void printArray(int[] arrays){

        System.out.print("[");

        for (int i = 0; i < arrays.length; i++) {

            if (i != arrays.length - 1) {

                System.out.print(arrays[i] + ", ");

            } else {

                System.out.print(arrays[i]);

            }

        }

        System.out.println("]");

    }

}

七、冒泡排序

冒泡排序无疑是最为出名的排序算法之一，总共有八大排序

冒泡的代码还是相当简单的，两层循环，外层冒泡轮数，里层依次比较，人尽皆知

public class BubbleSort {

    public static void main(String[] args) {

        /* 冒泡排序

        1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置

        2.每一次比较，都会产生出一个最大或最小的数字

        3.下一轮则可以少一次排序

        4.依次循环，直到结束

         */

        int[] a = {7, 2, 4, 1, 0, 6};

        System.out.println(Arrays.toString(bubbleSort(a)));

    }

    public static int[] bubbleSort(int[] arrays){

        //临时变量

        int temp = 0;

        //外层循环，判断要走多少次

        for (int i = 0; i < arrays.length - 1; i++) {

            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置

            for (int j = 0; j < arrays.length - 1 - i; j++) {

                if (arrays[j + 1] < arrays[j]) {

                    temp = arrays[j];

                    arrays[j] = arrays[j + 1];

                    arrays[j + 1] = temp;

                }

            }

        }

        return arrays;

    }

}

我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)

思考：如何优化？

public class BubbleSort_Optimization {

    public static void main(String[] args) {

        /* 冒泡排序

        1.比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换它们的位置

        2.每一次比较，都会产生出一个最大或最小的数字

        3.下一轮则可以少一次排序

        4.依次循环，直到结束

         */

        int[] a = {7, 2, 4, 1, 0, 6};

        System.out.println(Arrays.toString(bubbleSort(a)));

    }

    public static int[] bubbleSort(int[] arrays){

        //临时变量

        int temp = 0;

        //外层循环，判断要走多少次

        for (int i = 0; i < arrays.length - 1; i++) {

            //通过 flag 标识位减少没有意义的比较，省略最后一轮的比较

            boolean flag = false;

            //内层循环，比较判断两个数，如果第一个数比第二个数大，则交换位置

            for (int j = 0; j < arrays.length - 1 - i; j++) {

                if (arrays[j + 1] < arrays[j]) {

                    temp = arrays[j];

                    arrays[j] = arrays[j + 1];

                    arrays[j + 1] = temp;

                    flag = true;

                }

            }

            //没有进行比较，说明已经结束，跳出循环，最后一轮就不用走了，少走一轮

            if (flag == false) {

                break;

            }

        }

        return arrays;

    }

}

八、稀疏数组

1.稀疏数组

简单的数据结构，用来压缩数组，便于保存，大大减少空间储存量
需求：编写五子棋游戏中，有存盘和续上盘的功能。
- 分析问题：因为该二维数组的很多值是默认值0，因此记录了很多没有意义的数据。
- 解决：稀疏数组（压缩算法）

2.稀疏数组介绍

当一个数组中大部分元素为 0 ，或者为同一值的数组时，可以使用稀疏数组来保存该数组。
稀疏数组的处理方式是：
- 记录数组一共有几行几列，有多少个不同值
- 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模（压缩：在最初的时候可以节省空间）
如下图：左边是原始数组，右边是稀疏数组

public class SparseArray {

    public static void main(String[] args) {

        /*

        0 0 0 0 0 0 0 0 0 0 0  ==>  行  列  值

        0 0 1 0 0 0 0 0 0 0 0       11 11 2

        0 0 0 2 0 0 0 0 0 0 0       1  2  1

        0 0 0 0 0 0 0 0 0 0 0       2  3  2

        0 0 0 0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0 0 0 0

        0 0 0 0 0 0 0 0 0 0 0

         */

        //1.创建一个二维数组 11 * 11， 0：没有棋子，1：黑棋， 2：白棋

        int[][] arrays = new int[11][11];

//        Arrays.fill(arrays, 0);

        arrays[1][2] = 1;

        arrays[2][3] = 2;

        //输出原始的数组

        for (int[] array : arrays) {

            for (int i : array) {

                System.out.print(i + " ");

            }

            System.out.println();

        }

        System.out.println();

        //转换为稀疏数组

        //1.获取有效值个数

        int sum = 0;

        for (int i = 0; i < arrays.length; i++) {

            for (int j = 0; j < arrays[0].length; j++) {

                if (arrays[i][j] != 0) {

                    sum ++;

                }

            }

        }

        System.out.println("行\t" + "列\t" + "值");

        //2.创建一个稀疏数组的数组

        int[][] arrays2 = new int[sum + 1][3];  //固定的 3 列：行、列、值

        arrays2[0][0] = arrays.length;

        arrays2[0][1] = arrays[0].length;

        arrays2[0][2] = sum;

        //3.遍历二维数组，将非 0 的值，存放到稀疏数组中

        int count = 0;  //计数

        for (int i = 0; i < arrays.length; i++) {

            for (int j = 0; j < arrays[i].length; j++) {

                if (arrays[i][j] != 0) {

                    count ++;

                    arrays2[count][0] = i;

                    arrays2[count][1] = j;

                    arrays2[count][2] = arrays[i][j];

                }

            }

        }

        //输出稀疏数组

        for (int[] array2 : arrays2) {

            for (int i2 : array2) {

                System.out.print(i2 + "\t");

            }

            System.out.println();

        }

        System.out.println();

        //还原稀疏数组：根据稀疏数组重新构建一个数组

        //1.读取稀疏数组的值

        int[][] arrays3 = new int[arrays2[0][0]][arrays2[0][1]];

        //2.给其中的元素还原它的值

        for (int i = 1; i < arrays2.length; i++) {

            arrays3[arrays2[i][0]][arrays2[i][1]] = arrays2[i][2];

        }

        //3.打印还原

        for (int[] array3 : arrays3) {

            for (int i3 : array3) {

                System.out.print(i3 + " ");

            }

            System.out.println();

        }

    }

}

总结：稀疏数组，记录有效的坐标，记录原始坐标的大小以及它的有效值，记录每一个值的坐标，变成一个新的数组

巴特西

7.Java数组

一、数组概念（最简单的数据结构）

二、数组声明创建

三、内存分析

1.Java 内存分析：

2.三种初始化

3.数组的四个基本特点

4.数组边界

5.小结

四、数组使用

1.普通的for循环（使用最多）

2.foreach循环

3.数组作方法入参

4.数组作返回值

五、多维数组（数组的升级）（坐标）

六、Arrays 类（专门操作数组的类）

七、冒泡排序

八、稀疏数组

1.稀疏数组

2.稀疏数组介绍

最新文章

热门文章

巴特西

7.Java数组

一、数组概念（最简单的数据结构）

二、数组声明创建

三、内存分析

1.Java 内存分析：

2.三种初始化

3.数组的四个基本特点

4.数组边界

5.小结

四、数组使用

1.普通的for循环（使用最多）

2.foreach循环

3.数组作方法入参

4.数组作返回值

五、 多维数组（数组的升级）（坐标）

六、Arrays 类（专门操作数组的类）

七、冒泡排序

八、稀疏数组

1.稀疏数组

2.稀疏数组介绍

最新文章

热门文章

五、多维数组（数组的升级）（坐标）