数组

                           数组

一、概述

1、数组是一种容器，与其他容器有三方面的区别：效率、类型和保存基本类型的能力。

2、数组是一种简单地线性序列，是一种存储和随机访问对象效率最高的序列方式。但，这种效率需要付出代价：数组的对象大小被固定，并且在其生命周期内不可变。

    3、数组标识符是一个引用，指向在堆中创建的一个真实对象(这个对象中保存了指向其他对象的引用)。

    4、函数可通过返回数组同一时间返回多个对象等。函数返回的是数组的引用。

    5、与C、C++不同，Java在数组的定义中并不为数组元素分配内存，因此[]中不用指出数组中元素个数，即数组长度。对于只是声明而没有开辟空间的数组，不能访问该数组；对于开辟了空间而没有赋值的数组，其自动初始化为空。

    6、数组初始化

class ElementArray{

  static int count;

  private String str;

  ElementArray(){

         count++;

         str = "element of array";

  }

}

public class InitArray {

  public static void main(String[] args) {

         //方式一

         ElementArray[] obArray1;

         //System.out.println(obArray1);

obArray1 = new ElementArray[]{new ElementArray(), new ElementArray(),};

         System.out.println(obArray1);

         //方式二

ElementArray[] obArray2 = new ElementArray[]{new ElementArray(), new ElementArray(),};

         System.out.println(obArray2);

         //方式三

         ElementArray[] obArray3 = new ElementArray[5];

         System.out.println(obArray3);

         for(int i=0; i<obArray2.length; i++){

                System.out.print("前：" + obArray3[i]  + "   ");

                if(obArray3[i] == null)

                       obArray3[i] = new ElementArray();

                System.out.println("后：" +obArray3[i]  + "   ");

         }    

  }

}

       运行结果：

