Java笔记

最新推荐文章于 2024-06-10 21:57:08 发布

雪里看海

最新推荐文章于 2024-06-10 21:57:08 发布

阅读量93

点赞数

文章标签： java 网络 udp

本文链接：https://blog.csdn.net/weixin_46045873/article/details/123232118

版权

1.体验Stream流

需求：按照下面的要求完成集合的创建和遍历
创建一个集合，存储多个字符串元素
把集合中所有以“张”开头的元素存储到一个新的集合
把“张”开头的集合中的长度为3的元素存储到一个新的集合
遍历上一步得到的集合

使用Stream流的方式完成过滤操作
list.stream().filter(s -> s.startsWith(“张”)).filter(s -> s.length() == 3).forEach(System.out::println);
直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生成流、过滤姓张、过滤长度为3、逐一打印
Stream流把真正的函数式编程风格引入到Java中

2.Stream流的生成方式
在这里插入图片描述
生成流：
通过数据源（集合，数组等）生成流
list.stream（）
中间操作：
一个流后面可以跟随零个或多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/ 映射，返回一个新的流，交给下一个操作使用
filter （）
终结操作：
一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
forEach（）

Stream流的生成方式
Collection体系的集合可以使用默认方法stream() 生成流
default Stream < E > stream()
Map体系的集合间接的生成流
数组可以通过Stream接口的静态方法of(T…values)生成流

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

public class StreamDemo {
    public static void main(String[] args) {
        //Collection体系的集合可以使用默认方法stream() 生成流
        List<String> list = new ArrayList<>();
        Stream<String> listStream = list.stream();

        Set<String> set = new HashSet<>();
        Stream<String> setStream = set.stream();

        //Map体系的集合间接的生成流   间接生成流
        Map<String,Integer> map = new HashMap<>();
        Stream<String> keyStream = map.keySet().stream();
        Stream<Integer> valueStream = map.values().stream();
        Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();

        //数组可以通过Stream接口的静态方法of(T...values)生成流
        String[] strArray = {"hello","world","java"};
        Stream<String> strArrayStream = Stream.of(strArray);
        Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
        Stream<Integer> intStream = Stream.of(10, 20, 30);

    }
}

3.Stream流的常见中间操作方法

Stream< T > filter(Predicate predicate) : 用于对流中的数据进行过滤
Predicate 接口中的方法 boolean test(T t) : 对给定的参数进行判断，返回一个布尔值
Stream< T > limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
Stream< T > skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static < T > Stream< T > concat(Stream a,Stream b)：合并a和b两个流为一个流
Stream< T > distinct() ：返回由该流的不同元素（根据Object.equals(Object)）组成的流
Stream< T > sorted()：返回由此流的元素组成的流，根据自然顺序排序
Stream< T >sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序
< R > Stream< R > map (Function mapper) ：返回由给定函数应用于此流的结果组成的流
Function接口中的方法 R apply(T t)
IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果
IntStream：表示原始int流
ToIntFunction接口中的方法 int applyAsInt(T value)

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamDemo01 {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //把list集合中以张开头的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
        System.out.println("---------");

        //把list集合中长度为3的元素在控制台输出
        list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("---------");

        //把list集合中以张开头，长度为3的元素在控制台输出
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
        System.out.println("=========");

        //取前3个数据,在控制台输出
        //Stream< T > limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("----------");

        //跳过3个元素,把剩下的元素在控制台输出
        //Stream< T > skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("----------");

        //跳过2个元素,把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
        System.out.println("==========");

        //取前4个数据组成一个流
        Stream<String> s1 = list.stream().limit(4);

        //跳过2个数据组成一个流
        Stream<String> s2 = list.stream().skip(2);

        //合并需求1和需求2得到的流,并把结果在控制台输出
        //static < T > Stream< T > concat(Stream a,Stream b)：合并a和b两个流为一个流
//        Stream.concat(s1,s2).forEach(System.out::println);

        //合并需求1和需求2得到的流,并把结果在控制台输出，要求字符串元素不能重复
        //Stream< T >  distinct() ：返回由该流的不同元素（根据Object.equals(Object)）组成的流
        Stream.concat(s1, s2).distinct().forEach(System.out::println);
        System.out.println("=========");

        //按照字母顺序把数据在控制台输出
        //Stream< T > sorted()：返回由此流的元素组成的流，根据自然顺序排序
//        list.stream().sorted().forEach(System.out::println);

        //按照字符串长度把数据在控制台输出
//        list.stream().sorted((s3, s4) -> s3.length() - s4.length()).forEach(System.out::println);
        list.stream().sorted((s3, s4) -> {
            int num = s3.length() - s4.length();
            int num2 = num == 0 ? s3.compareTo(s4) : num;
            return num2;
        }).forEach(System.out::println);

    }
}

