精华内容
下载资源
问答
  • StramApi常用操作

    2019-11-22 14:39:38
    StramApi常用操作,stream之数组与list之间互相转化,stream之list分组, list对象转换为某个属性的list字符串,.list对象转化为某两个属性拼接的list字符串,list对象按照某个属性值进行分组,list对象按照某两个...

    StramApi常用操作

    什么是流 ?

    Stream 不是集合元素,它不是数据结构并不保存数据,它是有关算法和计算的,它更像一个高级版本的 Iterator。原始版本的 Iterator,用户只能显式地一个一个遍历元素并对其执行某些操作;高级版本的 Stream,用户只要给出需要对其包含的元素执行什么操作,比如 “过滤掉长度大于 10 的字符串”、“获取每个字符串的首字母”等,Stream 会隐式地在内部进行遍历,做出相应的数据转换。

    Stream 就如同一个迭代器(Iterator),单向,不可往复,数据只能遍历一次,遍历过一次后即用尽了,就好比流水从面前流过,一去不复返.

    流的结构

    当我们使用一个流的时候,通常包括三个基本步骤:
    获取一个数据源(source)→ 数据转换→执行操作获取想要的结果,每次转换原有 Stream 对象不改变,返回一个新的 Stream 对象(可以有多次转换),这就允许对其操作可以像链条一样排列,变成一个管道,如下图所示。

    流管道 (Stream Pipeline) 的构成

    在这里插入图片描述

    生成 Stream Source的方式

    从 Collection 和数组

    Collection.stream()
    Collection.parallelStream()
    Arrays.stream(T array) or Stream.of()
    

    从 BufferedReader

    java.io.BufferedReader.lines()
    

    静态工厂

    java.util.stream.IntStream.range()
    java.nio.file.Files.walk()
    

    自己构建

    java.util.Spliterator
    

    其它

    Random.ints()
    BitSet.stream()
    Pattern.splitAsStream(java.lang.CharSequence)
    JarFile.stream()
    
    流的操作类型分为两种:

    Intermediate(中间):一个流可以后面跟随零个或多个 intermediate 操作。其目的主要是打开流,做出某种程度的数据映射/过滤,然后返回一个新的流,交给下一个操作使用。这类操作都是惰性化的(lazy),就是说,仅仅调用到这类方法,并没有真正开始流的遍历。

    Terminal(最终):一个流只能有一个 terminal 操作,当这个操作执行后,流就被使用“光”了,无法再被操作。所以这必定是流的最后一个操作。Terminal 操作的执行,才会真正开始流的遍历,并且会生成一个结果,或者一个 side effect。
    在对于一个 Stream 进行多次转换操作 (Intermediate 操作),每次都对 Stream 的每个元素进行转换,而且是执行多次,这样时间复杂度就是 N(转换次数)个 for 循环里把所有操作都做掉的总和吗?其实不是这样的,转换操作都是 lazy 的,多个转换操作只会在 Terminal 操作的时候融合起来,一次循环完成。我们可以这样简单的理解,Stream 里有个操作函数的集合,每次转换操作就是把转换函数放入这个集合中,在 Terminal 操作的时候循环 Stream 对应的集合,然后对每个元素执行所有的函数。

    一个流操作的示例

    int sum = widgets.stream()
    .filter(w -> w.getColor() == RED)
     .mapToInt(w -> w.getWeight())
     .sum();
    

    stream() 获取当前小物件的 source,filter 和 mapToInt 为 intermediate 操作,进行数据筛选和转换,最后一个 sum() 为 terminal 操作,对符合条件的全部小物件作重量求和。

    构造流的几种常见方法

    // 1. Individual values
    Stream stream = Stream.of("a", "b", "c");
    // 2. Arrays
    String [] strArray = new String[] {"a", "b", "c"};
    stream = Stream.of(strArray);
    stream = Arrays.stream(strArray);
    // 3. Collections
    List<String> list = Arrays.asList(strArray);
    stream = list.stream();
    

    1.流转换为其它数据结构

    1.1 转为数组 Array
    String[] arr=Stream.toArray(String[]::new)
    

    代码:

    private static  List<Person> getList() {
        List<Person> list = new ArrayList<>();
        list.add(new Person("范冰冰","女",28));
        list.add(new Person("刘亦菲","女",24));
        list.add(new Person("胡歌","男",30));
        return list;
    }
    
    public static void main(String[] args) {
        List<Person> list = getList();
        //list 转 数组
        Person[] arr= list.stream().toArray(Person[]::new);
        Arrays.stream(arr).forEach(System.out::println);
    }
    

    效果:
    在这里插入图片描述

    1.2 转为集合 list,set Collection
    List<String> list = stream.collect(Collectors.toList());
    List<String> list = stream.collect(Collectors.toCollection(ArrayList::new));
    Set set = stream.collect(Collectors.toSet());
    Stack stack = stream.collect(Co`llectors.toColl`ection(Stack::new));
    

    代码:

      public static void main(String[] args) {
        List<Person> list = getList();
        //list 转 数组
        Person[] arr= list.stream().toArray(Person[]::new);
        //数组 转 list
        List<Person> collect = Arrays.stream(arr).collect(Collectors.toList());
    }
    
    1.3 转为字符串
    String str = stream.collect(Collectors.joining()).toString();
    //Collectors.joining 收集器 支持灵活的参数配置,可以指定字符串连接时的 分隔符,前缀 和 后缀 字符串
    

    代码:

    final static String[] names = {"A", "B", "C", "D", "E"};
    public static void main(String[] args) {
        String collect = Stream.of(names).collect(Collectors.joining("-", "{", "}"));
        System.out.println("字符串格式="+collect);
    }
    

    效果图:

    在这里插入图片描述

    2.流的操作

    流的操作
    接下来,当把一个数据结构包装成 Stream 后,就要开始对里面的元素进行各类操作了。常见的操作可以归类如下。
    Intermediate:
    map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
    Terminal:
    forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

    常用操作:

    map: 把 input Stream 的每一个元素,映射成 output Stream 的另外一个元素。

    在项目中的应用:

    1.list对象转换为某个属性的list字符串 (用来取list对象中的所有的对象的某个属性的list)

    private static  List<Person> getList() {
            List<Person> list = new ArrayList<>();
            list.add(new Person("范冰冰","女",28));
            list.add(new Person("刘亦菲","女",24));
            list.add(new Person("胡歌","男",30));
            return list;
        }
    
        public static void main(String[] args) {
            //获取所有的学生名字
            List<Person> list = getList();
            List<String> resList = list.stream().map(Person::getName).collect(Collectors.toList());
            resList.stream().forEach(System.out::println);
        }
    

    在这里插入图片描述
    2.list对象转化为某两个属性拼接的list字符串

    public static void main(String[] args) {
            //获取所有人  "名字+年龄" 格式 的list
            List<Person> list = getList();
            List<String> resList = list.stream().map(e -> e.getName()+"+"+e.getAge()).collect(Collectors.toList());
            resList.stream().forEach(System.out::println);
        }
    

    在这里插入图片描述
    3.list对象按照某个属性值进行分组

     private static  List<Person> getList() {
            List<Person> list = new ArrayList<>();
            list.add(new Person("范冰冰","女",28));
            list.add(new Person("刘亦菲","女",24));
            list.add(new Person("胡歌","男",30));
            list.add(new Person("胡歌","女",24));
            return list;
        }
    
        public static void main(String[] args) {
            //根据名字进行分组
            List<Person> list = getList();
            Map<Integer, List<Person>> collect = list.stream().collect(Collectors.groupingBy(Person::getAge));
            Set<Map.Entry<Integer, List<Person>>> entries = collect.entrySet();
            for(Map.Entry<Integer, List<Person>> entity:entries){
                System.out.println("key="+entity.getKey()+"value="+entity.getValue().size());
            }
    
        }
    

    在这里插入图片描述
    4.list对象按照某两个属性拼接进行分组

    
        private static  List<Person> getList() {
            List<Person> list = new ArrayList<>();
            list.add(new Person("范冰冰","女",28));
            list.add(new Person("刘亦菲","女",24));
            list.add(new Person("胡歌","男",24));
            list.add(new Person("胡歌","女",24));
            return list;
        }
    
        public static void main(String[] args) {
            //根据 "性别-年龄" 格式进行分组
            List<Person> list = getList();
            Map<String, List<Person>> collect = list.stream().collect(Collectors.groupingBy(e -> e.getGender() + "-" + String.valueOf(e.getAge())));
            Set<Map.Entry<String, List<Person>>> entries = collect.entrySet();
            for(Map.Entry<String, List<Person>> entity:entries){
                System.out.println("key="+entity.getKey()+"  value="+entity.getValue().size());
            }
    
        }
    

    在这里插入图片描述

    展开全文
  • 利用Stram来递归生成树形结构 当需要查询有子菜单,或者子部门这一类需要形成树形的数据时,我们可以使用stream流式编程写 实体类 实体类需要有一个子列,类似此处的子城市 @Data @EqualsAndHashCode(callSuper = ...

    利用Stram来递归生成树形结构

    当需要查询有子菜单,或者子部门这一类需要形成树形的数据时,我们可以使用stream流式编程写

    实体类

    实体类需要有一个子列,类似此处的子城市

    @Data
    @EqualsAndHashCode(callSuper = false)
    @ApiModel(value="TRegion对象", description="地区信息表")
    public class RegionVO {
    
        @TableId(value = "id", type = IdType.AUTO)
        private Integer id;
    
        @ApiModelProperty(value = "代码")
        private String code;
    
        @ApiModelProperty(value = "名称")
        private String name;
    
        @ApiModelProperty(value = "层级,1=省,2=市,3=区")
        private Integer lvl;
    
        @ApiModelProperty(value = "上级代码")
        private String parentCode;
    
        @ApiModelProperty("子城市")
        private List<RegionVO> children;
    
    }
    
    

    实现类

    @Override
        public RestResult getTree() {
    
            List<RegionVO> regionVoList = mapper.getTree();
    
    		// 这里就是过滤出查询出来的所有数据中lvl是1的作为最上层父级
            List<RegionVO> parents = (List)regionVoList.stream().filter((treex) -> {
                return 1 == (treex.getLvl());
            }).collect(Collectors.toList());
            return new RestResult(this.getTreeList(regionVoList, parents));
        }
    
    	//此处的功能就是将整个查询的数据和过滤出来的父级list传入
        private List<RegionVO> getTreeList(List<RegionVO> fullList, List<RegionVO> parentList) {
        	// 这里会去比对父级和子级的id,相同就会加入,然后生成整个树返回
            return (List)parentList.stream().map((region) -> {
                List<RegionVO> children = (List)fullList.stream().filter((childMenu) -> {
                    return region.getCode().equals(childMenu.getParentCode());
                }).collect(Collectors.toList());
                region.setChildren(this.getTreeList(fullList, children));
                return region;
            }).collect(Collectors.toList());
        }
    
    展开全文
  • 知道stram有fiter过滤的,但是现在是两个集合,所有百度了好多,今天看到了两个集合取交集差集 香香 List<Course> courses = courseService.query().eq("user_id", teacherId).eq("is_up",0).list(); List&...

    最近用的stream比较多,但是也就最简单的foreach和map的使用。今天遇到一个问题是两个集合取差集吧。知道stram有fiter过滤的,但是现在是两个集合,所有百度了好多,今天看到了两个集合取交集差集 香香

      List<Course> courses = courseService.query().eq("user_id", teacherId).eq("is_up",0).list();
            List<Integer> list = baseMapper.findcourseing(classId);
            List<Course> collect = courses.stream().filter(course -> !list.contains(course.getId())).collect(Collectors.toList());
    

    以上是差集,很简单要是交集就把那个!去掉就可以了
    好了 草鸡干活去了

    展开全文
  • Java8出了很久了,好用也确实好用,但是开发人员时间跨度会导致有些人不习惯用,同一个功能需求,两种写法,更倾向于用以前的写法,所以整理了下自己学习Stram的路程。

    使用场景

    循环遍历开始

             循环遍历是基础操作,这里举例一个简单的foreach遍历。

    @Test
        public void test1(){
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            for (String str:list
                 ) {
                System.out.println(str);
            }
        }

    优化

    @Test
        public void test2(){
            List<String> list = new ArrayList<>();
            list.add("a");
            list.add("b");
            list.add("c");
            list.add("d");
            list.forEach(str -> System.out.println(str));
        }
    • 第一步
      list.forEach:这个方法来源于Iterable接口(Jdk8新增),无返回值,如果参数为null 会抛出异常。foreach里面的
      action.accept(t)对应的是 Consumer 功能性接口,没有具体实现,无返回值,具体实现通过Lmbda表达式实现了。
      使用Lambda表达式可以避免使用庞大的匿名类实现。
      
    • 本来还写了好多优化,但是后来才发现往下就是 "::"的优化了

     

     

    展开全文
  • JDK8特性函数式接口与Stram流 函数式接口 函数式接口,一般java中一个接口中只有一个方法就可以被认为是函数式接口,用于契合jdk8中的lamda的 在jdk用也有很多函数式接口,比如典型的Runable和Comparable等接口都是...
  • Java8Stram

    2020-08-14 15:58:23
    package stream; import org.junit.Test; import java.util.*; import java.util.concurrent.ConcurrentHashMap; import java.util.function.Function;...import java.util.function.Predicate;...import java.util....
  • IDEA-Stram调试

    千次阅读 2021-05-16 23:21:01
    title: IDEA-Stream调试 tags: [IDEA,Stream,Debug] categories: Tool comment: true description: IDEA-Stream调试 前言 JAVA8的lambda的stream编程,给我们带来了很流畅(牛逼)的编程体验,但带来的问题也很明显:...
  • Stram流 常用方法

    2021-09-17 16:08:00
    !流常用方法 流,只会改变流内数据,不会改变原来的数据,最后需要新容器承接 .filter(name->{return name.indexOf(“libai”)>=0;}) .filter((String name)->{return 11}??... 参数数据类型可写可节省 ...
  • 在Xcode8上一直输出出现AQDefaultDevice(173):Skipping input stram 0 0 0x0 解决方法: 1 选择product-->Scheme-->Edit Scheme 2选择Arguments 3 在Environment Variables 添加一个环境变量 OS_ACTIVITY
  • **springCloud微服务需要使用消息队列,从应用扩展性及效率来讲,是使用spring cloud stram + rabbitmq 方式好点 还是单纯使用rabbitmq好点,另外后期想用mq控制事务,请有相关经验的大佬给一些建议**
  • java8 stram并行流学习

    2020-06-03 20:14:38
    并行流需要注意的地方: 并行流分解任务基于fork/join 框架 fork/join框架是jdk1.7引入的,java8的stream多线程并非流的正是以这个框架为基础的,所以想要深入理解并发流就要学习fork/join框架。...
  • Java8 Stram 的使用

    2018-04-09 08:36:34
    1、Java Stream 详解 http://colobu.com/2016/03/02/Java-Stream/ 2、Java 8 Stream 教程 https://www.jianshu.com/p/0c07597d8311 3、Java 8 中的 Streams API 详解 ...
  • Arraylist.stram()玩法 流

    2021-06-04 11:14:38
    package kgc_byme.day19.test.tt2; import java.util.*; import java.util.stream.Collectors; /** * @Description: * @author:myh * @date: 2021/6/4 10:54 ... public static void main(String[] args) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,880
精华内容 752
关键字:

stram