JavaSE——数组详解

• • Java中数组的特性
  • 一维数组
  • • • 定义
      • 静态初始化
      • 动态初始化
  • 二维数组
  • • • 定义
      • 静态初始化
      • 动态初始化
  • Arrays工具类
  • • • 转字符串
      • 填充数组
      • 排序
      • 数组比较
      • 数组拷贝
      • 二分查找
      • 数组转列表
      • 对数组元素进行指定运算

Java中的数组有一些令人十分困惑的地方。在Java中，数组是引用数据类型，引用类型的数据被创建时，首先要在栈上给其引用（句柄）分配一块内存，而它的具体信息都存储在堆内存上，然后由栈上面的引用指向堆中对象的地址。而令人困惑之处在于：数组是引用数据类型，那它是不是对象呢？

我们从以下几点进行探讨：

1. 要判断数组是不是对象，那么首先明确什么是对象，也就是对象的定义。在较高的层面上，对象是根据某个类创建出来的一个实例，表示某类事物中一个具体的个体。对象具有各种属性，并且具有一些特定的行为。而在较低的层面上，站在计算机的角度，对象就是内存中的一个内存块，在这个内存块封装了一些数据，也就是类中定义的各个属性，所以，对象是用来封装数据的。
   然而，在较高的层面上，数组不是某类事物中的一个具体的个体，而是多个个体的集合。那么它应该不是对象。而在计算机的角度，数组也是一个内存块，也封装了一些数据，这样的话也可以称之为对象。

2. 在使用数组的引用变量时，我们可以用它来调用一些属性和方法：

   int[] arr = {1,2,3};
   System.out.println(arr.length); //3
   
   Class c = arr.getClass();
   System.out.println(c.getName());    //[I
   
   int[] arr2 = arr.clone();
   System.out.println(Arrays.toString(arr2));  //[1, 2, 3]
   
   System.out.println(arr.hashCode());
   

   可以发现，除了数组独有的length属性外，其他的所有方法都来自Object这个类，这说明数组继承了Object类，接下来验证我们的想法：

   int[] arr = {1,2,3};
   Object obj = arr;   //向上转型，可以，编译器没有报错,可以使用obj里面的方法。
   
   int[] arr2 = (int[]) obj;   //向下转型，也可以。
   
   System.out.println(obj instanceof int[])	//用instanceof判断obj是不是int[]类型，结果true
   

所以到这里，我们可以基本得到这样一个结论：数组是一个特殊的类型，有Class实例对象，继承了Object类的很多方法，只是这个类型显得比较奇怪，但是我们没有自己创建这个类，也没有在Java的标准库中找到这个类。这只能有一个解释，那就是虚拟机自动创建了数组类型，可以把数组类型和8种基本数据类型一样， 当做java的内建类型，基本数据类型也有自己的Class实例对象，包括void也有。这种类型的命名规则是这样的：

