【java】Stream的使用

简介: 首先,给大家推荐一个好的地方:http://ifeve.com/stream/ 可以好好学一下接下来,今天要删除数组中的某些元素,想到了之前用过的这个JDK8的Stream 1.Array转化为Stream并进行筛选【有个坑】:数组转化为Stream有两种方式  1.Stream.of(数组)  2.Arrays.stream(数组)  区别:两种都支持引用数据类型,但是如果是基本数据类型的话,请选择第二种,所以妥善期间使用第二种比较合适。

首先,给大家推荐一个好的地方:http://ifeve.com/stream/ 可以好好学一下

接下来,今天要删除数组中的某些元素,想到了之前用过的这个JDK8的Stream

 

1.Array转化为Stream并进行筛选

【有个坑】:数组转化为Stream有两种方式

  1.Stream.of(数组)

  2.Arrays.stream(数组)

  区别:两种都支持引用数据类型,但是如果是基本数据类型的话,请选择第二种,所以妥善期间使用第二种比较合适。

 

【注意】:

使用stream进行任何操作,并不会因此而改变原数据的任何地方。因此想要获取到处理后的数据,需要你接收下来。

 

【代码展示】:

①filter中一行代码如下:

@org.junit.Test
    public void test() throws IOException{
        String [] str = "2.1.1&2.1.2&2.1.5&2.1.6&3.1.1&3.2.2&3.3.3&4.1.1&4.1.2&4.1.4&5.1.2&7.1.2&7.2.1&7.3.1.1&7.3.3.1&7.3.4.3&7.3.5.2&7.3.6.2&7.3.6.3".split("&");
        Stream<String> stream = Arrays.stream(str);
        Object[] o1 = stream.filter(s -> s.contains("2.1.")).toArray();
        for (int i = 0; i < o1.length; i++) {
            System.out.println(str[i].toString());
        }
    }

 

②filter中写代码块的代码如下:

【注意】:filter中写代码块,需要true或者false都要返回,否则要报错!

@org.junit.Test
    public void test() throws IOException{
        String [] str = "2.1.1&2.1.2&2.1.5&2.1.6&3.1.1&3.2.2&3.3.3&4.1.1&4.1.2&4.1.4&5.1.2&7.1.2&7.2.1&7.3.1.1&7.3.3.1&7.3.4.3&7.3.5.2&7.3.6.2&7.3.6.3".split("&");
        Stream<String> stream = Arrays.stream(str);
        Object[] o1 = stream.filter(s -> {if(s.contains("3.1.")&& ! s.contains("7.")){
                return true;
            }return false;
        }).toArray();
        //输出原数据
        System.out.println("输出原数据");
        for (int i = 0; i < str.length; i++) {
            System.out.println(str[i]);
        }
        
        System.out.println("输出处理后数据");
        for (int i = 0; i < o1.length; i++) {
            System.out.println(o1[i]);
        }
        
        
    }

 

 

2.List集合转化为Stream

【集合.stream()即可】

 

 

3.使用count()计数

计算List中对象的某个属性值为一个特定值的 对象有多少个

Long shanghaiNum = comList.stream().filter(i->"上海所属产品".equals(i.getBelong())).count();

先把list转化为stream(),然后filter中写出需要满足的筛选条件,最后count()计数。

 

 

4.List进行filter筛选后获取到新的List

List<ComPriceSet> xianList = comList.stream().filter(i-> "西安所属产品".equals(i.getBelong())).collect(Collectors.toList());

 

 

5.List按照对象的某个字段进行去重 distinct()

【需要进行去重操作的对象,重新equals()方法】

例如下面:

package net.shopxx.controller.admin;

/**
 * 产品工具类 内部结算销量统计表
 * @author SXD
 *
 */
public class ProCom {
    
    private Long productId;
    private String productName;
    
