Thinking in java ——数组

请优先使用高级容器集合，除非证明用数组确实效率高，否则当然优先使用容器集合。

效率方面（数组优势）：

在java中，数组是效率最高的存储和随机访问对象引用的一种方式。The array is Java’s most efficient way to store and randomly access a sequence of object references.

因为它是个线性序列，访问速度很快，但是在其生命周期内大小无法改变,array.length就是它的容量大小。

类型安全：泛型出现之前，除了数组外的其他容器都无法限制数据类型，统一按照Object对待，并且无法存放基本类型。

注意1： List<String> list = Arrays.asList(new String[] { "1", "2" });  返回的是一个大小固定的list。

              （Returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.)）

                List<String> list = new ArrayList(Arrays.asList(new String[] { "1", "2" }));  返回的是一个大小不固定的list。 

数组初始化：对象类型的数组 e.g.  String[] sarray=new String[4];  sarray[0] ——sarray[3]都初始化为null 

                 基本类型  初始化为0，false等等

例（根据传入参数返回一个数组，数组中的元素取自一个常量集合，但是不能重复）：

<span style="font-size:14px;">package com.java.array;

import java.util.Arrays;
import java.util.Random;

public class IceCream {

	private static Random random = new Random();

	static final String[] FLAVORS = new String[] { "Chocolate", "Strawberry",
			"Lemon", "Mint Chip", "Mud Pie" };

	static String[] setFlavor(int n) {
		if (n > FLAVORS.length) {
			throw new IllegalArgumentException("n is too big");
		}
		String[] rs = new String[n];
		boolean[] picked =  new boolean[FLAVORS.length];
		for (int i = 0; i < n; i++) {
			
			int t;
			
			do {
				t = random.nextInt(FLAVORS.length);
				System.out.println("t："+t);
			} while (picked[t]);
			picked[t] = true;
			rs[i] = FLAVORS[t];
		}

		return rs;
	}

	public static void main(String[] args) {

		String[] rs = setFlavor(5);
		System.out.println(Arrays.toString(rs));
	}

}</span>

数组与泛型：数组与泛型通常无法公用，当然一般也没人这样用。唯一可以公用的示例：

<span style="font-size:14px;">// 数组无法使用泛型,但是可以声明后强转
		// !ArrayList<String>[] ls = new ArrayList<String>[3];
		ArrayList<String>[] ls = (ArrayList<String>[]) new ArrayList[10];</span>

Arrays.fill()  向指定的数组中填充复制值（基本类型）；或者向数组中填充同一个对象的引用（对象类型）;

<span style="font-size:14px;">		ArrayList<String>[] ls = (ArrayList<String>[]) new ArrayList[10];
		List<String> list = new ArrayList<String>();
		list.add("1");
		Arrays.fill(ls, list);
		System.out.println(Arrays.toString(ls));
		list.remove(0);//删除list对象中的元素，查看数组的情况
		System.out.println(Arrays.toString(ls));</span>

<span style="font-size:14px;">         /*output
	 * [[1], [1], [1], [1], [1], [1], [1], [1], [1], [1]] 
	 * [[], [], [], [], [], [], [], [], [], []]
	 */</span>

遇到的一个小问题：

<span style="font-size:14px;">Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;</span>

<span style="font-size:14px;">public class Test {

    public static void main(String[] args) {
        System.out.println(new CountingGenerator.String(12).next());
        List<Integer> list=new ArrayList<Integer>();
        list.add(new Integer(1));
        list.add(new Integer(2));
	Integer[] c =null;
        //throw an exception: 
        //Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer;
	//1.list.toArray() return an Object[] which is not superClass of Integer[] 
	//2.c= list.toArray(new Integer[]{}); is correct! return Integer[] **
	c =  (Integer[]) list.toArray(c);
		 
    }
}</span>

in other words,1you can't treat a list of Integer IS-A list of Object! Integer[] a... and int b[] ...  ;2 a=b or b=a is wrong,they won't be autoboxing or autounboxing!

Arrays常用方法:

Arrays里有很多常用的 static method，如比较两个数组的 Arrays.equals()(多维数组用Arrays.deepEquals())；Arrays.fill()用于对数组填充元素；Arrays.sort()对数组排序，Arrays.toString()使数组成为字符串；Arrays.binarySearch()排序后查找元素；Arrays.hasCode()产生数组的散列码;Arrays.asList()接收任意序列或数组为参数翻回一个List.

另外：System.arraycopy(Object src,int srcPos, Object dest, int destPos, int length) src是复制源数组，原数组复制的起始位置，（复制到）目的数组，复制的元素个数；另个数组必须类型完全一致，数组无法自动拆箱装箱。

Arrays.equals() : 比较两个数组中对应位置的对应元素的equals方法是否返回true。改写equalsf方法：

<span style="font-size:14px;">	public boolean equals(Object obj) {
		if (obj == this) {
			return true;
		} else if (obj instanceof Test19) {
			return ((Test19) obj).i == this.i;
		} else {
			return false;
		}
	}</span>

Arrays.sort() : 两个数组排序，你可以给你的要排序的对象类实现Comparable接口。另外一种就是用策略模式，可以用匿名内部类的方式实现Comparator接口。当你传入的Comparator对象不同，就会有不同的比较方式。（传入对象的不同而产生不同行为——策略模式）如下，就是按照CompType对象的 j变量做比较的，当然你也可以按照其他变量做比较排序！

<span style="font-size:14px;">		Arrays.sort(array, new Comparator<CompType>() {
			@Override
			public int compare(CompType o1, CompType o2) {
				return o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1);
			}
		});
		</span>

java标准类库正对正排序（字符串大写字母在前）做了优化：对于基本类型使用“快速排序”，对对象类型使用”稳定归并排序“。除非你能证明排序是瓶颈，否则无需担心排序问题！

Arrays.binarySearch()：

1.首先要对查找的数组做Arrays.sort()排序；2.其算法为二分查找，返回索引号；3.数组中有重复的元素，查找时随机返回任意一个索引号。对于对象类型需要传入改写的Comparator作为参数！