【Java学习笔记系列】深入学习数组与相关知识点总结

版权声明:本文为博主原创文章,转载须注明原创链接,标注原创作者名:SnailMann https://blog.csdn.net/SnailMann/article/details/80333044

深入学习数组与相关知识点总结


虽然之前对数组大致都了解,因为这不是一个困难的知识点,只是一个很普通的基础知识,但是真正运用起来总感觉缺了些什么,那可能是之前对数组的印象一直都停留在能用模糊的概念上,所以今天我们就好好的总结一下数组的相关知识,我这里大致分为三个模块。

  • 数组的概念知识
  • 数组的定义和初始化
  • 数组工具类的应用

数组的概念知识


什么是数组?
数组只是相同类型的,用一个标识符名称封装在一起的一个基本类型序列或对象序列。

数组类型:

  • 基本类型数组 (用于存放基本类型数据的数组)
  • 对象类型数组 (用于Object类型的数组)

数组的特性

  • 数组和类对象一样,实例化的数组和实例化的对象都存储在内存的堆中。
  • 数组对象的大小是固定,是数组实例化的时候已经赋予了的,不允许再被改变,越界是会报运行时异常的
  • 数组对象因为存放在堆中,所以是具有默认值的,如int类型为0,引用类型为Null
  • -

数组与其他种类的容器之间的区别

  • 效率
    (数组是一种效率最高的存储和随机访问对象引用序列的方法,数据就是一个简单的线性序列,这是的元素访问非常迅速)
  • 保存基本类型的能力
    (随着容器可以使用泛型,容器也可以保存基本类型了,所以这不再是数组唯一的特性)

数组的定义和初始化


数组变量的定义

要定义一个数组,只需要在类型名后加上一对空方括号[]

  • int[] a;
  • int a[];

两种格式的含义是一样的,第二种格式符合C和C++程序员的习惯,不过,前一种格式或许更合理,毕竟它表明类型是一个XX类型的数组。在Java开发中,我更倾向于第一种定义格式。

数组的初始化

为了简单简洁,这里的数组都为基本类型的一维数组,多维或是对象数组其实方式都差不多,我就仅在补充上稍微带过。

知识前提:
数组的初始化中,有两个东西需要我们提前了解一下。

  • [](dimension expressions,维度表达式) - 用于表示这是几维数组,每维中大小时多少
  • {...,...,...}(array initializer,数组初始化器)- 用于帮助数组进行批量初始化

数组初始化的三种方式:

int[] array1 = {1,2,3,4};               //数组初始化器定义了大小和内容
int[] array2 = new int [] {1,2,3,4};    //数组初始化器定义了大小和内容
int[] array3 = new int [4];             //维度表达式定义大小

System.out.println(Arrays.toString(array1));
System.out.println(Arrays.toString(array2));
System.out.println(Arrays.toString(array3));        

结果

[1, 2, 3, 4]            //int[] array1 = {1,2,3,4};
[1, 2, 3, 4]            //int[] array2 = new int [] {1,2,3,4};
[0, 0, 0, 0]            //int[] array4 = new int [4];

我们可以看出第一种方式和第二种方式的结果是一样的,这种使用数组初始化器初始化的方式,我们称为静态初始化,都是通过给数组批量初始化固定个数的内容,而且第一二种初始化方式的本质其实是一样,虽然源代码略有不同,但是反编译之后的代码其实都是第一种定义方式

//反编译后得到的代码
int[] array1 = { 1, 2, 3, 4 };
int[] array2 = { 1, 2, 3, 4 };

第三种方式属于用维度表达式来定义这一维度的大小,仅仅定义大小而没有内容。我们称为动态初始化,所以我们可以看到输出的结果是一个一维,length为4,默认值为0的数组。

要注意的地方:
(一)维度表达式和数组初始化器初始化大小时必须二选一
数组的初始化有几种方式,但是每种方式都必须为数组定义好大小。可以是方括号中的数字[10](dimension expressions,维度表达式),或则大括号的内容的个数{...,...,...}(array initializer,数组初始化器),初始化大小时,只能二选一,不然是会报编译错误的

int[] array1 = new int [4] {1,2,3,4};                 //error
//Cannot define dimension expressions when an array initializer is provided
int[] array2 = new int [4];                           //right
int[] array3 = new int [] {1,2,3,4}                   //right

当数组初始化器被提供的时候,不允许再在维度表达式定义大小,因为有可能存在这种冲突情况

int[] array1 = new int [10] {1,2,3,4}                 //error
//维度表达式定义的大小和数组初始化器初始化的内容的个数不符合 10 != 4,这样就存在冲突了 

(二)大小为0的数组