    public Long getProductId() {
        return productId;
    }
    public void setProductId(Long productId) {
        this.productId = productId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((productId == null) ? 0 : productId.hashCode());
        result = prime * result
                + ((productName == null) ? 0 : productName.hashCode());
        return result;
    }
    
    //规定如果productId一致,则代表两个equals() 为true
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ProCom other = (ProCom) obj;
        if (productId == null) {
            if (other.productId != null)
                return false;
        } else if (!productId.equals(other.productId))
            return false;
        
        return true;
    }
    
    
    
}
View Code
List<ProCom>  xianProList =  xianProList.stream().distinct().collect(Collectors.toList())

 

6.List中有需要按照某个字段进行分组,可以使用Collectors.groupingBy()分组器实现

例如:

按照ComLabSet实体中productId进行分组,Collectors.groupingBy(ComLabSet::getProductId)中::后面跟的是你要分组的字段的get方法名
package net.shopxx.controller.admin;

/**
 * 导出实验室对账单 工具类
 * @author SXD
 *
 */
public class ComLabSet  implements Comparable<ComLabSet>{
    
    private Long orderId;        //订单ID
    private Boolean by_credit_card;//是否赠送 1true   0false
    private Long productId;        //产品ID
    private String productName;    //产品名称
    private String product_belong;//产品所属公司
    private String cybbm;            //采样包编码
    private Long sysId;                //实验室ID
    private String sysName;            //实验室名称
    
    
    
    public Long getOrderId() {
        return orderId;
    }
    public void setOrderId(Long orderId) {
        this.orderId = orderId;
    }
    public Boolean getBy_credit_card() {
        return by_credit_card;
    }
    public void setBy_credit_card(Boolean by_credit_card) {
        this.by_credit_card = by_credit_card;
    }
    public Long getProductId() {
        return productId;
    }
    public void setProductId(Long productId) {
        this.productId = productId;
    }
    public String getProductName() {
        return productName;
    }
    public void setProductName(String productName) {
        this.productName = productName;
    }
    public String getProduct_belong() {
        return product_belong;
    }
    public void setProduct_belong(String product_belong) {
        this.product_belong = product_belong;
    }
    public String getCybbm() {
        return cybbm;
    }
    public void setCybbm(String cybbm) {
        this.cybbm = cybbm;
    }
    public Long getSysId() {
        return sysId;
    }
    public void setSysId(Long sysId) {
        this.sysId = sysId;
    }
    public String getSysName() {
        return sysName;
    }
    public void setSysName(String sysName) {
        this.sysName = sysName;
    }
    @Override
    public int compareTo(ComLabSet s) {
        Long productId1 = this.getProductId();
        Long productId2 = s.getProductId();
        return productId1>productId2 ? 1 : productId1 == productId2 ? 0 : -1;
    }
    
    
    
}
View Code
Map<Long,List<ComLabSet>> xianTypeMap = xianList.stream().collect(Collectors.groupingBy(ComLabSet::getProductId));

结果类似于下面:Map的键是分组字段productId ,值是一组的list

 