每一维度用一个[表示；开头两个[，就代表是二维数组。

[ 后面是数组中元素的类型(包括基本数据类型和引用数据类型)

在java语言层面上,arr是数组,也是一个对象,那么他的类型应该是int[]，这样说是合理的。但是在JVM中，他的类型为[I。顺便说一句普通的类在JVM里的类型为 包名+类名，也就是全限定名。

看到了这里，你以为事情真的这么简单？不不不，来看一个例子：

public class Test01 {
    public static void main(String[] args) {
        String[] s = {"abc","123"};
        Object obj = s;     //obj指向s，没毛病，String[]是Object的子类，父类变量指向子类的引用
        Object[] objs = s;  //objs也可以指向s，这说明String[]也是Object[]的子类，这显然不符合Java的单继承

        //结果为java.lang.Object，我们通过String[]的Class对象得到它的父类的Class对象可以得到他的父类是Object，这说明String[]的直接父类就是Object
        System.out.println(s.getClass().getSuperclass().getName());
    }
}

既然String[]的直接父类是Object，那么对于Object[]类型的引用也可以指向String[]类型的对象，只可能是因为这是Java的一种特性，赋予我们的一种特权。只要有继承关系，都可以这么使用，比如：

Student[] s;
Person[] p = s;

当然对于多维数组，这种情况也奏效：

String[][] s = {{"123","abc"},{"456","def"}};
Object[][] objs = s2;

但是对于基本数据类型就不可以了:

//因为基本类型不是引用类型，Object不是它们的父类，在这里自动装箱不起作用
int[] i = {1,2,3};
Object[] objs1 = i;	//报错

//但是可以这么使用
Object[] objs2 = {1,'c',true};	//也就是Object类型的数组可以接受任意类型的值，包括基本数据类型，基本数据类型可以自动装箱

Java为什么会为数组提供这样一种语法特性呢？也就是说这种语法有什么作用？

所以这种特性主要是用于方法中参数的传递。Object数组中存放的就是原数组同维度的数据

public class Test01 {
    public static void main(String[] args) {
        String[] strs = {"123","456","abc"};
        test(strs);
    }
    
    public static void test(Object[] objects){
        for (Object object : objects) {
            System.out.println(object);
        }
    }
}

但是如果没有上面的数组特性(如果有两个类A和B，如果B继承了A，那么A[]类型的引用就可以指向B[]类型的对象)，那么数组类型就只能通过Object类型接收，这样就无法在方法内部访问或遍历数组中的各个元素

为什么说同维度呢？这是什么意思？来看看下面这种情况：

public class Test04 {
    public static void main(String[] args) {
        String[][][] arr = {{{"123","abc"},{"456","def"}},{{"789","ghi"},{"kfj","yyd"}}};
        Object[] objects = arr;
        for (Object object : objects) {
            System.out.println(object);
        }
    }
}

傻眼了吧，还有这种操作？？？

输出的结果是：

[[Ljava.lang.String;@1b6d3586
[[Ljava.lang.String;@4554617c

其实这就是这个三维数组第二维在内存中的数据类型+哈希值，即三维数组就是一维数组，只不过三维数组中存放的不是具体的值，而是一组指向其他东西的引用，这些东西可以是数组，也可以是具体的值。

所以对待数组，有时候我们要把它看为数组，有时候得把它看为对象，至于到底是数组还是对象，那就要看Java的设计者了。

为什么java要设计这样迷惑人的特性呢？太折磨人了吧！！！

//方式一（推荐）：数据类型[] 数组名
int[] arr1;

//方式二：数据类型 数组名[];
String arr2[];

//方式一：数据类型[] 数组名 = {值1,值2,值3...};
int[] arr3 = {1,2,3};

//方式二：数据类型[] 数组名 = new 数据类型[]{值1,值2,值3...};
int arr4 = new int[]{1,2,3};

//数据类型[] 数组名 = new 数据类型[数组长度];
int[] arr5 = new int[5];

//数据类型[][] 数组名
int[][] arr1;

//方式一：数据类型[][] 数组名 = {{值1,值2,值3...},{值1,值2,值3...}...}
int[][] arr2 = {{1,2,3},{4,5,6}};

//方式二：数据类型[][] 数组名 = new 数据类型[][]{{值1,值2,值3...},{值1,值2,值3...}...}
int[][] arr3 = new int[][]{{1,2,3},{4,5,6}};

//方式一：数据类型[][] 数组名 = new 数据类型[第一维的长度][第二维的长度]
int[][] arr4 = new int[2][3];

//方式二：数据类型[][] 数组名 = new 数据类型[第一维的长度][]，第二维在另行创建
int [][] arr5 = new int[2][];

//一维数组转字符串
String toString(基本数据类型或者Object[] arr);

//多维数组转字符串
String deepToString(Object[] arr);

//全部填充
void fill(int[] arr,int value);	

//部分填充，左闭右开
void fill(int[] arr,int fromIndex,int toIndex,int value);	

//默认排序
void sort(基本数据类型或Object[] arr);

//根据指定排序器排序
 void sort(T[] a, Comparator c);

//部分排序，左闭右开
void sort(int[] arr,int fromIndex,int toIndex);

//根据指定排序器排序，部分排序
 void sort(T[] a,int fromIndex,int toIndex,g Comparator c);

//并行排序，我的理解是排序所有元素同时进行
void parallelSort(基本数据类型或Object[] arr);	

//比较的是值
boolean equals(基本数据类型或者Object[] arr1,基本数据类型或者Object[] arr2);

//多维数组的比较
boolean deepEquals(Object[] arr1,Object[] arr2);	

基本数据类型[] copyOf(基本数据类型[] original,int newLength);

T[] copyOf(T[] original,int newLength);


基本数据类型[] copyOfRange(基本数据类型[] original,int fromIndex,int toIndex);

//全局查找，元素必须有序
基本数据类型 binarySearch(基本数据类型[] arr,基本数据类型 key);

Object binarySearch(Object[] arr,Object key);

T binarySearch(T[] arr,T key,Comparator c);	//指定排序器，元素无需有序

//部分查找，元素必须有序
基本数据类型 binarySearch(基本数据类型[] arr,int fromIndex,int toIndex,基本数据类型 key);

Object binarySearch(Object[] arr,int fromIndex,int toIndex,Object key);

T binarySearch(T[] arr,T key,int fromIndex,int toIndex,Comparator c);	//指定排序器，元素无需有序

//如果arr是基本数据类型数组，asList会把这个数组的引用加入列表中，并不会对每个元素进行装箱操作，这时需要使用包装类。
List asList(T... arr);

array = new int[]{3, 10, 4, 0, 2};

Arrays.parallelPrefix(array, (x,y)->(x+y)); //[3, 13, 17, 17, 19]

Arrays.parallelSetAll(array, (x)->(x*x)); 	//[0, 1, 4, 9, 16]

Arrays.setAll(array, (x)->(x%3));			//[0, 1, 2, 0, 1], 与parallelSetAll相比只是不并行