int[] array1 = {};
int[] array2 = new int [] {};
int[] array3 = new int [0] ;
//它们的输出结果都是   {}    ,不然任何数组内容,length为0

Java是允许这样定义数组的,但是目前我还不知道这样定义数组的好处是什么,因为数组可以说是一个大小不变的对象。起始大小为0就代表堆中的这个数组的大小永远都为0。这样子看来这种数组的存在毫无意义可言。如果你尝试引用这种数组,是会得到运行时异常的。

int[] array1 = {};
array1[0] = 1;          

数组越界异常Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0,大小为0的数组不存在下标为0具体内容。

(三)数组的length属性
所有数组(无论是对象类型还是基本类型)都有一个固定成员,可以通过它获知数组中包含了多少个元素,但不能对其进行改变,这个成员就是length.

int[] array1 = new int [10];
Sysytem.out.println(array1.length);                   //output : 10

补充:
多维数组跟一维数组的,对象数组和基本类型数组的定义和初始化过程基本上都类似。我们这里就直接通过多维对象数组来介绍一下。

Integer[][] array = new Integer[][] {
        {new Integer(1),new Integer(2),new Integer(3)},
        {new Integer(4),new Integer(5),new Integer(6)},
        {new Integer(7),new Integer(8),new Integer(9)}
};

for(Integer[] a :array){
        System.out.println(Arrays.toString(a));
}

输出结果

