Java基础之数组篇

概述

是什么
通过new关键字创建并组装他们，通过使用整形索引值访问它的元素，并且它的尺寸是不可变的！
数组是一个简单的复合数据类型，它是一系列有序数据的集合，它当中的每一个数据都具有相同的数据类型，我们通过数组名加上一个不会越界下标值来唯一确定数组中的元素。
数组是一个特殊的对象

不管在其他语言中数组是什么，在java中它就是对象。一个比较特殊的对象。

public class Test {
    public static void main(String[] args) {
        int[] array = new int[10];
        Class clazz = array.getClass(); 
        System.out.println(array.length);
        System.out.println(clazz.getSuperclass());
        System.out.println(clazz.getName());
        System.out.println(Object[].class);
        System.out.println(Object[][].class);

        System.out.println("-------------------------------");

        System.out.println(clazz.getDeclaredFields().length);   
        System.out.println(clazz.getDeclaredMethods().length);   
        System.out.println(clazz.getDeclaredConstructors().length);   
        System.out.println(clazz.getDeclaredAnnotations().length);   
        System.out.println(clazz.getDeclaredClasses().length); 
    }
}

/*
输出：
10                                 //数组的长度
class java.lang.Object             //数组的父类是Object
[I                                 //一维整型数组的类名是[I
class [Ljava.lang.Object;          //一维对象数组类名[L

class [[Ljava.lang.Object;         //二维对象数组类名[[L
\-------------------------------
0            
0
0
0
0


*/

从第二部分输出可以看到：数组没有生命任何成员变量、成员方法、构造函数、Annotation甚至连length成员变量这个都没有，它就是一个彻彻底底的空类

---

没有声明length，那么我们array.length时，编译器怎么不会报错呢？确实，数组的length是一个非常特殊的成员变量。我们知道数组的是Object的直接子类，但是Object是没有length这个成员变量的，那么length应该是数组的成员变量，但是从上面的示例中，我们发现数组根本就没有任何成员变量，这两者不是相互矛盾么？

public class Test {
    public static void main(String[] args) {
        int a[] = new int[2];
        int i = a.length;
    }
}

使用SUN JDK 1.6编译上述代码，并使用jclasslib打开Test.class文件，得到main方法的字节码：

0 iconst_2                   //将int型常量2压入操作数栈  
1 newarray 10 (int)          //将2弹出操作数栈，作为长度，创建一个元素类型为int, 维度为1的数组，并将数组的引用压入操作数栈  
3 astore_1                   //将数组的引用从操作数栈中弹出，保存在索引为1的局部变量(即a)中  
4 aload_1                    //将索引为1的局部变量(即a)压入操作数栈  
5 arraylength                //从操作数栈弹出数组引用(即a)，并获取其长度(JVM负责实现如何获取)，并将长度压入操作数栈  
6 istore_2                   //将数组长度从操作数栈弹出，保存在索引为2的局部变量(即i)中  
7 return                     //main方法返回

在这个字节码中我们还是没有看到length这个成员变量，但是看到了这个:arraylength ,这条指令是用来获取数组的长度的，所以说JVM对数组的长度做了特殊的处理，它是通过arraylength这条指令来实现的。

使用方法

数组的使用方法无非就是四个步骤：声明数组、分配空间、赋值、处理。

声明数组：就是告诉计算机数组的类型是什么。有两种形式：int[] array、int array[]。
分配空间：告诉计算机需要给该数组分配多少连续的空间，记住是连续的。array = new int[10];
赋值：赋值就是在已经分配的空间里面放入数据。array[0] = 1 、array[1] = 2……其实分配空间和赋值是一起进行的，也就是完成数组的初始化。有如下三种形式：

int a[] = new int[2];    //默认为0,如果是引用对象类型就为null
int b[] = new int[] {1,2,3,4,5};    
int c[] = {1,2,3,4,5};

性能

数组与其他种类的容器之间的区别有三个方面：效率、类型和保存基本类型的能力。在java中，数组是一种效率最高的存储和随机访问对象引用序列的方式。
在项目设计中数组使用的越来越少了，而且它确实是没有List、Set这些集合使用方便，但是在某些方面数组还是存在一些优势的，例如：速度，而且集合类的底层也都是通过数组来实现的。
因为在list中，list.add(5),要进行装箱操作，而list.get(i)，进行拆箱动作，Integer对象通过intValue方法自动转换成一个int基本类型，在这里就产生了不必要的性能消耗。

数组的扩容

public class ArrayUtils {
    public static <T> T[] expandCapacityMul(T[] datas,int mulitiple){
        mulitiple = mulitiple < 0 ? 1 : mulitiple;
        int newLen = datas.length * mulitiple;
        return Arrays.copyOf(datas,newLen );
    }
}

public class Test {
    public static void main(String[] args) { 
        int sum=0;
        Integer [] arr ={1,2,3,4,5,6,7,8,9,10,11};
        System.out.println(arr.length);
        arr=ArrayUtils.expandCapacityMul(arr, 2);
        System.out.println(arr.length);
        System.out.println(arr[4]);
        System.out.println(arr[14]);
    }
}

