Java Array、List、Set互相转化
Java Array、List、Set互相转化
1. Array、List、Set互转实例
1.1 Array、List互转
Array转List
1
2
|
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。
1
2
|
s[ 0 ] = "AA" ;
System.out.println( "list: " + list);
|
输出结果
1
|
list: [AA, B, C, D, E] |
List转Array
1
2
|
String[] dest = list.toArray( new String[ 0 ]); //new String[0]是指定返回数组的类型
System.out.println( "dest: " + Arrays.toString(dest));
|
输出结果
1
|
dest: [AA, B, C, D, E] |
注意这里的dest里面的元素不是list里面的元素,换句话就是说:对list中关于元素的修改,不会影响dest。
1
2
3
|
list.set( 0 , "Z" );
System.out.println( "modified list: " + list);
System.out.println( "dest: " + Arrays.toString(dest));
|
输出结果
1
2
|
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作为参数的构造函数,因此通常采用构造函数的形式完成互相转化。
1
2
3
4
5
6
|
//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的互转
1
2
3
4
5
6
7
|
//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.
1
2
3
4
5
6
7
|
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类的静态内部类。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/** * @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()的实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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 Array、List、Set互相转化
1. Array、List、Set互转实例
1.1 Array、List互转
Array转List
1
2
|
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。
1
2
|
s[ 0 ] = "AA" ;
System.out.println( "list: " + list);
|
输出结果
1
|
list: [AA, B, C, D, E] |
List转Array
1
2
|
String[] dest = list.toArray( new String[ 0 ]); //new String[0]是指定返回数组的类型
System.out.println( "dest: " + Arrays.toString(dest));
|
输出结果
1
|
dest: [AA, B, C, D, E] |
注意这里的dest里面的元素不是list里面的元素,换句话就是说:对list中关于元素的修改,不会影响dest。
1
2
3
|
list.set( 0 , "Z" );
System.out.println( "modified list: " + list);
System.out.println( "dest: " + Arrays.toString(dest));
|
输出结果
1
2
|
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作为参数的构造函数,因此通常采用构造函数的形式完成互相转化。
1
2
3
4
5
6
|
//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的互转
1
2
3
4
5
6
7
|
//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.
1
2
3
4
5
6
7
|
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类的静态内部
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
/** * @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()的实现:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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;
}
|