[起源篇]---带你感受数组的魅力（Java数组）

目录

数组

数组的概念

例子（感受数组的方便之处）

数组的语法格式

数组的操作(重点)

---

1.数组的概念 

        什么是数组？

         数组（Array）是有序数据的集合，数组中的每个元素具有相同的数据类型，可以用一个统一的数组名和不同的下标来唯一确定数组中的元素。根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

        换句话说：就是我们将一组相同类型的元素，统一放在一起，便于我们进行增删改查的操作。

         

        接着，我们通过一个题，来感受一下有数组和无数组的区别在哪？

//需求:输入三个班，每班5个学生的成绩，求每个班的总分和平均分 


//[不用数组]：
		int classNum=0; //迭代次数
        double sum; //总分变量
        double avg; //平均数变量
        Scanner sc = new Scanner(System.in);
        while (classNum<3)
        {

            sum=0;//初始化
            avg=0;
            System.out.println("现在是在录入"+(classNum+1)+"班同学的信息！");
            for (int i = 1; i <=5; i++) {
                System.out.println("请输入第"+i+"个同学的分数：");
                double score = sc.nextDouble();
                sum+=score;
            }
            avg=sum/5;
            System.out.println((classNum+1)+"班的同学的总分为："+sum+" 平均成绩为："+avg);
            classNum++;
        }

//[用数组]：
	 Scanner sc = new Scanner(System.in);
        //定义存储每个班的总分和平均成绩的数组
        double[] sums = new double[3]; //总分数组
        double[] avgs = new double[3]; //平均分数组

        int classNum=0;
        while (classNum<3)
        {

            double[] classScore = new double[5]; //每个班5个同学成绩数组
            //先录入信息
            System.out.println("现在是在录入"+(classNum+1)+"班同学的信息！");
            for (int i = 0; i <5; i++) {
                System.out.println("请输入第"+(i+1)+"个同学的分数：");
                double score = sc.nextDouble();
                classScore[i]=score;
            }
            //在计算相对应一个班的总值（sum）
            for (int i = 0; i < classScore.length; i++) {
                sums[classNum]+=classScore[i];
            }
            //计算一个班的平均值
            avgs[classNum]=sums[classNum]/classScore.length;
            //迭代变量
            classNum++;
        }

        //展示每个班的总分和成绩
        for (int i = 0; i < sums.length; i++) {
            System.out.print((i+1)+"班的总分为："+sums[i]+" ");
            System.out.println((i+1)+"班的平均分为："+avgs[i]);
        }

不难发现：

        用数组可以大大减少变量的定义数量，并且还可以将其统一存储，后续再统一进行管理，大大地减少了维护成本，可能你会觉得两者代码量没什么变化，但你仔细想一想，你会发现用数组来做，更具有逻辑性，并且还可以完成一些再复杂的业务逻辑操作。

2.数组的语法格式

        既然数组这么好用，那么这里将数组的基本定义和语法展示给大家看看，方便大家快速能够定义和使用数组。

        根据数组的维度，可以将其分为一维数组、二维数组和多维数组等。

//【一维数组】
数组中每个元素都只带有一个下标，是数组中最简单的一种数组。
1. 声明
声明一维数组语法有两种格式（推荐使用第一种）。
type[] arrayName;    // 数据类型[] 数组名;

或者
type arrayName[];    // 数据类型 数组名[];

2. 分配空间
分配空间语法格式如下。
arrayName = new type[size];    // 数组名 = new 数据类型[数组长度];

3. 初始化
Java 中初始化数组有以下 3 种方式。
使用 new 指定数组大小后进行初始化
使用 new 指定数组元素的值
直接指定数组元素的值
// 使用 new 指定数组大小后进行初始化
int[] number = new int[5];
number[0] = 1;
number[1] = 2;
number[2] = 3;
number[3] = 5;
number[4] = 8;
// 使用 new 指定数组元素的值（2种方式）
int[] number = new int[] { 1, 2, 3, 5, 8 };
int[] number = new int[5] { 1, 2, 3, 5, 8 };
// 直接指定数组元素的值（2种方式）
int[] number = { 1, 2, 3, 5, 8 };
int[] number;
number={1,2,3,5,8};
4. 使用
获取单个元素
获取全部元素
纯文本复制
// 获取单个元素
int[] number = { 1, 2, 3, 5, 8 };
System.out.println("获取第一个元素：" + number[0]);
// 使用for语句获取全部元素
int[] number = { 1, 2, 3, 5, 8 };
for (int i = 0; i < number.length; i++) {
    System.out.println("第" + (i + 1) + "个元素的值是：" + number[i]);

//二维数组
二维数组被看作数组的数组。
1. 声明
声明二维数组语法有两种格式（推荐使用第一种）。
type[][] arrayName;    // 数据类型[][] 数组名;

或者
type arrayName[][];    // 数据类型 数组名[][];

第一个中括号表示行，第二个中括号表示列。
2. 初始化
二维数组可以通过以下 3 种方式来指定元素的初始值。
type[][] arrayName = new type[][]{值 1,值 2,值 3,…,值 n};    // 在定义时初始化
type[][] arrayName = new type[size1][size2];    // 给定空间，在赋值
type[][] arrayName = new type[size][];    // 数组第二维长度为空，可变化

// 定义时初始化
int[][] temp = new int[][]{{1,2},{3,4}};
// 给定空间在赋值
int[][] temp = new int[2][2];
// 数组第二维长度为空，可变化
int[][] temp = new int[2][];
3. 使用
获取单个元素：arrayName[i-1][j-1];arrayName 表示数组名称，i 表示数组的行数，j 表示数组的列数。
获取全部元素：使用嵌套 for 循环或 for each 循环语句。
获取整行元素：需要将行数固定，然后只遍历该行中的全部列即可。
获取整列元素：获取指定列的元素与获取指定行的元素相似，保持列不变，遍历每一行的该列即可。

    补充：数组内存图（帮助你更快速理解数组的存储）

     一维数组：   二维数组：

3.数组的操作(重点）

        数组的语法上的知识点倒是不是难理解，而是对应数组里面存储的值进行一系列的操作，比如：某个值的查找，数组的排序，值的反转等等操作。这些才是我们学习数组里面需要去掌握的。

 下面举几个数组的常用操作：

        3.1 比较数组

        
   比较数组元素的个数和对应位置的元素是否相等。
   
  1.数组工具类：Arrays.equals(arrayA, arrayB);
 
   arrayA 是用于比较的第一个数组，arrayB 是用于比较的第二个数组。

   2.自定义

//比较数组
    private static boolean equals(int[] arr, int[] brr) {
        //判断长度
        if (arr.length != brr.length) {
            return false;
        }
        //判读值
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] != brr[i]) {
                return false;
            }
        }
        return true;
    }

        3.2 填充数组

