strem流filter 带条件 stream流常用方法

文章目录

• Stream流的概括及方法

• 介绍
• 具体方法

• ①生成Stream流的各种方式（Collection集合，Map体系集合，数组）
• ②——Stream流中间操作方法（常见方法）
• ③——Stream流终结操作方法（常见方法
• ④——Stream流的收集操作（方法和工具类）

• Stream中filter和map的使用区别
• 例题展示

Stream流的概括及方法

介绍

Stream流是使用stream()或.parallelStream()将集合生成流，然后可以对其中的元素进行流式操作，对流的操作中最常用的是filter和map方法。
演示代码：

class test  
{
	public static void main (String[] args)
	{
		List<Integer> list = new ArrayList<>();
		for(int i = 0; i < 10; i++){
			list.add(i);
		}
		List<Integer> list1 = list.stream().filter(i -> i <= 5).collect(Collectors.toList());
		System.out.println(list1);
		List<Integer> list2 = list.stream().map(i -> i*i).collect(Collectors.toList());
		System.out.println(list2);
	}
}

代码结果：
0.1.2.3.4.5
0, 1, 4, 9, 16, 25, 36, 49, 64, 81

具体方法

①生成Stream流的各种方式（Collection集合，Map体系集合，数组）

代码演示

②——Stream流中间操作方法（常见方法）

③——Stream流终结操作方法（常见方法

④——Stream流的收集操作（方法和工具类）

Stream中filter和map的使用区别

原生js中数组可以直接通过map(),filter()函数来进行一次操作，他们分别是做一次统一映射，和一次过滤。说的更通俗一点，就是map函数之后，数组元素个数不变，但是按照一定的条件转换，数组元素发生了变化。filter函数之后，数组元素个数可能发生了改变，但是数组元素不会发生改变。

import java.io.*;
import java.util.stream.Collectors;
import java.util.List;
import java.util.ArrayList;

class test  
{
	public static void main (String[] args)
	{
		List<Integer> list = new ArrayList<>();
		for(int i = 0; i < 10; i++){
			list.add(i);
		}
		List<Integer> list1 = list.stream().filter(i -> i <= 5).collect(Collectors.toList());
		System.out.println(list1);
		List<Integer> list2 = list.stream().map(i -> i*i).collect(Collectors.toList());
		System.out.println(list2);
	}
}

运行结果
[0, 1, 2, 3, 4, 5]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
filter()和map()的区别：
filter是过滤操作，返回结果为true的数据；而map的作用是将流中的每一个元素T映射为R。

例题展示

主页面：

import java.util.*;
import java.util.stream.Stream;

public class Demo05 {
    public static void main(String[] args) {
        List<Transaction> transactions = null;
        Trader raoul = new Trader("Raoul", "Cambridge");
        Trader mario = new Trader("Mario", "Milan");
        Trader alan = new Trader("Alan", "Cambridge");
        Trader brian = new Trader("Brian", "Cambridge");
        transactions = Arrays.asList(
                new Transaction(brian, 2011, 300),
                new Transaction(raoul, 2012, 1000),
                new Transaction(raoul, 2011, 400),
                new Transaction(mario, 2012, 710),
                new Transaction(mario, 2012, 700),
                new Transaction(alan, 2012, 950)
        );


//        1. 找出 2011 年发生的所有交易， 并按交易额排序（从低到高）
//        2. 交易员都在哪些不同的城市工作过
//        3. 查找所有来自剑桥的交易员，并按姓名排序
//        4. 返回所有交易员的姓名字符串，按字母顺序排序
//        5. 有没有交易员是在米兰工作的
//        6. 打印生活在剑桥的交易员的所有交易额
//        7. 所有交易中，最高的交易额是多少
//        8. 找到交易额最小的交易


    Stream<Transaction> stream1 = transactions.stream().filter(e -> e.getYear() == 2011).
            sorted((e1, e2) -> Integer.compare(e1.getValue(), e2.getValue()));
    stream1.forEach(System.out::println);
    System.out.println("---------------------------------");
    Stream<String> stream2 = transactions.stream().
            map(e -> e.getTrader().getCity()).distinct();
    stream2.forEach(System.out::println);
    System.out.println("----------------------------------");
    Stream<Transaction> stream3 = transactions.stream().filter(e -> e.getTrader().getCity().equals("Cambridge")).
            sorted((e1, e2) -> e1.getTrader().getName().compareTo(e2.getTrader().getName()));
    stream3.forEach(System.out::println);
    System.out.println("-----------------------");
    Stream<String> steam4 = transactions.stream().map(e -> e.getTrader().getName()).sorted((e1, e2) -> e1.compareTo(e2));
    steam4.forEach(System.out::println);
    System.out.println("--------------------------");
    boolean b = transactions.stream().anyMatch(e -> e.getTrader().getCity().equals("Milan"));
    System.out.println("有没有在米兰工作的" + b);
    System.out.println("-----------------------------");
    transactions.stream().filter(e -> e.getTrader().getCity().equals("Cambridge")).map(Transaction::getValue).forEach(System.out::println);
    System.out.println("--------------------------");
    Optional<Integer> max = transactions.stream().map(Transaction::getValue).max(Integer::compareTo);
    System.out.println("最高价格是多少" + max.get());
    System.out.println("-------------------------------------");
    Optional<Transaction> min = transactions.stream().min(Comparator.comparing(e -> e.getValue()));
    System.out.println("最低价格是" + min);
}

}
类：

class Trader {
	        private String name;
	        private String city;
	
        public Trader() {
        }

    public Trader(String name, String city) {
        this.name = name;
        this.city = city;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Trader [name=" + name + ", city=" + city + "]";
    }
}

class Transaction {
    private Trader trader;
    private int year;
    private int value;

    public Transaction() {
    }

    public Transaction(Trader trader, int year, int value) {
        this.trader = trader;
        this.year = year;
        this.value = value;
    }

    public Trader getTrader() {
        return trader;
    }

    public void setTrader(Trader trader) {
        this.trader = trader;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getValue() {
        return value;
    }

    public void setValue(int value) {
        this.value = value;
    }

    @Override
    public String toString() {
        return "Transaction [trader=" + trader + ", year=" + year + ", value="
                + value + "]";
    }
}