数组，集合流式互转

在Java中，数组和集合（List、Map、Set）之间可以通过流（Stream）进行相互转换。下面列举一些常见的转换操作示例。

基本流程:（过滤器可无，必需的是转stream和收集器）
集合对象.stream().filter(lambda return boolean).collect(  Collectors.to你要的集合() );

如果转map的话要传lambda，指定什么当key什么当value

数组的话要用工具类转stream

Arrays.stream(  你的数组 ).filter(lambda return boolean).boxed().collect(  Collectors.to你要的集合() );

1. 数组转List

import java.util.Arrays;
import java.util.List;

public class ArrayToList {
    public static void main(String[] args) {
        String[] array = {"apple", "banana", "cherry"};

        // 数组转 List
        List<String> list = Arrays.stream(array)
                                  .toList(); // Java 16+ 提供的简洁方法
        // 或者使用
        // List<String> list = Arrays.asList(array);

        System.out.println(list);
    }
}

2. 数组转Set

import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;

public class ArrayToSet {
    public static void main(String[] args) {
        String[] array = {"apple", "banana", "cherry"};

        // 数组转 Set
        Set<String> set = Arrays.stream(array)
                                .collect(Collectors.toSet());

        System.out.println(set);
    }
}

3. 数组转Map

假设数组中的元素是String类型，可以将其转换为键值对，例如使用字符串的长度作为值：

import java.util.Arrays;
import java.util.Map;
import java.util.stream.Collectors;

public class ArrayToMap {
    public static void main(String[] args) {
        String[] array = {"apple", "banana", "cherry"};

        // 数组转 Map，键为字符串，值为字符串长度
        Map<String, Integer> map = Arrays.stream(array)
                                         .collect(Collectors.toMap(
                                             str -> str, 
                                             str -> str.length()
                                         ));

        System.out.println(map);
    }
}

4. List转数组

import java.util.Arrays;
import java.util.List;

public class ListToArray {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry");

        // List 转数组
        String[] array = list.stream()
                             .toArray(String[]::new);

        System.out.println(Arrays.toString(array));
    }
}

5. Set转数组

import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;

public class SetToArray {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>(Arrays.asList("apple", "banana", "cherry"));

        // Set 转数组
        String[] array = set.stream()
                            .toArray(String[]::new);

        System.out.println(Arrays.toString(array));
    }
}

6. List转Set

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class ListToSet {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("apple", "banana", "cherry", "apple");

        // List 转 Set
        Set<String> set = list.stream()
                              .collect(Collectors.toSet());

        System.out.println(set);
    }
}

7. Set转List

import java.util.Set;
import java.util.HashSet;
import java.util.List;
import java.util.stream.Collectors;
import java.util.Arrays;

public class SetToList {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>(Arrays.asList("apple", "banana", "cherry"));

        // Set 转 List
        List<String> list = set.stream()
                               .collect(Collectors.toList());

        System.out.println(list);
    }
}

8. Map转List（键或值）

将Map中的键或值转换为List：

import java.util.Map;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;

public class MapToList {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "apple");
        map.put(2, "banana");
        map.put(3, "cherry");

        // Map 键转 List
        List<Integer> keysList = map.keySet().stream()
                                    .collect(Collectors.toList());

        // Map 值转 List
        List<String> valuesList = map.values().stream()
                                     .collect(Collectors.toList());

        System.out.println("Keys: " + keysList);
        System.out.println("Values: " + valuesList);
    }
}

9. Map转Set（键或值）

将Map中的键或值转换为Set：

import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.stream.Collectors;

public class MapToSet {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "apple");
        map.put(2, "banana");
        map.put(3, "cherry");

        // Map 键转 Set
        Set<Integer> keysSet = map.keySet().stream()
                                  .collect(Collectors.toSet());

        // Map 值转 Set
        Set<String> valuesSet = map.values().stream()
                                   .collect(Collectors.toSet());

        System.out.println("Keys: " + keysSet);
        System.out.println("Values: " + valuesSet);
    }
}

10. Map转数组（键或值）

将Map中的键或值转换为数组：

import java.util.Map;
import java.util.HashMap;
import java.util.Arrays;

public class MapToArray {
    public static void main(String[] args) {
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "apple");
        map.put(2, "banana");
        map.put(3, "cherry");

        // Map 键转数组
        Integer[] keysArray = map.keySet().stream()
                                 .toArray(Integer[]::new);

        // Map 值转数组
        String[] valuesArray = map.values().stream()
                                  .toArray(String[]::new);

        System.out.println("Keys: " + Arrays.toString(keysArray));
        System.out.println("Values: " + Arrays.toString(valuesArray));
    }
}