集合的进阶

不可变集合

创建不可变的集合
- 在创建了之后集合的长度内容都不可以变化
静态集合的创建在list ，set ，map接口当中都可以获取不可变集合

方法名称	说明
static list of(E …elements)	创建一个具有指定元素集合list集合对象
staticlist of(E…elements)	创建一个具有指定元素的set集合
static Map of(E…elements)	创建一个具有指定元素的Map集合

这个集合是不能删除和修改
List集合

/*不能添加修改操作*/
List<String> list = List.of("lishi", "changff", "zhangshan", "wangshang");
      list.remove("lishi");
      list.add("shuxili");
      list.set(0,"bbbb");
1
2
3
4
5

set集合
注意事项：信息不能重复

package ImmutableDemo;

import java.util.Iterator;
import java.util.Set;

public class Demo2  {
    public static void main(String[] args) {
        Set<String> s=Set.of("lishi", "changff", "zhangshan", "wangshang","dkjkjf");
        Iterator<String> it = s.iterator();
        while (it.hasNext() ) {
            System.out.println(it.next());
        }
        System.out.println("---------------");

        System.out.println("---------------");
//        s.remove("lishi");
//        s.add("shuxili");

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

map集合
注意事项：键值对信息不能重复

package ImmutableDemo;

import java.util.Map;
import java.util.Set;

public class Demo3 {
    public static void main(String[] args) {
        Map<String, String> mapDeom = Map.of("南京", "1000", "北京", "10000", "上海", "8000");
        Set<String> keySet = mapDeom.keySet();
        for (String s : keySet) {
            System.out.println(s);
            System.out.println(mapDeom.get(s));
        }
        System.out.println("---------");
        Set<Map.Entry<String, String>> entries = mapDeom.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "=" + value);
        }
        
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

由于map集合的特殊，还有一种方法为Map.ofEntries( )方法可以传递多个键值对对象

package ImmutableDemo;

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

public class Demo4  {
    public static void main(String[] args) {
        HashMap<String,String> h =new HashMap<>();
        h.put("aaa","111");
        h.put("bbb","222");
        h.put("ccc","333");
        h.put("ddd","444");
        h.put("eee","555");
        /*先获取键值对，对像*/
        Set<Map.Entry<String, String>> entries = h.entrySet();
        Map.Entry[] array = entries.toArray(new Map.Entry[0]);/*先将键值对对象转化为数组，0长度不会影响，在底层会自动比较，
                                                                然后转成集合的长度*/

        /*创建不可变集合*/
        Map map = Map.ofEntries(array);/*可变集合底层是一个数组，可以将数组直接传过去*/
//        map.put("fff","777");
//        map.remove("aaa");
        /*简写*/
        Map<Object, Object> map1 = Map.ofEntries(h.entrySet().toArray(new Map.Entry[0]));
    }
}

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

总结：

特点：

定义完成后不可以进行增删改
如何创建不可变集合

三种方式的细节

Stream流：

思想：工厂流水线，每个负责一项功能,结合lambda表达式来简化对数组的操作

Stream流的使用步骤：
1.得到一条Stream流，并添加数据
2.使用中间方法对流水线进行操作
3.使用终结方法结束对Stream的操作例如 sout

获取方法	方法名	说明
单列集合	default Stream stream()	Collection 中的默认方法
双列集合	无	无法直接使用stream流
数组	Public static StramStream(T[] array)	Arrays工具类中的静态方法调用
一堆零散数据	public staticStream of(T…value)	Stream接口中的静态方法

单列集合

  public static void main(String[] args) {
        /*单列集合直接调用，list是collections的实现类*/
        ArrayList<String> list =new ArrayList<>();
        Collections.addAll(list,"A","B","C","E","F","G");
        list.stream().forEach(s -> System.out.println(s ));
    }
1
2
3
4
5
6

双列集合
注意事项：不能直接使用，必须转化为单列结合最后（keyset，entery）

    public static void main(String[] args) {
        HashMap<String,Integer> ha =new HashMap<>();
        ha.put("aaa",1);
        ha.put("bbb",2);
        ha.put("ccc",3);
        ha.put("ddd",4);
        ha.put("eee",5);
        /*获取键值 */
        ha.keySet().stream().forEach(s -> System.out.println(s));
        System.out.println();
        /*获取键值对 对象，*/
        ha.entrySet().stream().forEach(stringIntegerEntry -> System.out.println(stringIntegerEntry));
    }		
1
2
3
4
5
6
7
8
9
10
11
12
13

数组

注意事项：不能直接使用需要借助工具类arrays中的stream流

 /*数组*/
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        String [] st ={"aaa","bbb","ccc"};
        /*获取stream流*/
        Arrays.stream(arr).forEach(s-> System.out.println(s));
        System.out.println();
        Arrays.stream(st).forEach(s1 -> System.out.println(s1));
    }	
1
2
3
4
5
6
7
8
9

零散数据
注意事项：数据的类型必须一致，在添加引用类型的数组是可以直接使用，但是基本数据类型的数组是不能使用的会吧整个数组当成一个元素直接传递到steam流中
```
public static void main(String[] args) {
        Stream.of(1,2,3,4,5,6,7,8,9).forEach(s-> System.out.println(s));
    }
1
2
3
```

stream流中的中间方法：

Filter 过滤
注意事项：stream流在使用一次后就自动关闭，不能在下面接着使用，建议链式编程
在stream流中修改了数据，原来集合里面的数据不会发生改变

ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list, "aaa", "bbb", "ccc", "ddd", "eee");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                /*true:留下  false：舍弃*/
                return s.startsWith("a");
            }
        }).forEach(s -> System.out.println(s));
        /*简化*/
        list.stream().filter(s -> s.startsWith("a")).forEach(s -> System.out.println(s));
