数组类型转换

测试数据

 //【字符串】切成【数组】
String[] arr = "1,2,3,4,5,6".split(",");  

1.1. 字符串数组 to （Integer、Long、Double）列表

1.1.1. 传统方式

1.1.1.1.【String数组】转成【Long数组】

 //【String数组】转成【Long数组】
Long[] LongIds= (Long[]) ConvertUtils.convert(arr, Long.class);  

1.1.1.2.【Long数组】 转 【ArrayList】

 // Arrays.asList 返回固定大小的列表。
List<Long> list = Arrays.asList(LongIds);
// new ArrayList 创建动态的 ArrayList 
ArrayList<Long> ids = new ArrayList<Long>(list );  

1.1.2. Java8 Stream方式

 List<Integer> intList = Arrays.stream(arr).map(Integer::valueOf).collect(toList());
System.out.println(intList);
List<Long> longList = Arrays.stream(arr).map(Long::valueOf).collect(toList());
System.out.println(longList);
List<Double> doubleList = Arrays.stream(arr).map(Double::valueOf).collect(toList());
System.out.println(doubleList);  

1.2. 数组 to 数组

1.2.1. 字符串数组 to （int、long、double ）数组

 int[] ints = Arrays.stream(arr).mapToInt(Integer::valueOf).toArray();
long[] longs = Arrays.stream(arr).mapToLong(Long::valueOf).toArray();
double[] doubles = Arrays.stream(arr).mapToDouble(Double::valueOf).toArray();  

1.2.2. int[]、long[]、double[] 数组互相转换

 // int[] 2 long[]
long[] longs = Arrays.stream(ints).mapToLong(Long::valueOf).toArray();
// int[] 2 double[]
double[] doubles = Arrays.stream(ints).mapToDouble(Double::valueOf).toArray();
// long[] 2 int[]
int[] ints1 = Arrays.stream(longs).mapToInt(i -> (int)i).toArray();
// long[] 2 double[]
double[] doubles1 = Arrays.stream(longs).mapToDouble(Double::valueOf).toArray();
// double[] 2 int[]
int[] ints2 = Arrays.stream(doubles).mapToInt(i -> (int)i).toArray();
// double[] 2 long[]
long[] longs2 = Arrays.stream(doubles).mapToLong(i -> (long)i).toArray();  

1.2.3. int[]、long[]、double[] 数组再转回 String[]

 String[] strArr1 = Arrays.stream(ints).mapToObj(String::valueOf).toArray(String[]::new);
String[] strArr2 = Arrays.stream(longs).mapToObj(String::valueOf).toArray(String[]::new);
String[] strArr3 = Arrays.stream(doubles).mapToObj(String::valueOf).toArray(String[]::new);  

基础类型数组 to 列表

2.1. int数组 to 列表

 int[] intArr = {1, 2, 3, 4, 5, 6};
List<Integer> intList = Arrays.stream(intArr).boxed().collect(Collectors.toList());
System.out.println(intList);  

2.2. long数组 to 列表

 long[] longArr = {1L, 2L, 3L, 4L, 5L, 6L};
List<Long> longList = Arrays.stream(longArr).boxed().collect(Collectors.toList());
System.out.println(longList);  

2.3. double数组 to 列表

 double[] doubleArr = {1d, 2d, 3d, 4d, 5d, 6d};
List<Double> doubleList = Arrays.stream(doubleArr).boxed().collect(Collectors.toList());
System.out.println(doubleList);  

2.4 String数组 to 列表

 String[] arr = "1,2,3,4,5,6".split(",");

// list 不可编辑
List<String> list = Arrays.asList(arr);
System.out.println(list);

// arrayList 不可编辑
ArrayList<String> arrayList = new ArrayList<String>(list);
System.out.println(arrayList);  

数组转 String

3.1. 字符数组

方便输出查看。

 //======================= Array ==============================
String[] arr = {"你好", "哈喽", "啦啦啦"};
String str1 = Arrays.toString(arr);
System.out.println(str1);
String str3 = String.join(",", arr);
System.out.println(str3);
//======================= List<T> ==============================
List<String> list = Arrays.asList(arr);
String string1 = list.stream().collect(Collectors.joining(","));
System.out.println(string1);
String string2 = String.join(",", list);
System.out.println(string2);  

3.2 其它数组

3.2.1 自定义收集器写法。

 IntStream nums = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
String str = nums.collect(
StringBuilder::new, 
StringBuilder::append,
StringBuilder::append
).toString();
System.out.println(str);  

用reduce也能实现，只是用收集器语义上更合理吧。

 IntStream nums = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
String str = nums.boxed().map(String::valueOf).reduce("", String::concat);
System.out.println(str);  

3.2.2. 需要指定分隔符可以使用：Collectors.joining

 IntStream nums = IntStream.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
String str = nums.boxed().map(String::valueOf).collect(Collectors.joining(","));
System.out.println(str);  

集合运算

 <dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-collections4</artifactId>
<version>4.4</version>
</dependency>  

 List<String> listA = new ArrayList<>();
listA.add("你好");
listA.add("哈喽");
listA.add("啦啦啦");
List<String> listB = new ArrayList<>();
listB.add("你好");
listB.add("我好");
listB.add("大家好");
// listA 交 listB。当listA发生该变返回true
// listA.retainAll(listB);
// 返回交集
Collection<String> intersect1 = CollectionUtils.retainAll(listA, listB);
System.out.println(intersect1);
Collection<String> intersect2 = CollectionUtils.retainAll(listA, listB);
System.out.println(intersect2);
// 返回并集
Collection<String> union1 = CollectionUtils.union(listA, listB);
System.out.println(union1);
Collection<String> union2 = CollectionUtils.union(listB, listA);
System.out.println(union2);
// 返回差集
Collection<String> except1 = CollectionUtils.subtract(listA, listB);
System.out.println(except1);
Collection<String> except2 = CollectionUtils.subtract(listB, listA);
System.out.println(except2);  

 [你好]
[你好]
[我好, 你好, 大家好, 啦啦啦, 哈喽]
[我好, 你好, 大家好, 啦啦啦, 哈喽]
[哈喽, 啦啦啦]
[我好, 大家好]