[Larray.ElementArray;@b40443

[Larray.ElementArray;@83ce25

[Larray.ElementArray;@152e9a8

前：null   后：array.ElementArray@6a4268  

前：null   后：array.ElementArray@2de41d  

      上面的实例展示了数组初始化的三种方式。新生成一个数组对象时，其中所有的引用被自动初始化为null；索引检查其中的引用是否为null，即可知道数组的某个位置是否存有对象。同样，基本类型的数组如果是数值型的，就被自动初始化为0；如果是字符型(char)，就被自动初始化为(char)O；如果是布尔型(boolean)，就被自动初始化为false。

二、数组操作类Array

    1、类：java.lang.reflect.Array

    2、Array提供了动态创建和访问JAVA数组的方法，允许在执行get()或set()操作期间进行扩展和转换。如果发生收缩转换，则抛出IllegalArgumentException。

    3、Array的作用：(1)动态获取数组某个位置的值；(2)动态生成数组对象(一维或者多维)；(3)动态设置数组某个位置的值；(4)用于完成数组的反射应用。

    4、Array提供的方法都是静态方法，用于对JAVA数组的操作。

函数	参数	功能详述
get	(Object array, int index)	返回指定对象数组、指定索引的某种类型的值
getBoolean	(Object array, int index)
getByte	(Object array, int index)
getChar	(Object array, int index)
getDouble	(Object array, int index)
getFloat	(Object array, int index)
getInt	(Object array, int index)
getLong	(Object array, int index)
getShort	(Object array, int index)
set	(Object array, int index, Object value)	以某种类型设置指定数组、指定索引的值。
setBoolean	(Object array, int index, boolean z)
setByte	(Object array, int index, byte b)
setChar	(Object array, int index, char c)
setDouble	(Object array, int index, double d)
setFloat	(Object array, int index, float f)
setInt	(Object array, int index, int i)
getLong	(Object array, int index, long l)
setShort	(Object array, int index, short s)
getLength	(Object array)	返回指定数组对象的长度
newInstance	(Class<?> componentType, int... dimensions)	创建一个具有指定的组件类型和维度的新数组。
newInstance	(Class<?> componentType, int length)	创建一个具有指定的组件类型和长度的新数组。

     5、应用实例

import java.lang.reflect.Array; 

import java.util.Arrays; 

public class ArrayReflect { 

    public static void main(String[] args) throws SecurityException, NoSuchMethodException { 

    int[] arr = new int[10]; 

    for (int i = 0; i < arr.length; i++) { 

        arr[i] = i * i; 

    } 

    //使用Array反射获取数组的长度 

    int length = Array.getLength(arr); 

    System.out.println("length:  " + length);     

    //使用Array反射获取数组的某个位置的值 

    Object Obj = Array.get(arr, 5); 

    System.out.println("get() :  " + Obj);    

    //使用Array反射设置某个位置的值 

    Array.set(arr, 5, new Integer(1));

    //打印整个数组

    System.out.println(Arrays.toString(arr)); 

    //使用Array反射生成数组（一维数组）10 ：数组的长度 

    ElementArray[] obj = (ElementArray[]) Array.newInstance(ElementArray.class, 10); 

    for (int i = 0; i < obj.length; i++) { 

         ElementArray h = obj[i]; 

     System.out.print(h + "   "); // 都是null ，因为反射生成的都是引用 

    } 

    System.out.println();

    System.out.println("length:  " + obj.length); 

    //使用反射生成多维数组  其中 1 维：有2个B[]数组，每个数组总有4个B元素 

    ElementArray[][] obj2 = (ElementArray[][]) Array.newInstance(ElementArray.class, 2,4); 

    System.out.println(Arrays.toString(obj2)); 

    } 

}

运行结果：

length:  10

get() :  25

[0, 1, 4, 9, 16, 1, 36, 49, 64, 81]

null   null   null   null   null   null   null   null   null   null  

length:  10

[[Larray.ElementArray;@6a4268, [Larray.ElementArray;@2de41d]

三、数组操作类Arrays

     提供数组操作的相关的方法：搜索、拷贝、比较、排序等。Arrays提供都是静态方法。

函数	功能详述
asList	返回一个受指定数组支持的固定大小的列表
binarySearch	使用二分搜索法来搜索指定类型的数组(或数组的某个范围)，以获得指定的值。为了适应不同的数据类型，根据不同数据类型重载该方法。
copyOf	复制指定的数组，截取或用相应类型数据填充（如有必要），以使副本具有指定的长度。为了适应不同的数据类型，根据不同数据类型重载该方法。
copyOfRange	将指定数组的指定范围复制到一个新数组。为了适应不同的数据类型，根据不同数据类型重载该方法。
equals	如果两个指定的同类型数组彼此相等，则返回 true。为了适应不同的数据类型，根据不同数据类型重载该方法。
fill	将指定类型值分配给同一类型数组的每个元素。为了适应不同的数据类型，根据不同数据类型重载该方法。
hashCode	基于指定数组的内容返回哈希码。为了适应不同的数据类型，根据不同数据类型重载该方法。
sort	对指定类型数组(的指定范围)按数字升序进行排序。为了适应不同的数据类型，根据不同数据类型重载该方法。
toString	返回指定数组内容的字符串表示形式。为了适应不同的数据类型，根据不同数据类型重载该方法。
deepEquals	如果两个指定数组彼此是深层相等 的，则返回 true。该方法可应用于多维数组。
deepHashCode	基于指定数组的“深层内容”返回哈希码。该方法可应用于多维数组。
deepToString	返回指定数组“深层内容”的字符串表示形式。该方法可应用于多维数组。

     实例：

public class TestArrays {

    public static void output(int[] array) {

        if (array != null) {

            for (int i = 0; i < array.length; i++) {

                System.out.print(array[i] + " ");

            }

        }

        System.out.println();

    }

 

    public static void main(String[] args) {

        int[] array = new int[5];

        // 填充数组

        Arrays.fill(array, 5);

        System.out.print("填充数组：Arrays.fill(array, 5)：" + "  ");

        TestArrays.output(array);

        // 将数组的第2和第3个元素赋值为8

        Arrays.fill(array, 2, 4, 8);

        System.out.print("将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：");

        TestArrays.output(array);

        int[] array1 = { 7, 8, 3, 2, 12, 6, 3, 5, 4 };

        // 对数组的第2个到第6个进行排序进行排序

        Arrays.sort(array1, 2, 7);

        System.out.print("对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：");

        TestArrays.output(array1);

        // 对整个数组进行排序

        Arrays.sort(array1);

        System.out.print("对整个数组进行排序：Arrays.sort(array1)：");

        TestArrays.output(array1);

        // 比较数组元素是否相等

        System.out.println("比较数组元素是否相等:Arrays.equals(array, array1):" + "  "+ Arrays.equals(array, array1));

        int[] array2 = array1.clone();

              System.out.println("克隆后数组元素是否相等:Arrays.equals(array1, array2):" + "   "

                + Arrays.equals(array1, array2));

        // 使用二分搜索算法查找指定元素所在的下标（必须是排序好的，否则结果不正确）

        Arrays.sort(array1);

        System.out.print("排序后的数组 ：");

        TestArrays.output(array1);

        System.out.println("元素3在array1中的位置：Arrays.binarySearch(array1, 3)："

                + "   " + Arrays.binarySearch(array1, 3));

        // 如果不存在就返回负数

        System.out.println("元素9在array1中的位置：Arrays.binarySearch(array1, 9)："

                + "  " + Arrays.binarySearch(array1, 9));

    }

}

运行结果：

填充数组：Arrays.fill(array, 5)：  5 5 5 5 5

将数组的第2和第3个元素赋值为8：Arrays.fill(array, 2, 4, 8)：5 5 8 8 5

对数组的第2个到第6个元素进行排序进行排序：Arrays.sort(array,2,7)：7 8 2 3 3 6 12 5 4

对整个数组进行排序：Arrays.sort(array1)：2 3 3 4 5 6 7 8 12

比较数组元素是否相等:Arrays.equals(array, array1):  false

克隆后数组元素是否相等:Arrays.equals(array1, array2):   true

排序后的数组 ：2 3 3 4 5 6 7 8 12

元素3在array1中的位置：Arrays.binarySearch(array1, 3)：   1

元素9在array1中的位置：Arrays.binarySearch(array1, 9)：  -9

四、将数组转换为列表

import java.util.Arrays;

import java.util.Collections;

import java.util.List;

 

public class ArrayToList {

    static void printList(List<String> list){

        for(String e : list)

            System.out.print("  " + e);

        System.out.println();

    }

    public static void main(String[] args) {

        String[] strs = {"xue", "ma", "xiong", "feng", };

        //方法一

        List<String> strList = Arrays.asList(strs);

        ArrayToList.printList(strList);

        //方法二

        List strList1 = new ArrayList<String>(strs.length);

        for(String e : strs)

            strList1.add(e);

        ArrayToList.printList(strList1);

        //方法三

        List strList2 = new ArrayList();

        Collections.addAll(strList2, strs);

        ArrayToList.printList(strList2);

    }

}

运行结果：

xue  ma  xiong  feng

xue  ma  xiong  feng

xue  ma  xiong  feng

五、List转换为数组

    方法一： ArrayList<String> list=new ArrayList<String>();

String[] strings = new String[list.size()];

list.toArray(strings);

    方法二：ArrayList<String> list=new ArrayList<String>();

String strings[]=new String[list.size()];

for(int i=0,j=list.size();i<j;i++)

                     strings[i]=list.get(i);