Java基础知识【第5期】--数组

导读:

本篇是JAVA基础系列的第五篇，主要介绍了数组的创建、初始化及针对数组的各种操作。数组是最常见的一种数据结构，它是相同类型的用一个标识符封装到一起的基本类型数据序列或者对象序列。数组使用一个统一的数组名和不同的下标来唯一确定数组中的元素。实质上，数组是一个简单的线性序列，因此访问速度很快。

1.java数组简介

例如要求存储100个学生的考试成绩，那么如果按照之前的做法，可能现在定义的的结构如下：

int a1,a2,a3,a4......a100;

非常麻烦，并且变量之间没有任何关系。而使用数组就可以避免此类问题。

int[]nums=new int[100];

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

数组中的概念:

1. 数组简述：数组就是存储一组相同数据类型的数据，长度固定的容器。

2. 标识符：数组的名称，用于区分不同的数组

3. 数组元素：向数组中存放的数据

4. 元素下标：对数组元素进行编号,从0开始

5. 元素类型：数组元素的数据类型  

6. 数组长度：数组中元素的个数

数组的特点：

1. 只能存储同一种数据类型的数据。

2. 一旦初始化，长度固定。

3. 数组中的元素与元素之间的内存地址是连续的。

注意：Object类型的数组可以存储任意类型的数据

2.一维数组

当数组中每个元素都只带有一个下标时，这种数组就是“一维数组”。一维数组（one-dimensional array）实质上是一组相同类型数据的线性集合，是数组中最简单的一种数组。

数组是引用数据类型，引用数据类型在使用之前一定要做两件事情：声明和初始化

第一步：声明

声明一维数组语法有两种格式（推荐使用第一种）。

 数据类型[] 数组名;//第一种 推荐使用
 或者
 数据类型 数组名[];//第二种 C/C++的写法，java中保留了，不建议使用

第二步:分配空间

 数组名 = new 数据类型[数组长度];

第三步:初始化

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};

第四步：使用

• 获取单个元素

• 获取全部元素

 // 获取单个元素 通过数组下标获取指定位置元素
 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]);
 }
 // 使用foreach语句获取全部元素
 for (int val : number) {
     System.out.print("元素的值依次是：" + val + "\t");
 }

数组除了一维数组之外，还有二维数组和多维数组。其中二维数组可以看做是数组的数组，简单来说就是数组中的数组元素是一维数组。

3.求数组的最大值和最小值

求数组中数据的最大值和最小值是日常统计中比较常见的诉求。java实现也比较简单：

 public class Example{
     public static void main(String[] args) {
         int score[] = { 67, 89, 87, 69, 90, 100, 75, 90 }; // 初始化数组
         int max = 0; // 定义变量保存到最大值
         int min = 0; // 定义变量保存到最小值
         max = min = score[0]; // 把第1个元素的内容赋值给max和min
         for (int x = 0; x < score.length; x++) { // 循环求岀最大和最小
             if (score[x] > max) { // 依次判断后续元素是否比max大
                 max = score[x]; // 如果大则修改max内容
            }
             if (score[x] < min) { // 依次判断后续的元素是否比min小
                 min = score[x]; // 如果小，则修改min内容
            }
        }
         System.out.println("最高成绩：" + max); // 输出最大值
         System.out.println("最低成绩：" + min); // 输出最小值
    }
 }

4.冒泡排序法（非常重要）

冒泡排序是常用的数组排序算法之一，在面试中也是最常出现的手写代码之一。

面试过程中最常考的手写代码:冒泡排序、递归、单例模式

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素值移动到数组前面，把大的元素值移动到数组后面（也就是交换两个元素的位置），这样数组元素就像气泡一样从底部上升到顶部。

Java 中的冒泡排序在双层循环中实现，其中外层循环控制排序轮数，总循环次数为要排序数组的长度减 1。而内层循环主要用于对比相邻元素的大小，以确定是否交换位置，对比和交换次数依排序轮数而减少。

