Java Array、List、Set互相轉化

Java Array、List、Set互相轉化

1. Array、List、Set互轉實例
   1.1 Array、List互轉
   Array轉List

String[] s = new String[]{"A", "B", "C", "D","E"};
List<String> list = Arrays.asList(s);

注意這里list里面的元素直接是s里面的元素( list backed by the specified array)，換句話就是說：對s的修改，直接影響list。

s[0] ="AA";
System.out.println("list: " + list);

輸出結果

list: [AA, B, C, D, E]

List轉Array

String[] dest = list.toArray(new String[0]);//new String[0]是指定返回數組的類型
System.out.println("dest: " + Arrays.toString(dest));

輸出結果

dest: [AA, B, C, D, E]

注意這里的dest里面的元素不是list里面的元素，換句話就是說：對list中關於元素的修改，不會影響dest。

list.set(0, "Z");
System.out.println("modified list: " + list);
System.out.println("dest: " + Arrays.toString(dest));

輸出結果

modified list: [Z, B, C, D, E]
dest: [AA, B, C, D, E]

可以看到list雖然被修改了，但是dest數組沒有沒修改。

1.2 List、Set互轉
因為List和Set都實現了Collection接口，且addAll(Collection<? extends E> c);方法，因此可以采用addAll()方法將List和Set互相轉換；另外，List和Set也提供了Collection<? extends E> c作為參數的構造函數，因此通常采用構造函數的形式完成互相轉化。

//List轉Set
Set<String> set = new HashSet<>(list);
System.out.println("set: " + set);
//Set轉List
List<String> list_1 = new ArrayList<>(set);
System.out.println("list_1: " + list_1);

和toArray()一樣，被轉換的List(Set)的修改不會對被轉化后的Set（List）造成影響。

1.3 Array、Set互轉
由1.1 1.2可完成Array和Set的互轉

//array轉set
s = new String[]{"A", "B", "C", "D","E"};
set = new HashSet<>(Arrays.asList(s));
System.out.println("set: " + set);
//set轉array
dest = set.toArray(new String[0]);
System.out.println("dest: " + Arrays.toString(dest));

2.Arrays.asList() 和 Collection.toArray()
上述列出的互相轉換離不開Arrays.asList()和Collection.toArray()兩個重要的方法；

This method acts as bridge between array-based and collection-based APIs, in combination with Collection.toArray. The returned list is serializable and implements RandomAccess.

Arrays.asList()

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

這里出現的ArrayList<>並不是我們通常使用的java.util.ArrayList，因為java.util.ArrayList沒有數組作為參數的構造函數。查看對應的源碼發現，其實Arrays類的靜態內部類。

/**
   * @serial include
   */
  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) {
          a = Objects.requireNonNull(array);
      }

      @Override
      public int size() {
          return a.length;
      }

      @Override
      public Object[] toArray() {
          return a.clone();
      }

      @Override
      @SuppressWarnings("unchecked")
      public <T> T[] toArray(T[] a) {
          int size = size();
          if (a.length < size)
              return Arrays.copyOf(this.a, size,
                                   (Class<? extends T[]>) a.getClass());
          System.arraycopy(this.a, 0, a, 0, size);
          if (a.length > size)
              a[size] = null;
          return a;
      }

      @Override
      public E get(int index) {
          return a[index];
      }

      @Override
      public E set(int index, E element) {
          E oldValue = a[index];
          a[index] = element;
          return oldValue;
      }

      @Override
      public int indexOf(Object o) {
          E[] a = this.a;
          if (o == null) {
              for (int i = 0; i < a.length; i++)
                  if (a[i] == null)
                      return i;
          } else {
              for (int i = 0; i < a.length; i++)
                  if (o.equals(a[i]))
                      return i;
          }
          return -1;
      }

      @Override
      public boolean contains(Object o) {
          return indexOf(o) != -1;
      }

      @Override
      public Spliterator<E> spliterator() {
          return Spliterators.spliterator(a, Spliterator.ORDERED);
      }

      @Override
      public void forEach(Consumer<? super E> action) {
          Objects.requireNonNull(action);
          for (E e : a) {
              action.accept(e);
          }
      }

      @Override
      public void replaceAll(UnaryOperator<E> operator) {
          Objects.requireNonNull(operator);
          E[] a = this.a;
          for (int i = 0; i < a.length; i++) {
              a[i] = operator.apply(a[i]);
          }
      }

      @Override
      public void sort(Comparator<? super E> c) {
          Arrays.sort(a, c);
      }
  }

可以看到，這個由Arrays類實現的另一個Arrays$ArrayList，對於java.util.ArrayList類來講，是比較簡單粗糙的類。

沒有擴容機制；

無法在指定位置add(int index, E element)，調用該方法會拋異常；

這些不同讓這個ArrayList看起來實際上就是一個List-View的數組。

Collection.toArray()

雖然List、Set的具體實現類都對Collection.toArray()方法進行了不同程度的重寫，但是大致都差不多。

這里選AbstractCollection.toArray()的實現：

public <T> T[] toArray(T[] a) {
        // Estimate size of array; be prepared to see more or fewer elements
        int size = size();
        T[] r = a.length >= size ? a :
                  (T[])java.lang.reflect.Array
                  .newInstance(a.getClass().getComponentType(), size);//如果給定的參數T[] a的長度足夠存放當前collection(list or set)的元素，則采用該參數來存放元素；否則則根據參數給定的類型反射生成一個數組；
  //因此這里的參數T[] a有倆作用；第一：可能用作存放元素；第二：為返回數組提供類型
        Iterator<E> it = iterator();
        for (int i = 0; i < r.length; i++) {
            if (! it.hasNext()) { // fewer elements than expected 集合的size少於給定的參數數組的長度
                if (a == r) {
                    r[i] = null; // null-terminate 最后一個元素被設置為null，表明collection元素結束；
                } else if (a.length < i) {
                    return Arrays.copyOf(r, i);
                } else {
                    System.arraycopy(r, 0, a, 0, i);
                    if (a.length > i) {
                        a[i] = null;
                    }
                }
                return a;
            }
            r[i] = (T)it.next();
        }
        // more elements than expected
        return it.hasNext() ? finishToArray(r, it) : r;
    }