输出：
11
22
5
null

数组转换为Arraylist

我们经常需要使用到Arrays这个工具的asList()方法将其转换成列表.但有需要注意的地方

public class Test {
    public static void main(String[] args) {
        int[] datas = new int[]{1,2,3,4,5};  
        List list = Arrays.asList(datas);
        System.out.println(list.size());

        Integer[] datas2 = new Integer[]{1,2,3,4,5};
        List list2 = Arrays.asList(datas2);
        System.out.println(list2.size());
        list2.add(10);
        System.out.println(list2.size());

    }

}

输出:
1
5

Exception in thread “main” java.lang.UnsupportedOperationException
at java.util.AbstractList.add(Unknown Source)
at java.util.AbstractList.add(Unknown Source)
at java_interview.Test.main(Test.java:36)

数组中可以放基本数据类型和对象
集合中只能放放对象
基本数据类型是不可能泛型化的，也是就说8个基本数据类型是不可作为泛型参数的

编译没错，但是运行竟然出现了异常错误！UnsupportedOperationException ，当不支持请求的操作时，就会抛出该异常。从某种程度上来说就是不支持add方法

asList()源码：

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

再进一步ArrayList源码：

 private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
            a = array;
        }

        public int size() {...}
        public Object[] toArray() {...}
        public <T> T[] toArray(T[] a) {...}
        public E get(int index) {..}
        public E set(int index, E element) {...}
        public int indexOf(Object o) {... }
        public boolean contains(Object o) {...}
    }

再看它的父类AbstractList：

   public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }

这里父类仅仅只是提供了方法，方法的具体实现却没有，所以具体的实现需要子类自己来提供，但是非常遗憾这个内部类ArrayList并没有提供 add的实现方法

而在ArrayList中，它主要提供了如下几个方法：

  1、size：元素数量
  2、toArray：转换为数组，实现了数组的浅拷贝。
  3、get：获得指定元素。
  4、contains：是否包含某元素。

所以综上所述，asList返回的是一个长度不可变的列表。数组是多长，转换成的列表是多长，我们是无法通过add、remove来增加或者减少其长度的。

java.util.Arrays的数组工具类的使用

数组对象的方法只有.length(),其余就是从Object类来的方法

其余对数组操作的函数都在Arrays工具类中
包括排序，二分查找(一定是对有序的数组查找)，数组的复制，数组值的填充

public class Test {
    public static void main(String[] args) {
        //一维数组
        int[] datas = new int[]{5,3,2,4,1,4}; 

        Integer [] data_integer=new Integer[]{3,8,3,2,4};


        //二维数组
        int[][] datas2=new int[][]{
                {1,8,3,7},
                {5,2,6,9},
                {3}
        };

        //数组转为list,数组中的类型必须是引用数据类型
        List list=Arrays.asList(data_integer);//
        System.out.println(list.toString());



        //数组的行列
        System.out.println("数组的行："+datas2.length);
        System.out.println("数组的列："+datas2[0].length);
        System.out.println("数组的列："+datas2[2].length);


        //数组排序和遍历
        Arrays.sort(datas);
        System.out.print("sort:");
        for(int x:datas)
              System.out.print(x);//数组的遍历

        //二分查找
       System.out.println("\n"+"查到了："+Arrays.binarySearch(datas, 4));//返回要查找数的第一个位置
       System.out.println("没查到："+Arrays.binarySearch(datas, 6));//查不到则返回-(length+1)


       //toString()
        String str=Arrays.toString(datas);
        System.out.println("字符串："+str);


        //复制
        int newdata[] = Arrays.copyOf(datas, 10);
       System.out.println("copyOf:"+Arrays.toString(newdata));

       //按范围复制
       System.out.println("原字符串："+Arrays.toString(datas));
        int newdata2[] =Arrays.copyOfRange(datas, 0, 3);
        System.out.println("copyOfRange:"+Arrays.toString(newdata2));
        int newdata3[] =Arrays.copyOfRange(datas, 3, datas.length);
        System.out.println("copyOfRange:"+Arrays.toString(newdata3));

        //填充一个数组
        Arrays.fill(newdata2, 20);
        System.out.println("fill:"+Arrays.toString(newdata2));

        //判断两个数组相等
        int data_copy[]=Arrays.copyOf(datas, 6);
        System.out.println(Arrays.equals(datas, data_copy));//两个数组长度一样，其中元素也相同，则相等

    }

}

输出：
[3, 8, 3, 2, 4]
数组的行：3
数组的列：4
数组的列：1
sort:123445
查到了：4
没查到：-7
字符串：[1, 2, 3, 4, 4, 5]
copyOf:[1, 2, 3, 4, 4, 5, 0, 0, 0, 0]
原字符串：[1, 2, 3, 4, 4, 5]
copyOfRange:[1, 2, 3]
copyOfRange:[4, 4, 5]
fill:[20, 20, 20, 20]
true

【参考原文】http://www.cnblogs.com/chenssy/p/3463719.html