import java.util.ArrayList;

public class StreamDemo03 {
    public static void main(String[] args) {
        //创建一个集合,存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();

        list.add("10");
        list.add("20");
        list.add("30");
        list.add("40");
        list.add("50");

        //将集合中的字符串数据转换为整数之后在控制台输出
        //< R > Stream< R > map (Function mapper) ：返回由给定函数应用于此流的结果组成的流
//        list.stream().map(s->Integer.parseInt(s)).forEach(System.out::println);
        list.stream().map(Integer::parseInt).forEach(System.out::println);
        System.out.println("-----------");

        //IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果
        list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
            //int sum() 返回此流中元素的总和
        int result = list.stream().mapToInt(Integer::parseInt).sum();
        System.out.println(result);

    }
}

4.Stream流的常见终结操作方法

Stream流的常见终结操作方法
void forEach(Consumer action)：对此流的每个元素执行操作
Consumer接口中的方法 void accept(T t) ：对给定的参数执行此操作
long count（）：返回此流中的元素数

import java.util.ArrayList;

public class StreamDemo {
    public static void main(String[] args) {
        //创建一个集合，存储多个字符串元素
        ArrayList<String> list = new ArrayList<>();

        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");
        list.add("张敏");
        list.add("张无忌");

        //把集合中的元素在控制台输出
        list.stream().forEach(System.out::println);

        //统计集合中有几个以张开头的元素，并把统计结果在控制台输出
        long count = list.stream().filter(s -> s.startsWith("张")).count();
        System.out.println(count);

    }
}

5.Stream流的练习

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
男演员只要名字为3个字的前三人
女演员只要姓林的，并且不要第一个
把过滤后的男演员姓名和女演员姓名合并到一起
把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

/*
    演员类
 */
public class Actor {
    private String name;

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

import java.util.ArrayList;
import java.util.stream.Stream;

public class StreamTest {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> manList = new ArrayList<>();
        manList.add("周润发");
        manList.add("成龙");
        manList.add("刘德华");
        manList.add("吴京");
        manList.add("周星驰");
        manList.add("李连杰");

        ArrayList<String> womanList = new ArrayList<>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");

        //男演员只要名字为3个字的前三人
        Stream<String> ms = manList.stream().filter(s -> s.length() == 3).limit(3);

        //女演员只要姓林的，并且不要第一个
        Stream<String> ws = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(ms, ws);

        //把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
        stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
        System.out.println("------");

        Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3),
                womanList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).
                forEach(p -> System.out.println(p.getName()));

    }
}

6.Stream流的收集操作

对数据使用Stream流的方式操作完毕后，怎么把流中的数据收集到集合中？
Stream流的收集方法
R collect(Collector collector)
但是这个收集方法的参数是一个Collect接口

工具类Collectors提供了具体的收集方式
public static < T > Collector toList() : 把元素收集到 List集合中。
public static < T > Collector toSet() : 把元素收集到 Set集合中。
public static Collector toMap(Function keyMapper,Function valueMapper)：把元素收集到Map集合中

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

public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<>();
        list.add("路飞");
        list.add("乌索普");
        list.add("乔巴");
        list.add("弗兰奇");
        list.add("索隆");

        //得到名字为3个字的流
        Stream<String> listStream = list.stream().filter(s -> s.length() == 3);

        //把使用Stream流操作完毕的数据收集到list集合中并遍历
        List<String> names = listStream.collect(Collectors.toList());
        for (String name : names) {
            System.out.println(name);
        }
        System.out.println("------");

        //创建Set集合对象
        Set<Integer> set = new HashSet<>();
        set.add(18);
        set.add(27);
        set.add(23);
        set.add(26);
        set.add(20);

        //得到年龄大于25的流
        Stream<Integer> setStream = set.stream().filter(age -> age > 25);

        //把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for (Integer age : ages) {
            System.out.println(age);
        }
        System.out.println("------");

        //定义一个字符串数组，每一个字符串数据由姓名和年龄数据组合而成
        String[] strArray = {"路飞,25", "索隆,28", "娜美,23", "乌索普,27"};

        //得到字符串中年龄数据大于26的流
        Stream<String> arrayStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split(",")[1]) > 26);
        System.out.println(arrayStream);

        //把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串中的姓名作键、年龄作值
        Map<String, Integer> map = arrayStream.collect(Collectors.toMap(s -> s.split(",")[0], 
        s -> Integer.parseInt(s.split(",")[1])));
        Set<String> keySet = map.keySet();
        for (String key : keySet) {
            Integer value = map.get(key);
            System.out.println(key + "," + value);
        }

    }
}