[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

所以我们可以看到定义和初始化其实是差不多了。不过我们也要注意多维数组一点的是

Integer[][] array1 = new Integer[][4];      //error,编译错误
//Cannot specify an array dimension after an empty dimension
Integer[][] array2 = new Integer[4][];      //right,相当定义了

第二种定义输出的结果是4个null,不是4个{}。所以第二种的定义方式并不是初始化了4个大小为0的数组。而是定义了4个一维数组,再四个第一维的数组中分别定义了一个数组变量,该变量指向null,既还不指向任何地址。

数组工具类几种常用的应用


Arrays.fill()

这是一个作用十分有限的功能,相对于基本类型数组来说,只能使用同一个值来填充各个位置。相对于对象数组来说,就是将对象数组的各个部分都引用同一个地址。通过查看fill()方法的源码就可以了解的很清楚。
测试代码:

public class FillDemo {

    public static void main(String[] args) {
        int[] i1 = new int[5];
        Integer[] i2 = new Integer[10];

        Arrays.fill(i1, 1);
        Arrays.fill(i2, new Integer(2));

        System.out.println(Arrays.toString(i1));
        System.out.println(Arrays.toString(i2));
    }
}

结果:

[1, 1, 1, 1, 1]
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

我们可以看到

Arrays.copyOf()

Arrays.copyOf()方法是一个用来复制数组的方法,返回一个新数组对象的引用。那么在说Arrays.copyOf()方法之前,我们先来说一下Java标准库中提供的System.arraycopy()方法,用它来复制数组比用for复制快的多。

public static void ArrayCopy(){
    int[] i1 = new int[5];
    int[] i2 = new int[10];
    Arrays.fill(i1, 1);
    System.arraycopy(i1, 0, i2, 0, i1.length);
    System.out.println(Arrays.toString(i2));

    //output:[1, 1, 1, 1, 1, 0, 0, 0, 0, 0]
}

由上面的代码和输出,我们可以初步知道该函数是将i1数组的五个元素复制到i2数组中。我们来看一下arraycopy的具体源码

    //源码
public static native void arraycopy(Object src,  int  srcPos,
                                    Object dest, int destPos,
                                    int length);

发现这是一个native方法,既本地方法,不是由Java语言实现的方法,没有返回值,所以我们这么就不管它的具体实现,我们来看arraycopy的五个参数。第一个参数src代表源数组,既被复制的数组。第二个参数srcPos代表要从源数组的那个索引位置开始复制数据。第三个参数dest代表目标数组,既被赋值的数组。第四个参数destPos代表被复制的部分从目标数组的什么位置开始拷贝进去。第五个参数length代表要复制源数组中的多大的长度,既要复制的元素个数。

所以由此可知,我们上是从源数组s10位置开始复制,复制到s2目标数组中,从目标数组的0位置开始拷贝进去,总共复制的元素i1.length
特别注意,要注意数组的越界行为,避免出现java.lang.ArrayIndexOutOfBoundsException异常

我们学习了System.arraycopy的方法之后,我们再来看回Arrays.copyOf()方法

public static void CopyOf(){
    int[] i1 = new int[10];
    int[] i2 = new int[5];
    Arrays.fill(i1, 1);
    i2 = Arrays.copyOf(i1, 7);
    System.out.println(Arrays.toString(i2));

    //output :  [1, 1, 1, 1, 1, 1, 1]
}

由代码和输出,我们可以看出Arrays.copyOf()方法是截取源数组i17个元素,并组合成一个新的数组对象,返回新的数组对象的引用给目标数组变量i2
那么虽然Arrays.copyOf()System.arraycopy()使用方式,返回值,参数列表不同,但他们的功能是相似的,那么它们之间是什么关系呢?我们来看一下Arrays.copyOf()方法的源码

 public static int[] copyOf(int[] original, int newLength) {
     int[] copy = new int[newLength];
     System.arraycopy(original, 0, copy, 0,Math.min(original.length, newLength));
     return copy;
 }

我们惊奇的发现,实际Arrays.copyOf()方法的底层实现使用的仍然是System.arraycopy().所以我们可以这么说copyOf()是根据某种具体场景将System.arraycopy()封装起来的一个实现。

注意:
需要注意的是,Arrays.copySystem.arraycopy方法都不是一个深拷贝的方法,只是取原数组元素的引用重新组成一个新的数组对象,这个新的数组对象的地址倒是不同。但其中相应元素的地址任然是同一个。对象的Object.clone()方法对于数组而言也是一个浅拷贝,这跟Arrays.copyOf()System.arraycopy()方法特性一样。

当然这里也有一种观点是说Arrays.copy,System.arraycopyObject.clone都是一个深拷贝,这里的深拷贝是说的是整个数组对象的地址变了,也就是存放数组元素的躯壳变了。要从这个角度来说,这的确也是一个深拷贝。所以就看你从什么角度出发了。

Arrays.equals()

Arrays.equals()方法是一个用于比较整个数组的值是否相同的方法,数组相等的条件是元素个数必须相等,对应位置的元素的也相等(非引用地址对比)。

//基本类型数组
int[] i1 = new int[]{1,2,3,4};
int[] i2 = new int[]{1,2,3,4};
System.out.println(i1.equals(i2));                  //false
System.out.println(Arrays.equals(i1, i2));          //true

//对象数组
Integer[] i3 = new Integer[]{new Integer(1),new Integer(2)};
Integer[] i4 = new Integer[]{new Integer(1),new Integer(2)};
System.out.println(i3.equals(i4));                  //false
System.out.println(Arrays.equals(i3, i4));          //true

由上,我们可以看到如果直接使用数组的equals方法去比较,即使元素个数相同,对应位置元素的值也相同,也是false。但是使用Arrays.equals去比较却是true,这是为什么呢?我们分别查看一下源码。

//数组原生equals方法
public boolean equals(Object obj) {
    return (this == obj);
}

以上是数组原生的equals方法,我们都知道数组实际也是一个对象,所以说白了数组的实现也是继承于Object类,但是数组不像其他的包装类,如Integer类,重写了equals方法。所以数组的equals方法就是没做任何改动,直接拿的Object类的equals方法来使用的。所以在数组原生的equals方法中,我们可以看到,它使用==去比较,比较的是传过来的对象的地址和当前对象的地址。所以自然是false.

//Arrays工具类int类型的equals重载方法
public static boolean equals(int[] a, int[] a2) {
    if (a==a2)
        return true;
    if (a==null || a2==null)
        return false;

    int length = a.length;
    if (a2.length != length)
        return false;

    for (int i=0; i<length; i++)
        if (a[i] != a2[i])
            return false;

     return true;
  }

以上是Arrays类的关于Int型的equals方法,我们可以看到它的4个判断流程,首先比较两个数组的地址是否相等,再比较两个数组的引用是否都为Null,再比较两个数组的长度是否相等,再比较两个数组对应位置的值是否一致。所以可想而知,为true。当然Arrays类关于不同的类型,基本类型,包装类型都有自己不同equals重载方法。因为太多了,就不一一罗列。有兴趣的,可以自己看源码研究一下。

Arrays.sort()

Arrays.sort()方法是工具类提供的数组排序方法。对于基本类型数组排序使用的是(DualPivotQuicksort)“快速排序算法”,对于对象数组使用的是(legacyMergeSort)“稳定归并排序”和(ComparableTimSort)比较分类方法,所以无需担心排序的性能。这都是做过优化的。
Arrays.sort()的使用方式可以比较多种多样,目前我就简单的说一下,有时间再专门针对这里写了一个总结。

    public static void main(String[] args) {
        int[] i1 = new int[]{1,3,2,4};
        Arrays.sort(i1);
        System.out.println(Arrays.toString(i1));

        Integer[] i3 = new Integer[]{new Integer(1),new Integer(3),new Integer(2),new Integer(4)};
        Arrays.sort(i3);
        System.out.println(Arrays.toString(i3));
    }

结果

[1, 2, 3, 4]
[1, 2, 3, 4]

我们可以看到默认的排序方式是升序的,是从大到小排序的。因为Arrays.sort()没有专门的降序排序的实现,如果是基本类型数组,就从后遍历赋值给另一个数组,如果是对象数组,可以通过实现Comparator方法来完成,比较麻烦一些。

public class SortDemo {
    public static void main(String[] args) {
        MyComparator comparator = new MyComparator();

        Integer[] i3 = new Integer[]{new Integer(1),new Integer(3),new Integer(2),new Integer(4)};
        Arrays.sort(i3,comparator);
        System.out.println(Arrays.toString(i3));

        //output : [4,3,2,1]
    }

}

class MyComparator implements Comparator<Integer>{

    @Override
     public int compare(Integer o1, Integer o2) {
       //如果o1小于o2,我们就返回正值,如果o1大于o2我们就返回负值,
         //这样颠倒一下,就可以实现反向排序了
         if(o1 < o2) {
            return 1;
         }else if(o1 > o2) {
             return -1;
         }else {
             return 0;
         }
     }
 }
Arrays.binarySearch()

有待

Arrays.asList()

关于Arrays.asList()方法的使用,我查了很多的资料,发现很多地方都在说这个方法的坑。也的确存在一些坑。所以我这里就顺带的数一下,有时间再专门整理一个贴。

总的来说这个Arrays.asList()方法是将一个数组转换成一个集合的实例。

  • 该方法不适用于基本数据类型(byte,short,int,long,float,double,boolean),直接使用会存在一定的问题。
  • 该方法将数组与集合关联在一起,当修改其中一个,也会影响到另一个,因为它们两个使用的是同一个地址
  • 不支持add和remove方法,返回的是一个只可读的“ArrayList”实例,此ArrayList非彼ArrayList.不是我们通常所说的ArrayList

关于基本数据类型不能使用的问题,我暂时还没有想明白,所以暂时这里就不讨论了。

测试代码:

public static void method1 (){
    Integer[] i = {1,2,3};
    List list = Arrays.asList(i);

    System.out.println("修改前Array"+Arrays.toString(i));
    System.out.println("修改前list"+list);

    i[1]=0;

    System.out.println("修改后Array"+Arrays.toString(i));
    System.out.println("修改后list"+list);
}

结果:

修改前Array[1, 2, 3]
修改前list[1, 2, 3]
修改后Array[1, 0, 3]
修改后list[1, 0, 3]

从上面看,我们就能得出结果,的确Arrays.asList(i)得到的集合会跟数组i关联起来,你更新,我就更新。这是为什么呢?我们来查看一下源码asList的源码

 @SafeVarargs
 @SuppressWarnings("varargs")
 public static <T> List<T> asList(T... a) {
     return new ArrayList<>(a);
 }

asList()方返回了一个ArrayList<>()的实例对象,这好像没有关系,我们点击这个ArrayList。却发现这里面别有洞天,这不是一个不同的ArrayList,既不是我们平时所常用java.util包下的ArrayList.而是Arrays类中的静态内部类ArrayList….这就牛逼啦。

 //静态内部类ArrayList的构造方法
 ArrayList(E[] array) {
      a = Objects.requireNonNull(array);
 }

在点进Objects.requireNonNull()方法

 public static <T> T requireNonNull(T obj) {
      if (obj == null)
          throw new NullPointerException();
      return obj;
 }

由此我们可以看出来,当数组i从asList(i)中传入,然后到静态内部类ArrayList的构造方法,再到构造方法中的Objects.requireNonNull()方法,i数组的引用一直给传递下去,最后判断该引用是否为Null,如果不是则直接返回该引用到List变量list中。所以list所指向的地址和i数组指向的地址其实是同一个地址…所以才会互相牵连。

又为什么返回的这个list不能扩展呢?那是因为这个Arrays类的静态内部类ArrayList没有重写父类AbstractListaddremove功能。所以就相当于直接从父类AbstractList继承下addremove方法。我们看看AbstractList类的addremove的源码,我们就一清二楚了。

//AbstractList类相关方法的源码
 public void add(int index, E element) {
     throw new UnsupportedOperationException();
 }


 public E remove(int index) {
     throw new UnsupportedOperationException();
 }

看了源码我们就一目了然了,使用removeadd方法会导致报UnsupportedOperationException异常,因为该方法没有得到重写…so.明白了吧


参考资料

《Java编程思想》第四版
《Java语言程序设计》基础篇
Array.asList:数组转list时你一定要知道的“陷阱”!
Arrays.asList()源码剖析


在此感谢参考过的网站和博客的作者,谢谢!!

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页