Java05——数组

本文章是本人根据视频和网上资料整理所写笔记，可能有不通顺或遗漏的地方，请尽量参考学习来源处的链接去进行学习。

学习来源

【狂神说Java】Java零基础学习视频通俗易懂：https://www.bilibili.com/video/BV12J41137hu

菜鸟教程： https://www.runoob.com/

阿里巴巴Java开发手册

java二维数组 https://www.jianshu.com/p/aa905c079332

Java集合框架：Arrays工具类 https://honeypps.com/java/java-collection-arrays/

数组的定义

Tables	Are
简化格式：	数据类型数组名称 = {值, 值,…}
完整格式：	数据类型数组名称 = new 数据类型[] {值, 值,…}

type arrayName[];
type[] arrayName;
type 为Java中的任意数据类型，包括基本类型和组合类型，arrayName为数组名，必须是一个合法的标识符，[ ] 指明该变量是一个数组类型变量。
例如：
int demoArray[];
int[] demoArray;

数组的初始化

可以在声明数组的同时进行初始化（静态初始化），也可以在声明以后进行初始化（动态初始化）。例如：

// 静态初始化
// 静态初始化的同时就为数组元素分配空间并赋值
int intArray[] = {1,2,3,4};
String stringArray[] = {"zhidao", "baidu", "百度知道"};
// 动态初始化
float floatArray[] = new float[3];
floatArray[0] = 1.0f;
floatArray[1] = 132.63f;
floatArray[2] = 100F;

数组的使用

每个数组都有一个length属性来指明它的长度，例如 intArray.length 指明数组 intArray 的长度。

【示例】写一段代码，要求输入任意5个整数，输出它们的和。

public class ArrayTest {
    public static void main(String[] args) {
        int intArray[] = new int[5];
        long total = 0;
        int len = intArray.length;
        // 给数组元素赋值
        System.out.print("请输入" + len + "个整数，以空格为分隔：");
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < len; i++) {
            intArray[i] = sc.nextInt();
        }
        // 计算数组元素的和
        for (int i = 0; i < len; i++) {
            total += intArray[i];
        }
        System.out.println("所有数组元素的和为：" + total);
    }
}

结果

请输入5个整数，以空格为分隔：1 2 3 4 5 6 7 8 9
所有数组元素的和为：15

二维数组

概述：二维数组其实就是一个元素为一维数组的数组

格式：

数据类型[][] 变量名=new 数据类型[m][n];
 m表示这个二维数组有多少个数组
 n表示每一个一维数组的元素个数

举例：
 int[][] arr=new int[3][2];
 定义了一个二维数组arr
 这个二维数组有3个一维数组，名称是ar[0],arr[1],arr[2]
 每个一维数组有2个元素，可以通过arr[m][n]来获取

Arrays工具类

java.util.Arrays类能方便地操作数组，它提供的方法都是静态的。整个Arrays工具类的实现有3000+行，但是归纳总结一下可知它有以下功能（9个）：

1.asList

public static <T> List<T> asList(T... a) {
    return new ArrayList<>(a);
}

功能：将一个数组(变长参数的语法糖实现就是数组)转变成一个List(确切的来说是ArrayList)，注意这个List是定长的，企图添加或者删除数据都会报错（java.lang.UnsupportedOperationException）

譬如案例1-1：

List<Integer> list = Arrays.asList(3,4,2,1,5,7,6);
System.out.println(list);

输出结果：[3, 4, 2, 1, 5, 7, 6]

但是，对于基础类型（比如byte,int,float等）千万不要想着这么实现（案例1-2，勿效仿）：

int a[] = new int[]{1,2,5,4,6,8,7,9};
List list = Arrays.asList(a);

因为List list = Arrays.asList(a);会变成List<int[]> list = Arrays.asList(a);所以遍历需要这样：

for(int[] arr:list)
{
    for(int i:arr)
    {
        System.out.println(i);
    }
}

这样操作就显得非常的烦琐。因为预想List是List形式的，没想到是List<int[]>形式的。使用的时候要特别的注意一下。

2.sort

对数组进行排序。适合byte,char,double,float,int,long,short等基本类型，还有Object类型（实现了Comparable接口），如果提供了比较器Comparator也可以适用于泛型。

案例2-1（基础类型，输出：[1, 1, 4, 4, 5, 6, 7, 9]）：

int a[] = new int[]{1,9,5,4,6,4,7,1};
Arrays.sort(a);
System.out.println(Arrays.toString(a));

案例2-2（String类型(Object)，实现了Comparable接口，输出：[s1, s2, s3, s4]）：

String str[] = {"s2","s4","s1","s3"};
Arrays.sort(str);
System.out.println(Arrays.toString(str));

案例2-3 （自定义类型，实现了Comparable接口，输出：[jj:17, zzh:18, qq:19]）：

Person1 persons[] = new Person1[]{
        new Person1("zzh",18),new Person1("jj",17),new Person1("qq",19)
};
Arrays.sort(persons);
System.out.println(Arrays.toString(persons));

案例2-4（泛型，如果类型没有实现Comparable接口，可以通过Comparator实现排序）：

