集合的进阶

不可变集合

  • 创建不可变的集合

    • 在创建了之后集合的长度内容都不可以变化

  • 静态集合的创建在list ,set ,map接口当中都可以获取不可变集合

方法名称 说明
static list of(E ...elements) 创建一个具有指定元素集合list集合对象
staticlist of(E...elements) 创建一个具有指定元素的set集合
static<k,v> Map<k,v> of(E...elements) 创建一个具有指定元素的Map集合
  • 这个集合是不能删除和修改

  • List集合

java 复制代码
/*不能添加修改操作*/
List<String> list = List.of("lishi", "changff", "zhangshan", "wangshang");
      list.remove("lishi");
      list.add("shuxili");
      list.set(0,"bbbb");
  • set集合
  • 注意事项:信息不能重复
java 复制代码
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");

    }
}
  • map集合
  • 注意事项:键值对信息不能重复
java 复制代码
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);
        }
        
    }
}
  • Map

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

java 复制代码
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]));
    }
}

总结:

  • 特点:

    定义完成后不可以进行增删改

  • 如何创建不可变集合

  • 三种方式的细节

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接口中的静态方法
    • 单列集合

      java 复制代码
        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 ));
          }
      • 双列集合
        注意事项:不能直接使用,必须转化为单列结合最后(keyset,entery)
    java 复制代码
        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));
        }		
    • 数组

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

      java 复制代码
       /*数组*/
          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));
          }	
    • 零散数据
      注意事项:数据的类型必须一致,在添加引用类型的数组是可以直接使用,但是基本数据类型的数组是不能使用的会吧整个数组当成一个元素直接传递到steam流中

      java 复制代码
      public static void main(String[] args) {
              Stream.of(1,2,3,4,5,6,7,8,9).forEach(s-> System.out.println(s));
          }

stream流中的中间方法:

  • Filter 过滤
    注意事项 :stream流在使用一次后就自动关闭,不能在下面接着使用,建议链式编程
    在stream流中修改了数据,原来集合里面的数据不会发生改变
java 复制代码
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));
  • Limit 获取前几个元素,limit(个数)

    java 复制代码
      /*limit获取前几元素,不是索引是元素*/
            list.stream().limit(4)
                    .forEach(s -> System.out.println(s));
  • skip 跳过前几个元素,skip(个数)

    java 复制代码
    /*skip跳过前几个元素*/
            list.stream().skip(2)
                    .forEach(s -> System.out.println(s));

    练习:

    java 复制代码
    /*练习获取其中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( );
    • distinct 去重复,在底层是hashset去重复

      java 复制代码
       /*去重复*/
              list1.stream().distinct().forEach(s -> System.out.println(s));/*引用数据类型可以直接,自定义的对象需要重写hascode和equales方法*/
    • Concat 流合并

      **注意事项:**类型一致,不会提升类型,不一致会提升到俩流的父类,不能使用单独流的特有功能

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

Map 流的转换:

java 复制代码
 /*流的转换*/
        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));

终结方法:

  • 遍历
java 复制代码
/*遍历方式*/
        list2.stream().forEach(s -> System.out.println(s));
  • 统计

    java 复制代码
    /*将Stream流中的数据进行统计*/
            System.out.println(list2.stream().distinct().count());
  • 收集流中的数据放到数组中

java 复制代码
    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));
  • 收集流中的数据放到集合里面

    注意事项:

    lis集合是不会去重复的

    set集合是会去重复的

    map里面的键值对不能重复

    java 复制代码
    /*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);

总结:

相关推荐
小蜗牛慢慢爬行2 分钟前
有关异步场景的 10 大 Spring Boot 面试问题
java·开发语言·网络·spring boot·后端·spring·面试
新手小袁_J26 分钟前
JDK11下载安装和配置超详细过程
java·spring cloud·jdk·maven·mybatis·jdk11
呆呆小雅27 分钟前
C#关键字volatile
java·redis·c#
Monly2127 分钟前
Java(若依):修改Tomcat的版本
java·开发语言·tomcat
Ttang2329 分钟前
Tomcat原理(6)——tomcat完整实现
java·tomcat
钱多多_qdd40 分钟前
spring cache源码解析(四)——从@EnableCaching开始来阅读源码
java·spring boot·spring
waicsdn_haha42 分钟前
Java/JDK下载、安装及环境配置超详细教程【Windows10、macOS和Linux图文详解】
java·运维·服务器·开发语言·windows·后端·jdk
Q_19284999061 小时前
基于Spring Boot的摄影器材租赁回收系统
java·spring boot·后端
Code_流苏1 小时前
VSCode搭建Java开发环境 2024保姆级安装教程(Java环境搭建+VSCode安装+运行测试+背景图设置)
java·ide·vscode·搭建·java开发环境
禁默2 小时前
深入浅出:AWT的基本组件及其应用
java·开发语言·界面编程