Java Array、List、Set互相转化

太过爱你忘了你带给我的痛 2023-10-11 16:10 7阅读 0赞

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;  
\}