Person2 persons2[] = new Person2[]{
        new Person2("zzh",18),new Person2("jj",17),new Person2("qq",19)
};
Arrays.sort(persons2,new Comparator<Person2>(){

    @Override
    public int compare(Person2 o1, Person2 o2)
    {
        if(o1 == null || o2 == null)
            return 0;
        return o1.getAge()-o2.getAge();
    }

});
System.out.println(Arrays.toString(persons2));

输出：[jj:17, zzh:18, qq:19]

关于类Person1和类Person2的详细细节可以参考《Comparable与Comparator浅析》

3.binarySearch

通过二分查找法对已排序（譬如经过Arrays.sort排序，且按照升序进行排序。如果数组没有经过排序，那么检索结果未知）的数组进行查找。适合byte,char,double,float,int,long,short等基本类型，还有Object类型和泛型（参考sort那段）

案例3-1：

String str[] = {"s2","s4","s1","s3"};
Arrays.sort(str);
System.out.println(Arrays.toString(str));
int ans = Arrays.binarySearch(str, "s1");
System.out.println(ans);

输出：

[s1, s2, s3, s4]
0

4. copyOf

数组拷贝，底层采用System.arrayCopy（native方法）实现。

案例4-1：

String str[] = {"s2","s4","s1","s3"};
String str2[] = Arrays.copyOf(str, str.length);
System.out.println(Arrays.toString(str2));

5. copyOfRange

数组拷贝，指定一定的范围，譬如（public static T[] copyOfRange(T[] original, int from, int to)）。底层采用System.arrayCopy（native方法）实现。

案例5-1：

String str[] = {"s2","s4","s1","s3"};
String str2[] = Arrays.copyOfRange(str,1,3);
System.out.println(Arrays.toString(str2));

输出：[s4, s1]

6. equals和deepEquals

equals：判断两个数组的每一个对应的元素是否相等（equals, 对于两个数组的元素o1和o2有o1null ? o2null : o1.equals(o2)）。

案例6-1：

String str1[] = {"s2","s4","s1","s3",null};
String str2[] = Arrays.copyOf(str1, str1.length);
System.out.println(Arrays.equals(str1, str2));

输出：

true

deepEquals：主要针对一个数组中的元素还是数组的情况，类似deepToString, deepHashCode如下：

案例6-1：

int a1[] = new int[]{1,2,3};
int a2[] = new int[]{1,3,3};
int a3[] = new int[]{4,3,2,1};
int a4[] = new int[]{1,2,3};
int a5[] = new int[]{1,3,3};
int a6[] = new int[]{4,3,2,1};
int[] a [] = new int[][]{a1,a2,a3};
int[] b [] = new int[][]{a4,a5,a6};

System.out.println(Arrays.equals(a, b));
System.out.println(Arrays.deepEquals(a, b));

输出结果：

false
true

7. fill

给数组赋值。填充数组之用。

案例7-1：

String str[] = {"s2","s4","s1","s3",null};
System.out.println(Arrays.toString(str));
Arrays.fill(str, "s5");
System.out.println(Arrays.toString(str));

输出：

[s2, s4, s1, s3, null]
[s5, s5, s5, s5, s5]

8. toString和deepToString

toString：对于一个数组int a[] = new int[]{1,9,5,4,6,4,7,1};如果按照System.out.println(a);打印企图可以打印出[1,9,5,4,6,4,7,1]，实际上只会打印出[I@3e2de41d这种。在打印数组的时候需要写成Arrays.toString(a)的形式。可参考sort的详解。

deepToString：当数组中又包含数组，那么就不能单存的利用Arrays.toString()了，请看例子。

案例8-1：

int a1[] = new int[]{1,2,3};
int a2[] = new int[]{1,3,3};
int a3[] = new int[]{4,3,2,1};
int[] a [] = new int[][]{a1,a2,a3};
System.out.println(Arrays.toString(a));
System.out.println(Arrays.deepToString(a));

输出结果：

[[I@1b6b7f83, [I@2e807f85, [I@76340c9c]
[[1, 2, 3], [1, 3, 3], [4, 3, 2, 1]]

9. hashCode和deepHashCode

hashCode：计算一个数组的hashCode.对于一个数组Object[], hashCode方法返回的值取决于：数组中每个元素的元素oi.hashCode()的值初级计算result = 31 * result + (oi== null ? 0 : oi.hashCode());

deepHashCode: 对于一个数组Object[], deepHashCode取决于：数组中每个元素oi，如果oi还是一个数组，那么就继续深入的去获取hashCode，这段比较绕，来个例子比较形象。

案例9-1：

int a1[] = new int[]{1,2,3};
int a2[] = new int[]{1,3,3};
int a3[] = new int[]{4,3,2,1};
int[] a [] = new int[][]{a1,a2,a3};
System.out.println(Arrays.hashCode(a));
System.out.println(Arrays.deepHashCode(a));

输出结果：

-1683374023
31646847

这样可以看到hashCode与deepHashCode的区别。对于数组而言hashCode只调用到它第一层元素，deepHashCode会一直调用直至不能再拆分成数组的元素。

排序算法

这个有非常多的人写了，这里推荐几篇不错的

Java常用排序算法/程序员必须掌握的8大排序算法 https://blog.csdn.net/qy1387/article/details/7752973

Java实现八大排序算法 https://www.cnblogs.com/morethink/p/8419151.html