Java Array、List、Set 互相转化

Java Array、List、Set 互相转化

Array 转 List

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

注意 list 的元素直接引用 s 的元素，换句话就是说：对 s 的修改，直接影响 list。

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

List 转 Array

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

注意 dest 的元素是 list 的元素的拷贝，换句话就是说：对 list 中关于元素的修改，不会影响dest。

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

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）造成影响。

Array、Set 互转

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

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

Java中 List, Integer[], int[] 的相互转换

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
 
public class Main {
    public static void main(String[] args) {
        int[] data = {4, 5, 3, 6, 2, 5, 1};
 
        // int[] 转 List<Integer>
        List<Integer> list1 = Arrays.stream(data).boxed().collect(Collectors.toList());
        // Arrays.stream(arr) 可以替换成 IntStream.of(arr)。
        // 1.使用 Arrays.stream 将 int[] 转换成 IntStream。
        // 2.使用 IntStream 中的 boxed() 装箱。将 IntStream 转换成 Stream<Integer>。
        // 3.使用 Stream 的 collect()，将 Stream<T> 转换成 List<T>，因此正是 List<Integer>。
 
        // int[] 转 Integer[]
        Integer[] integers1 = Arrays.stream(data).boxed().toArray(Integer[]::new);
        // 前两步同上，此时是 Stream<Integer>。
        // 然后使用 Stream 的 toArray，传入 IntFunction<A[]> generator。
        // 这样就可以返回 Integer 数组。
        // 不然默认是 Object[]。
 
        // List<Integer> 转 Integer[]
        Integer[] integers2 = list1.toArray(new Integer[0]);
        //  调用toArray。传入参数T[] a。这种用法是目前推荐的。
        // List<String>转String[]也同理。
 
        // List<Integer> 转 int[]
        int[] arr1 = list1.stream().mapToInt(Integer::valueOf).toArray();
        // 想要转换成int[]类型，就得先转成IntStream。
        // 这里就通过mapToInt()把Stream<Integer>调用Integer::valueOf来转成IntStream
        // 而IntStream中默认toArray()转成int[]。
 
        // Integer[] 转 int[]
        int[] arr2 = Arrays.stream(integers1).mapToInt(Integer::valueOf).toArray();
        // 思路同上。先将Integer[]转成Stream<Integer>，再转成IntStream。
 
        // Integer[] 转 List<Integer>
        List<Integer> list2 = Arrays.asList(integers1);
        // 最简单的方式。String[]转List<String>也同理。
 
        // 同理
        String[] strings1 = {"a", "b", "c"};
        // String[] 转 List<String>
        List<String> list3 = Arrays.asList(strings1);
        // List<String> 转 String[]
        String[] strings2 = list3.toArray(new String[0]); 
    }
}