Java中ArrayList與數組間相互轉換

　　在實際的 Java 開發中，如何選擇數據結構是一個非常重要的問題。

衡量標准化(讀的效率與改的效率) ：

　　 ① Array： 讀快改慢

       ② Linked ：改快讀慢

       ③ Hash：介於兩者之間

實現List、Set和數組之間轉換的關鍵點如下：（一定要注意泛型的引用）

 　　1. List轉換成數組可以使用List的toArray方法，返回一個Object數組；

  　   2. Set轉換成數組可以使用Set的toArray方法，返回一個Object數組；

 　  3. 如果List或Set中元素的類型都為A，那么可以使用帶參數的toArray方法，得到類型為A的數組，具體語句是“（A[]）set.toArray(new A[0])”；

    　4.  數組轉換成List可以使用Arrays的asList靜態方法，得到一個List；

 　   5. 數組轉化成Set時，需要先將數組轉化成List再用List構造Set；

  Demo_1：List 轉數組

import java.util.*;
public class Test {
	public static void print(Double arr[]) {
		for (int i=0; i<arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {  
    	ArrayList<Double> list = new ArrayList<Double>(); 
    	// 若不寫成泛型(<Double>)的方式，則下面： Double arr3[] = list.toArray(new Double[0]);
    	// 要改寫成：Double arr3[] = (Double[])list.toArray(new Double[0]);
        list.add(1.23);  
        list.add(4.57);  
        list.add(2.38); 
        list.add(4.598);
        int size = list.size();
        System.out.println(size); // 輸出：4
// 第一種方法，不推薦
        Double arr1[] = new Double[size];
        for(int i=0;i<size;i++){  
            arr1[i]=(double)list.get(i);  
        }  
        print(arr1); // 輸出：1.23 4.57 2.38 4.598
// 第二種方法，推薦
        // 當list中的數據類型都一致時可以將list轉化為數組
        Object arr2[] = list.toArray();
        System.out.println("從list轉換成的對象數組長度為：" + arr2.length); // 輸出：從list轉換成的對象數組長度為：4
        // 在轉化為其它類型的數組時需要強制類型轉換，並且，要使用帶參數的toArray方法，參數為對象數組.
        // 將list中的內容放入參數數組中，當參數數組的長度小於list的元素個數時，會自動擴充數組的長度以適應list的長度
        Double arr3[] = list.toArray(new Double[0]);
        System.out.println("從list轉換成的字符串數組長度為：" + arr3.length); // 輸出：從list轉換成的字符串數組長度為：4
        print(arr3); // 輸出：1.23 4.57 2.38 4.598 
        // 分配一個長度與list的長度相等的字符串數組
        Double[] arr4 = list.toArray(new Double[list.size()]);
        System.out.println("從list轉換成的字符串數組長度為：" + arr4.length); // 輸出：從list轉換成的字符串數組長度為：4
        print(arr4); // 輸出： 1.23 4.57 2.38 4.598 
	} 
}

 Demo_2：數組轉 List

import java.util.*;
public class Test {
	   public static void main(String[] args) {
	      List<Double> list = new ArrayList<Double>();
	      list.add(1.23);
	      list.add(4.57);
	      list.add(2.38);
	      list.add(4.598);
	      System.out.println(list); // 輸出：[1.23, 4.57, 2.38, 4.598]
	      list.clear();
	      System.out.println(list.size()); // 輸出：0
	   // 直接使用Arrays的asList方法
	      Double arr[] = {1.23,4.57,2.38,4.598};
	      list = Arrays.asList(arr);
	      System.out.println("將數組轉換成list的元素個數為：" + list.size()); // 輸出：將數組轉換成list的元素個數為：4
	      System.out.println(list); // 輸出：[1.23, 4.57, 2.38, 4.598]
	   }
}

 Demo_3：set 轉數組

import java.util.*;
public class Test {
	public static void print(Double arr[]) {
		for (int i=0; i<arr.length; i++) {
			System.out.print(arr[i]+" ");
		}
		System.out.println();
	}
	public static void main(String[] args) {  
    	HashSet<Double> set = new HashSet<Double>(); 
    	// 若不寫成泛型(<Double>)的方式，則下面： Double arr3[] = set.toArray(new Double[0]);
    	// 要改寫成：Double arr3[] = (Double[])set.toArray(new Double[0]);
        set.add(1.23);  
        set.add(4.57);  
        set.add(2.38); 
        set.add(4.598);
        int size = set.size();
        System.out.println(size); // 輸出：4
// 第一種方法，不推薦
        Double arr[] = new Double[size];
        Iterator<Double> i = set.iterator(); 
        // 若寫成 Iterator i = set.iterator()，則下面要寫成 arr[j] = (Double) i.next();
        int j =0;
        while(i.hasNext()){
        	arr[j] = i.next();
        	j++;
        }
        print(arr); // 輸出：4.598 2.38 1.23 4.57 
// 第二種方法，推薦
        // 當set中的數據類型都一致時可以將set轉化為數組
        Object arr1[] = set.toArray();
        System.out.println("從set轉換成的對象數組長度為：" + arr1.length); // 輸出：從set轉換成的對象數組長度為：4
        // 在轉化為其它類型的數組時需要強制類型轉換，並且，要使用帶參數的toArray方法，參數為對象數組.
        // 將set中的內容放入參數數組中，當參數數組的長度小於set的元素個數時，會自動擴充數組的長度以適應list的長度
        Double arr2[] = set.toArray(new Double[0]);
        System.out.println("從set轉換成的Double數組長度為：" + arr2.length); // 輸出：從list轉換成的字符串數組長度為：4
        print(arr2); // 輸出：4.598 2.38 1.23 4.57 
        // 分配一個長度與list的長度相等的字符串數組
        Double[] arr3 = set.toArray(new Double[set.size()]);
        System.out.println("從set轉換成的字符串數組長度為：" + arr3.length); // 輸出：從list轉換成的字符串數組長度為：4
        print(arr3); // 輸出： 4.598 2.38 1.23 4.57 
	} 
}

  Demo_4：數組轉 set

import java.util.*;
public class Test {
	   public static void main(String[] args) {
	      HashSet<Double> set = new HashSet<Double>();
	      set.add(1.23);
	      set.add(4.57);
	      set.add(2.38);
	      set.add(4.598);
	      System.out.println(set); // 輸出：[4.598, 2.38, 1.23, 4.57]
	      set.clear();
	      System.out.println(set.size()); // 輸出：0
	      Double arr[] = {1.23,4.57,2.38,4.598};
	      // 間接使用Arrays的asList方法，將數組轉換成List后，再用List構造Set
	      set = new HashSet<Double>(Arrays.asList(arr));
	      System.out.println("將數組轉換成set的元素個數為：" + set.size()); // 輸出：將數組轉換成set的元素個數為：4
	      System.out.println(set); // 輸出：[4.598, 2.38, 1.23, 4.57]
	   }
}