1
2
3
4
5
6
7
8
9
10
11

Limit 获取前几个元素，limit(个数)

  /*limit获取前几元素，不是索引是元素*/
        list.stream().limit(4)
                .forEach(s -> System.out.println(s));

1
2
3
4

skip 跳过前几个元素，skip(个数)

/*skip跳过前几个元素*/
        list.stream().skip(2)
                .forEach(s -> System.out.println(s));
1
2
3

练习：

/*练习获取其中3-4*/
        list.stream().limit(4)
                .skip(2)
                .forEach(s -> System.out.println(s));

        System.out.println();

        list.stream().skip(2)
                .limit(2)
                .forEach(s -> System.out.println(s));
        System.out.println( );
1
2
3
4
5
6
7
8
9
10
11

distinct 去重复，在底层是hashset去重复

 /*去重复*/
        list1.stream().distinct().forEach(s -> System.out.println(s));/*引用数据类型可以直接，自定义的对象需要重写hascode和equales方法*/

1
2
3

Concat 流合并
**注意事项：**类型一致，不会提升类型，不一致会提升到俩流的父类，不能使用单独流的特有功能

 /*流合并，类型一致，不会提升类型，不一致会提升到俩流的父类，不能使用单独流的特有功能*/
        Stream.concat(list1.stream().distinct(),list.stream())
                .forEach(s -> System.out.println(s));
1
2
3

Map 流的转换：

 /*流的转换*/
        list2.stream().map(new Function<String, Integer>() {
            /*string表示流里面原来就有的数据
            * integer表示的是要转换了之后的类型*/
            @Override
            public Integer apply(String s) {
                String[] split = s.split("-");/*切割方法split*/
                String s1 = split[1];
                int i = Integer.parseInt(s1);/*integer中的转换方法*/
                return i;
            }
        }).forEach(s -> System.out.println(s));
        System.out.println("================================");
        /*简化*/
        list2.stream().map(s -> Integer.parseInt(s.split("-")[1])).forEach(s-> System.out.println(s));
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

终结方法：

遍历

/*遍历方式*/
        list2.stream().forEach(s -> System.out.println(s));
1
2

统计

/*将Stream流中的数据进行统计*/
        System.out.println(list2.stream().distinct().count());
1
2

收集流中的数据放到数组中

    String[] array = list2.stream().toArray(new IntFunction<String[]>() {
            @Override
            public String[] apply(int value) {
                return new String[value];
            }
        });
        System.out.println(Arrays.toString(array));

        /*简化*/
        String[] array1 = list2.stream().toArray(value -> new String[value]);
        System.out.println(Arrays.toString(array));
1
2
3
4
5
6
7
8
9
10
11

收集流中的数据放到集合里面

注意事项：

lis集合是不会去重复的

set集合是会去重复的

map里面的键值对不能重复

/*list*/
        List<String> collect = list2.stream()
                .filter(s -> "男".equals(s.split("-")[2]))
                .collect(Collectors.toList());
        System.out.println(collect);
        /*set*/
        Set<String> collect1 = list2.stream()
                .filter(s -> "男".equals(s.split("-")[2]))
                .collect(Collectors.toSet());
        System.out.println(collect1);

        /*迭代器遍历*/
        Iterator<String> iterator = collect.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }
        /*增强for*/
        for (String s : collect) {
            System.out.println(s);
        }
        /*foreach*/
        collect.forEach((s)-> {  System.out.println(s); });

        /*收集到map集合当中注意键值对不能重复*/
        Map<String, Integer> mapcollect = list2.stream()
                .filter(s -> "男".equals(s.split("-")[2]))
                /*在map集合里面要传递2个数据，键的获取规则，值的获取规则*/
                /*在键或者值里面有2个类型第一个表示流里面的类型，第二个表示键或者值里面的类型，他们是交叉对应的*/
                .collect(Collectors.toMap(new Function<String, String>() {
                    @Override
                    public String apply(String s) {
                        return s.split("-")[0];
                    }
                }, new Function<String, Integer>() {
                    @Override
                    public Integer apply(String s) {
                        return Integer.parseInt(s.split("-")[1]);
                    }
                }));
 				/*简化*/
        Map<String, Integer> mapcollect2 = list2.stream()
                .filter(s -> "男".equals(s.split("-")[2]))
                .collect(Collectors.toMap(
                        s -> s.split("-")[0]
                        ,
                        s -> Integer.parseInt(s.split("-")[1])
                ));
        System.out.println(mapcollect2);

        System.out.println(mapcollect);
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

总结：

相关阅读:
树形Dp 2925. 在树上执行操作以后得到的最大分数
 机器人虚拟仿真工作站考试
 web前端期末大作业：个人网站设计——响应式个人小站网站HTML+CSS+JavaScript
【CSS3】CSS3 动画 ③ ( 动画属性 | CSS3 常见动画属性简介 | 动画属性简写方式 | 动画属性简写语法 | 代码示例 )
网络原理之IP协议
 App Startup原理解析
 技术分享 | 测试平台开发-前端开发之数据展示与分析
 FFmpeg学习笔记汇总
 Linux 简要命令记录
 24.聚类算法的介绍
原文地址：https://blog.csdn.net/weixin_49513202/article/details/133846010