java之Stream的常见用法

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象, 是一个来自数据源的元素队列并支持聚合操作(https://upload-images.jianshu.io/upload_images/6348370-f8218715507512e1.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

Stream 可以对集合和数组进行一些简化操作,将集合或数组转化为Stream流，使用Stream流中的方法对集合/数组中的元素进行操作，解决集合中的一些弊端

和以前的Collection操作不同，Stream操作还有两个基础的特征

Pipelining:中间操作都会返回流对象本身，这样多个操作可以串联成一个管道，如果流式风格(fluent style),这样做可以对操作进行优化，比如延迟执行(laziness)和短路(short-circuiting)
内部迭代：以前对集合遍历都是通过Iterator或者增强for的方式，显示的在集合外部进行迭代，这叫做外部迭代，Stream提供了内部迭代的方式，流可以直接调用遍历方法
当使用一个流的时候，通常包括3个步骤：获取一个数据源(source) -> 数据转换 -> 执行操作获取想要的结果,每次转换原有Stream对象，返回一个新的Stream对象，这就允许对其操作可以向链条一样排列，变成一个管道

516E226E-0FFF-43E9-9283-779D9491EB38.png

Stream两种使用方法：
1.在java.util.Collection 中有一个方法 default Stream
2.java.util.stream接口的静态方法of可以获取数组对应的流
static Stream of (T... values)

        List list = new ArrayList();
        Stream stream1 = list.stream();

        Set set = new HashSet();
        Stream stream2 = set.stream();

        Map map = new HashMap();
        Set keySet= map.keySet();
        Stream stream3 = keySet.stream();

        Collection collection = map.values();
        Stream stream4 = collection.stream();

        // 获取键值对的映射关系
        // Map.entrySet() 这个方法返回的是一个Set>，Map.Entry 是Map中的一个接口，他的用途是表示一个映射项（里面有Key和Value），
        // 而Set>表示一个映射项的Set。Map.Entry里有相应的getKey和getValue方法，即JavaBean，让我们能够从一个项中取出Key和Value
        Set> entries = map.entrySet();
        Stream> stream = entries.stream();

        // 数组转换为stream流
        Integer[] arr = {1,2,3,4,5};
        Stream stream5= Stream.of(arr);

案例1 ：对列表/数组中的每个元素都乘以2

package NewFeature.JavaStream;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public static void main(String[] args) {
    int[] list = IntStream.range(1, 10).map(i -> i*2).toArray();
        for (int value: list) {
            System.out.println(value);
        }

    // or
    List result = IntStream.range(10, 20).map(i -> i*2).boxed().collect(Collectors.toList());
        for (int value: result) {
            System.out.println(value);
        }
}

输出：

案例2：筛选重复元素

List list = Arrays.asList(1,2,2,3,4,2,1,5);
list.stream().filter(i -> i%2 == 0).distinct().forEach(System.out::println);

输出：

2
4

选出以"张"开头、长度为3的名字

        List list = new ArrayList();
        list.add("张三丰");
        list.add("马可波诺");
        list.add("张小龙");
        list.add("赵无极");
        list.add("青龙");
        list.add("乔峰");

        List shortList = new ArrayList<>();
        for (String name:list) {
            if (name.length() == 3 && name.startsWith("张")) {
                shortList.add(name);
            }
        }
        System.out.println("张开头并且长度为2的名字=" + shortList.toString())

list.stream().filter(value -> value.startsWith("张"))
                .filter(value -> value.length() == 3)
                .collect(Collectors.toList()).forEach(System.out::print);

案例3：限制元素数量

List list = Arrays.asList(2,5,6,6,8,2,12,63,53,13,76);
        list.stream().filter(i -> i>5).
                distinct().
                limit(3).
//                skip(1).
                collect(Collectors.toList()).
                forEach(System.out::println);

输出：

6
8
12

// 加了skip(1)
8
12

案例4: Stream支持map方法，接收一个函数作为参数，这个函数被应用到每个元素上，并将其映射成一个新元素

List list = Arrays.asList("wudy", "macBook", "china hello");
        List wordLens = list.stream().map(String::length).collect(Collectors.toList());
        for (Integer item:wordLens) {
            System.out.println("长度=" + item);
        }

输出：

长度=4
长度=7
长度=11

案例5：flatmap方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接起来成为一个流

List list = Arrays.asList("Hello", "World");
        list.stream().map(word -> word.split(""))
                     .flatMap(Arrays::stream)
                     .distinct()
                     .collect(Collectors.toList())
                     .forEach(System.out::print)

输出：

HeloWrd

如下图：

B6AC3DC1-1866-434E-AF24-A4A6FA232579.png

-案例6：给定两个数字列表，返回所有的数对？例如：给定列表[1,3]、[2,4,6], 应该返回[(1,2),(1,4),(1,6),(3,2),(3,4),(3,6)]

List list1 = Arrays.asList(1,3);
        List list2 = Arrays.asList(2,4,6);
        List pairs = list1.stream().flatMap(i -> list2.stream()
                                          .map(j -> new int[] {i, j}))
                                          .collect(Collectors.toList());
        // pairs.stream().forEach(item -> Arrays.stream(item).forEach();
        for (int [] item: pairs) {
            System.out.println(Arrays.toString(item));
        }

输出:

[1, 2]
[1, 4]
[1, 6]
[3, 2]
[3, 4]
[3, 6]

案例7: 匹配给定的谓词

List list = Arrays.asList("wudy","peter");
        if (list.stream().anyMatch(value -> value.equals("peter"))) {
            System.out.println("匹配到了给定的谓词");
        }

输出：

匹配到了给定的谓词

案例8: 流中是否所有的元素能匹配给定的谓词

List list = Arrays.asList(5,7,11,423,54);
        if (list.stream().allMatch(value -> value > 3)) {
            System.out.println("匹配了所有的谓词");
        }

输出：

匹配了所有的谓词

案例9: 流中没有任何元素能匹配给定的谓词

List list = Arrays.asList(101,198,112,423,354);
        if (list.stream().noneMatch(value -> value < 100)) {
            System.out.println("都能活到100岁");
        }

输出：

都能活到100岁

案例10: 求Sum、max

List list = Arrays.asList(1,2,3,4,5,6);
//        Integer sum = list.stream().reduce(0, (a, b) -> a + b);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println("sum=" + sum);

        Integer max = list.stream().reduce(0, Integer::max);
        System.out.println("max=" + max);

输出：

sum=21
max=6

案例11：现在有一个List集合，想对该集合中的数据分组处理

package NewFeature.JavaStream;

public class User {
    private  Integer id;
    private  Integer age;
    private  String name;

    public User(Integer id, Integer age, String name) {
        this.id = id;
        this.age = age;
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public Integer getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

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

}

package NewFeature.JavaStream;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 现在有一个List集合，想对该集合中的数据分组处理
 */
public class StreamDemo {
    public static void main(String[] args) {
        List list = getUserList();
        Map> userGroupList = list.stream().collect(Collectors.groupingBy(User::getAge));
        System.out.println(userGroupList);
//        for (Integer key: userGroupList.keySet()) {
//            System.out.println(userGroupList.get(key));
//        }
//
//        for (List value: userGroupList.values()) {
//            System.out.println(value);
//        }
    }

    public static ArrayList getUserList() {
        User user1 = new User(1, 18, "wudy");
        User user2 = new User(2, 20, "peter");
        User user3 = new User(3, 30, "timo");
        User user4 = new User(4, 20, "chimmy");

        ArrayList arrayList = new ArrayList();
        arrayList.add(user1);
        arrayList.add(user2);
        arrayList.add(user3);
        arrayList.add(user4);
        return arrayList;
    }
}

输出：

{18=[NewFeature.JavaStream.User@5b6f7412], 20=[NewFeature.JavaStream.User@27973e9b, NewFeature.JavaStream.User@312b1dae], 30=[NewFeature.JavaStream.User@7530d0a]}

Java8中Stream对列表去重的几种方法

1.distinct() 对于 String 列表的去重

 @Test
    public void stream1(){
        List list = new ArrayList<>();
        list.add("A");
        list.add("C");
        list.add("B");
        list.add("C");

        System.out.println("去重前=" + list);
        list = list.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后=" + list);
    }

去重前=[A, C, B, C]
去重后=[A, C, B]

2.对实体类列表的去重

// 定义实体类
@Data
@AllArgsConstructor
@NoArgsConstructor
@TableName(value = "message")
public class Message implements Serializable {
   @ApiModelProperty(value = "用户司机企业的id")
    private Long uid;

    @ApiModelProperty(value = "客服id")
    private String agentId;

    @ApiModelProperty(value = "客服名称")
    private String agentName;
}

// 实现类 MessageServiceImpl
package cn.huolala.llim.im.service.impl;


@Service
public class MessageServiceImpl extends ServiceImpl implements IMessageService {

    @Autowired
    private IMessageMapper iMessageMapper;

    @Override
    public List queryList(Message message, PageBO pager) {
        // 多条件构造器
        QueryWrapper queryWrapper = new QueryWrapper<>();
        queryWrapper
                .select("uid", "agent_id", "agent_name")  // 查询指定字段
                .isNotNull("uid").eq("uid", message.getUid());

        queryWrapper.orderByDesc("created_at");
        Page page = new Page<>(pager.getPage_no(), pager.getPage_size());
        page = iMessageMapper.selectPage(page, queryWrapper);
        return page.getRecords();
    }
}

import static java.util.stream.Collectors.collectingAndThen;
import static java.util.stream.Collectors.toCollection;

 @Test
    public void stream() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        Message message = new Message();
        message.setUid(113074491521L);

        PageBO page = new PageBO();
        page.setPage_no(1);
        page.setPage_size(10);

        // 1. 对于 Message 列表去重
        List messageList = iMessageService.queryList(message, page);
        System.out.println("去重前=" + messageList);
//        System.out.println("writeValueAsString = " + objectMapper.writeValueAsString(messageList));
        messageList = messageList.stream().distinct().collect(Collectors.toList());
        System.out.println("去重后=" + messageList);
//        System.out.println("writeValueAsString = " + objectMapper.writeValueAsString(messageList));

        messageList = messageList.stream().collect(
                collectingAndThen(
                        toCollection(() -> new TreeSet<>(Comparator.comparing(Message::getAgentId))), ArrayList::new)
        );
        System.out.println("根据agentID去重后=" + messageList);
    }

<==    Columns: uid, agent_id, agent_name
<==        Row: 113074491521, 107, wudy.yu2
<==        Row: 113074491521, 107, wudy.yu
<==        Row: 113074491521, 108, wudy.yu3
<==        Row: 113074491521, 107, wudy.yu


去重前=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=107, agentName=wudy.yu), Message(uid=113074491521, agentId=108, agentName=wudy.yu3), Message(uid=113074491521, agentId=107, agentName=wudy.yu)]
去重后=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=107, agentName=wudy.yu), Message(uid=113074491521, agentId=108, agentName=wudy.yu3)]
根据agentID去重后=[Message(uid=113074491521, agentId=107, agentName=wudy.yu2), Message(uid=113074491521, agentId=108, agentName=wudy.yu3)]

3.根据List

java之Stream的常见用法

你可能感兴趣的:(java之Stream的常见用法)