相关文章
|
3月前
|
安全 Java API
告别繁琐编码,拥抱Java 8新特性:Stream API与Optional类助你高效编程,成就卓越开发者!
【8月更文挑战第29天】Java 8为开发者引入了多项新特性,其中Stream API和Optional类尤其值得关注。Stream API对集合操作进行了高级抽象,支持声明式的数据处理,避免了显式循环代码的编写;而Optional类则作为非空值的容器,有效减少了空指针异常的风险。通过几个实战示例,我们展示了如何利用Stream API进行过滤与转换操作,以及如何借助Optional类安全地处理可能为null的数据,从而使代码更加简洁和健壮。
108 0
|
19天前
|
Java API 数据处理
探索Java中的Lambda表达式与Stream API
【10月更文挑战第22天】 在Java编程中,Lambda表达式和Stream API是两个强大的功能,它们极大地简化了代码的编写和提高了开发效率。本文将深入探讨这两个概念的基本用法、优势以及在实际项目中的应用案例,帮助读者更好地理解和运用这些现代Java特性。
|
1月前
|
Java 流计算
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具!
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具!
37 1
Flink-03 Flink Java 3分钟上手 Stream 给 Flink-02 DataStreamSource Socket写一个测试的工具!
|
1月前
|
Java Shell 流计算
Flink-02 Flink Java 3分钟上手 Stream SingleOutputStreamOpe ExecutionEnvironment DataSet FlatMapFunction
Flink-02 Flink Java 3分钟上手 Stream SingleOutputStreamOpe ExecutionEnvironment DataSet FlatMapFunction
23 1
Flink-02 Flink Java 3分钟上手 Stream SingleOutputStreamOpe ExecutionEnvironment DataSet FlatMapFunction
|
2月前
|
存储 Java API
Java——Stream流详解
Stream流是JDK 8引入的概念,用于高效处理集合或数组数据。其API支持声明式编程,操作分为中间操作和终端操作。中间操作包括过滤、映射、排序等,可链式调用;终端操作则完成数据处理,如遍历、收集等。Stream流简化了集合与数组的操作,提升了代码的简洁性
82 11
Java——Stream流详解
|
1月前
|
存储 Java 数据处理
Flink-01 介绍Flink Java 3分钟上手 HelloWorld 和 Stream ExecutionEnvironment DataSet FlatMapFunction
Flink-01 介绍Flink Java 3分钟上手 HelloWorld 和 Stream ExecutionEnvironment DataSet FlatMapFunction
35 1
|
2月前
|
Java API C++
Java 8 Stream Api 中的 peek 操作
本文介绍了Java中`Stream`的`peek`操作,该操作通过`Consumer&lt;T&gt;`函数消费流中的每个元素,但不改变元素类型。文章详细解释了`Consumer&lt;T&gt;`接口及其使用场景,并通过示例代码展示了`peek`操作的应用。此外,还对比了`peek`与`map`的区别,帮助读者更好地理解这两种操作的不同用途。作者为码农小胖哥,原文发布于稀土掘金。
114 9
Java 8 Stream Api 中的 peek 操作
|
2月前
|
Java C# Swift
Java Stream中peek和map不为人知的秘密
本文通过一个Java Stream中的示例,探讨了`peek`方法在流式处理中的应用及其潜在问题。首先介绍了`peek`的基本定义与使用,并通过代码展示了其如何在流中对每个元素进行操作而不返回结果。接着讨论了`peek`作为中间操作的懒执行特性,强调了如果没有终端操作则不会执行的问题。文章指出,在某些情况下使用`peek`可能比`map`更简洁,但也需注意其懒执行带来的影响。
139 2
Java Stream中peek和map不为人知的秘密
|
2月前
|
Java 大数据 API
Java 流(Stream)、文件(File)和IO的区别
Java中的流(Stream)、文件(File)和输入/输出(I/O)是处理数据的关键概念。`File`类用于基本文件操作,如创建、删除和检查文件;流则提供了数据读写的抽象机制,适用于文件、内存和网络等多种数据源;I/O涵盖更广泛的输入输出操作,包括文件I/O、网络通信等,并支持异常处理和缓冲等功能。实际开发中,这三者常结合使用,以实现高效的数据处理。例如,`File`用于管理文件路径,`Stream`用于读写数据,I/O则处理复杂的输入输出需求。
|
2月前
|
Java 程序员 API
Java 8新特性之Lambda表达式与Stream API的探索
【9月更文挑战第24天】本文将深入浅出地介绍Java 8中的重要新特性——Lambda表达式和Stream API,通过实例解析其语法、用法及背后的设计哲学。我们将一探究竟,看看这些新特性如何让Java代码变得更加简洁、易读且富有表现力,同时提升程序的性能和开发效率。