在指定位置进行数值填充。（全部填充，部分填充）
1.数组工具类：Arrays.fill(array,value);

array 表示数组，value 表示填充的值。只能使用同一个数值进行填充。

2.自定义：

   //填充数组
    private static void fill(int[] arr, int val) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] = val;
        }

    }

        3.3 数组查找

从数组中查询指定位置的元素，或者查询某元素在指定数组中的位置，语法格式如下。
binarySearch(Object[] a,Object key);

a 表示要搜索的数组，key 表示要搜索的值。

自定义：

  //数组查找
    private static int binarySearch(int[] arr, int index) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == index) {
                return i;
            }
        }
        return -1;//如果未找到返回-1
    }

在数组中指定范围内查找，语法格式如下。
binarySearch(Object[] a,int fromIndex,int toIndex,Object key);

a 表示要进行查找的数组，fromIndex 指定范围的开始处索引（包含开始处），toIndex 指定范围的结束处索引（不包含结束处），key 表示要搜索的元素。

        3.4 复制数组

1) copyOf()
1.数组工具类：Arrays.copyOf(dataType[] srcArray,int length);

srcArray 表示要进行复制的数组，length 表示复制后的新数组的长度

2.自定义：

 //复制数组
    private static int[] copyOf(int[] arr, int index) {
        int[] target = new int[index];
        for (int i = 0;i < index;i++){
            target[i] = arr[i];
        }
        return target;
    }

2) CopyOfRange()
1.数组工具类：Arrays.copyOfRange(dataType[] srcArray,int startIndex,int endIndex)

srcArray 表示原数组，startIndex 表示开始复制的起始索引，endIndex 表示终止索引。

3) arraycopy()
System.arraycopy(dataType[] srcArray,int srcIndex,int destArray,int destIndex,int length)

srcArray 表示原数组，srcIndex 表示源数组中的起始索引，destArray 表示目标数组，destIndex 表示目标数组中的起始索引，length 表示要复制的数组长度。
4) clone()
array_name.clone()

【上述四种复制数组细节 】

可参考这篇文档：https://blog.csdn.net/jijiangpeng/article/details/94776814    

       3.5 数组排序

Java 数组中有 4 种常见排序方法，分别是：
1.数组工具类：Arrays.sort();

2.自定义：
        a.冒泡排序
        b.快速排序
        c.选择排序

    // 冒泡排序  稳定
    public static void buddleSort(int[] arr) {
        int temp;
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j+ 1];
                    arr[j+1] = temp;
                }
            }
        }
    }

    // 选择排序 不稳定
    public static void choiceSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int k = 0, j;
            for (j = 0; j <= arr.length - i; j ++) {
                if (arr[k] < arr[j]){
                    k = j;}
            }
            if (k != j) {
                int temp = arr[k];
                arr[k] = arr[j-1];
                arr[j-1] = temp;
            }
        }
    }

    // 直接插入排序 稳定
    public static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i], j;
            for (j = i - 1; j >= 0; j--) {
                if (arr[j] > temp) {
                    arr[j+1] = arr[j];
                } else {
                    break;
                }
            }
            arr[j+1] = temp;
        }
    }

声明数组需要注意什么？

1. 声明数组时，一定要考虑数组的最大容量，防止容量不够的现象。数组一旦被声明，它的容量就固定了，不容改变。如果想在运行程序时改变容量，就需要用到集合(以后再说)。

2. 当然你会发现数组其实也是有缺点的，就是一旦声明，就不能改变容量，这个也是其使用频率不高的原因。一般存储数据会使用集合或 Vector（++） 来存储数据，后面我们会讲到。

以上就是简单数组学习的总结了，数组本身不难，但是它里面设计到的各种需求（算法）可能会有很多，所以还是希望大家多去练练，多去理解理解，熟能生巧尔。

谢谢，再见！