示例代码:

 public class ArrayDemo {
     public static void main(String[] args) {
         // 声明数组并赋值
         int[] score = {99, 89, 100, 77, 91, 90, 94};
         System.out.println("通过冒泡排序方法对数组进行排序：");
         for (int i = 0; i < score.length - 1; i++) {
             // 比较相邻两个元素，较大的数往后冒泡
             for (int j = 0; j < score.length - 1 - i; j++) {
                 if (score[j] > score[j + 1]) {
                     int temp = score[j + 1]; // 把第一个元素值保存到临时变量中
                     score[j + 1] = score[j]; // 把第二个元素值转移到第一个元素变量中
                     score[j] = temp; // 把临时变量（第一个元素的原值）保存到第二个元素中
                }
                 System.out.print(score[j] + " "); // 对排序后的数组元素进行输出
            }
             System.out.print("【");
             for (int j = score.length - 1 - i; j < score.length; j++) {
                 System.out.print(score[j] + " ");
            }
             System.out.println("】");
        }
    }
 }

5.Arrays工具类

Arrays 类是一个工具类，其中包含了数组操作的很多方法。这个 Arrays 类里均为 static 修饰的方法（static 修饰的方法可以直接通过类名调用），可以直接通过 Arrays.xxx(xxx) 的形式调用方法。

Arrays工具类常用方法:

1. int binarySearch(type[] a, type key)

   使用二分法查询 key 元素值在 a 数组中出现的索引，如果 a 数组不包含 key 元素值，则返回负数。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

2. int binarySearch(type[] a, int fromIndex, int toIndex, type key)

   这个方法与前一个方法类似，但它只搜索 a 数组中 fromIndex 到 toIndex 索引的元素。调用该方法时要求数组中元素己经按升序排列，这样才能得到正确结果。

3. type[] copyOf(type[] original, int length)

   这个方法将会把 original 数组复制成一个新数组，其中 length 是新数组的长度。如果 length 小于 original 数组的长度，则新数组就是原数组的前面 length 个元素，如果 length 大于 original 数组的长度，则新数组的前面元素就是原数组的所有元素，后面补充 0（数值类型）、false（布尔类型）或者 null（引用类型）。

4. type[] copyOfRange(type[] original, int from, int to)

   这个方法与前面方法相似，但这个方法只复制 original 数组的 from 索引到 to 索引的元素。

5. boolean equals(type[] a, type[] a2)

   如果 a 数组和 a2 数组的长度相等，而且 a 数组和 a2 数组的数组元素也一一相同，该方法将返回 true。

6. void fill(type[] a, type val)

   该方法将会把 a 数组的所有元素都赋值为 val。

7. void fill(type[] a, int fromIndex, int toIndex, type val)

   该方法与前一个方法的作用相同，区别只是该方法仅仅将 a 数组的 fromIndex 到 toIndex 索引的数组元素赋值为 val。

8. void sort(type[] a)

   该方法对 a 数组的数组元素进行排序。

9. void sort(type[] a, int fromIndex, int toIndex)

   该方法与前一个方法相似，区别是该方法仅仅对 fromIndex 到 toIndex 索引的元素进行排序。

10. String toString(type[] a)

    该方法将一个数组转换成一个字符串。该方法按顺序把多个数组元素连缀在一起，多个数组元素使用英文逗号,和空格隔开。

示例代码:

 public class ArrayDemo {
     public static void main(String[] args) {
         // 定义一个a数组
         int[] a = new int[] { 3, 4, 5, 6 };
         // 定义一个a2数组
         int[] a2 = new int[] { 3, 4, 5, 6 };
         // a数组和a2数组的长度相等，毎个元素依次相等，将输出true
         System.out.println("a数组和a2数组是否相等：" + Arrays.equals(a, a2));
         // 通过复制a数组，生成一个新的b数组
         int[] b = Arrays.copyOf(a, 6);
         System.out.println("a数组和b数组是否相等：" + Arrays.equals(a, b));
         // 输出b数组的元素，将输出[3, 4, 5, 6, 0, 0]
         System.out.println("b 数组的元素为：" + Arrays.toString(b));
         // 将b数组的第3个元素（包括）到第5个元素（不包括）賦值为1
         Arrays.fill(b, 2, 4, 1);
         // 输出b数组的元素，将输出[3, 4, 1, 1, 0, 0]
         System.out.println("b 数组的元素为：" + Arrays.toString(b));
         // 对b数组进行排序
         Arrays.sort(b);
         // 输出b数组的元素.将输出[0,0,1,1,3,4]
         System.out.println("b数组的元素为：" + Arrays.toString(b));
    }
 }