JavaEE学习记录day09集合03 Map集合、Stream流

2023-11-16

JavaEE学习记录day09集合03 Map集合、Stream流

1.Map集合

1.1Map集合概述和特点【理解】

Map集合概述

interface Map<K,V>  K：键的类型；V：值的类型

Map集合的特点
- 双列集合,一个键对应一个值
- 键不可以重复,值可以重复

Map集合的基本使用

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key, V value) 将指定的值与该映射中的指定键相关联
        map.put("itheima001","林青霞");
        map.put("itheima002","张曼玉");
        map.put("itheima003","王祖贤");
        map.put("itheima003","柳岩");

        //输出集合对象
        System.out.println(map);
    }
}

1.2Map集合的基本功能【应用】

方法介绍

方法名	说明
V put(K key,V value)	添加元素
V remove(Object key)	根据键删除键值对元素
void clear()	移除所有的键值对元素
boolean containsKey(Object key)	判断集合是否包含指定的键
boolean containsValue(Object value)	判断集合是否包含指定的值
boolean isEmpty()	判断集合是否为空
int size()	集合的长度，也就是集合中键值对的个数

示例代码

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String,String> map = new HashMap<String,String>();

        //V put(K key,V value)：添加元素
        map.put("张无忌","赵敏");
        map.put("郭靖","黄蓉");
        map.put("杨过","小龙女");

        //V remove(Object key)：根据键删除键值对元素
//        System.out.println(map.remove("郭靖"));
//        System.out.println(map.remove("郭襄"));

        //void clear()：移除所有的键值对元素
//        map.clear();

        //boolean containsKey(Object key)：判断集合是否包含指定的键
//        System.out.println(map.containsKey("郭靖"));
//        System.out.println(map.containsKey("郭襄"));

        //boolean isEmpty()：判断集合是否为空
//        System.out.println(map.isEmpty());

        //int size()：集合的长度，也就是集合中键值对的个数
        System.out.println(map.size());

        //输出集合对象
        System.out.println(map);
    }
}

1.3Map集合的获取功能【应用】

方法介绍

方法名	说明
V get(Object key)	根据键获取值
Set keySet()	获取所有键的集合
Collection values()	获取所有值的集合
Set<Map.Entry<K,V>> entrySet()	获取所有键值对对象的集合

示例代码

public class MapDemo03 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //V get(Object key):根据键获取值
//        System.out.println(map.get("张无忌"));
//        System.out.println(map.get("张三丰"));

        //Set<K> keySet():获取所有键的集合
//        Set<String> keySet = map.keySet();
//        for(String key : keySet) {
//            System.out.println(key);
//        }

        //Collection<V> values():获取所有值的集合
        Collection<String> values = map.values();
        for(String value : values) {
            System.out.println(value);
        }
    }
}

1.4Map集合的遍历(方式1)【应用】

遍历思路
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
  - 把所有的丈夫给集中起来
  - 遍历丈夫的集合，获取到每一个丈夫
  - 根据丈夫去找对应的妻子
步骤分析
- 获取所有键的集合。用keySet()方法实现
- 遍历键的集合，获取到每一个键。用增强for实现
- 根据键去找值。用get(Object key)方法实现

代码实现

public class MapDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键的集合。用keySet()方法实现
        Set<String> keySet = map.keySet();
        //遍历键的集合，获取到每一个键。用增强for实现
        for (String key : keySet) {
            //根据键去找值。用get(Object key)方法实现
            String value = map.get(key);
            System.out.println(key + "," + value);
        }
    }
}

1.5Map集合的遍历(方式2)【应用】

遍历思路
- 我们刚才存储的元素都是成对出现的，所以我们把Map看成是一个夫妻对的集合
  - 获取所有结婚证的集合
  - 遍历结婚证的集合，得到每一个结婚证
  - 根据结婚证获取丈夫和妻子
步骤分析
- 获取所有键值对对象的集合
  - Set<Map.Entry<K,V>> entrySet()：获取所有键值对对象的集合
- 遍历键值对对象的集合，得到每一个键值对对象
  - 用增强for实现，得到每一个Map.Entry
- 根据键值对对象获取键和值
  - 用getKey()得到键
  - 用getValue()得到值

代码实现

public class MapDemo02 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

2.HashMap集合

2.1HashMap集合概述和特点【理解】

HashMap底层是哈希表结构的
依赖hashCode方法和equals方法保证键的唯一
如果键要存储的是自定义对象，需要重写hashCode和equals方法

2.2HashMap集合应用案例【应用】

案例需求
- 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
- 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

代码实现

学生类

public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (age != student.age) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = name != null ? name.hashCode() : 0;
        result = 31 * result + age;
        return result;
    }
}

测试类

public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap集合对象
        HashMap<Student, String> hm = new HashMap<Student, String>();

        //创建学生对象
        Student s1 = new Student("林青霞", 30);
        Student s2 = new Student("张曼玉", 35);
        Student s3 = new Student("王祖贤", 33);
        Student s4 = new Student("王祖贤", 33);

        //把学生添加到集合
        hm.put(s1, "西安");
        hm.put(s2, "武汉");
        hm.put(s3, "郑州");
        hm.put(s4, "北京");

        //遍历集合
        Set<Student> keySet = hm.keySet();
        for (Student key : keySet) {
            String value = hm.get(key);
            System.out.println(key.getName() + "," + key.getAge() + "," + value);
        }
    }
}

3.TreeMap集合

3.1TreeMap集合概述和特点【理解】

TreeMap底层是红黑树结构
依赖自然排序或者比较器排序,对键进行排序
如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则

3.2TreeMap集合应用案例一【应用】

案例需求
- 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历
- 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序

代码实现

学生类

public class Student implements Comparable<Student>{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        //按照年龄进行排序
        int result = o.getAge() - this.getAge();
        //次要条件，按照姓名排序。
        result = result == 0 ? o.getName().compareTo(this.getName()) : result;
        return result;
    }
}

测试类

public class Test1 {
    public static void main(String[] args) {
      	// 创建TreeMap集合对象
        TreeMap<Student,String> tm = new TreeMap<>();
      
		// 创建学生对象
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);
      
		// 将学生对象添加到TreeMap集合中
        tm.put(s1,"江苏");
        tm.put(s2,"北京");
        tm.put(s3,"天津");
      
		// 遍历TreeMap集合,打印每个学生的信息
        tm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "---" + value);
                }
        );
    }
}

3.3TreeMap集合应用案例二【应用】

案例需求
- 给定一个字符串,要求统计字符串中每个字符出现的次数。
- 举例: 给定字符串是“aababcabcdabcde”,在控制台输出: “a(5)b(4)c(3)d(2)e(1)”

代码实现

public class Test2 {
    public static void main(String[] args) {
      	// 给定字符串
        String s = "aababcabcdabcde";
		// 创建TreeMap集合对象,键是Character,值是Integer
        TreeMap<Character,Integer> tm = new TreeMap<>();

        //遍历字符串，得到每一个字符
        for (int i = 0; i < s.length(); i++) {
            //c依次表示字符串中的每一个字符
            char c = s.charAt(i);
          	// 判断当前遍历到的字符是否在集合中出现过
            if(!tm.containsKey(c)){
                //表示当前字符是第一次出现。
                tm.put(c,1);
            }else{
                //存在，表示当前字符已经出现过了
                //先获取这个字符已经出现的次数
                Integer count = tm.get(c);
                //自增，表示这个字符又出现了依次
                count++;
                //将自增后的结果再次添加到集合中。
                tm.put(c,count);
            }
        }
        //  a（5）b（4）c（3）d（2）e（1）
        //System.out.println(tm);
        tm.forEach(
                (Character key,Integer value)->{
                    System.out.print(key + "（" + value + "）");
                }
        );
    }
}

4.可变参数

4.1可变参数【应用】

可变参数介绍
- 可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
- 方法的参数类型已经确定,个数不确定,我们可以使用可变参数

可变参数定义格式

修饰符 返回值类型 方法名(数据类型… 变量名) {  }

可变参数的注意事项
- 这里的变量其实是一个数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在最后

可变参数的基本使用

public class ArgsDemo01 {
    public static void main(String[] args) {
        System.out.println(sum(10, 20));
        System.out.println(sum(10, 20, 30));
        System.out.println(sum(10, 20, 30, 40));

        System.out.println(sum(10,20,30,40,50));
        System.out.println(sum(10,20,30,40,50,60));
        System.out.println(sum(10,20,30,40,50,60,70));
        System.out.println(sum(10,20,30,40,50,60,70,80,90,100));
    }

//    public static int sum(int b,int... a) {
//        return 0;
//    }

    public static int sum(int... a) {
        int sum = 0;
        for(int i : a) {
            sum += i;
        }
        return sum;
    }
}

4.2创建不可变集合【理解】

方法介绍
- 在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合
  - 这个集合不能添加,不能删除,不能修改
  - 但是可以结合集合的带参构造,实现集合的批量添加
- 在Map接口中,还有一个ofEntries方法可以提高代码的阅读性
  - 首先会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中

示例代码

public class MyVariableParameter4 {
    public static void main(String[] args) {
        // static <E>  List<E>  of(E…elements)  创建一个具有指定元素的List集合对象
        //static <E>  Set<E>  of(E…elements)    创建一个具有指定元素的Set集合对象
        //static <K , V>   Map<K，V>  of(E…elements) 创建一个具有指定元素的Map集合对象

        //method1();
        //method2();
        //method3();
        //method4();

    }

    private static void method4() {
        Map<String, String> map = Map.ofEntries(
                Map.entry("zhangsan", "江苏"),
                Map.entry("lisi", "北京"));
        System.out.println(map);
    }

    private static void method3() {
        Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
        System.out.println(map);
    }

    private static void method2() {
        //传递的参数当中，不能存在重复的元素。
        Set<String> set = Set.of("a", "b", "c", "d","a");
        System.out.println(set);
    }

    private static void method1() {
        List<String> list = List.of("a", "b", "c", "d");
        System.out.println(list);
        //list.add("Q");
        //list.remove("a");
        //list.set(0,"A");
        //System.out.println(list);

//        ArrayList<String> list2 = new ArrayList<>();
//        list2.add("aaa");
//        list2.add("aaa");
//        list2.add("aaa");
//        list2.add("aaa");

        //集合的批量添加。
        //首先是通过调用List.of方法来创建一个不可变的集合，of方法的形参就是一个可变参数。
        //再创建一个ArrayList集合，并把这个不可变的集合中所有的数据，都添加到ArrayList中。
        ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d"));
        System.out.println(list3);
    }
}

5.Stream流

5.1体验Stream流【理解】

案例需求

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

原始方式示例代码

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

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

        //把集合中所有以"张"开头的元素存储到一个新的集合
        ArrayList<String> zhangList = new ArrayList<String>();

        for(String s : list) {
            if(s.startsWith("张")) {
                zhangList.add(s);
            }
        }

//        System.out.println(zhangList);

        //把"张"开头的集合中的长度为3的元素存储到一个新的集合
        ArrayList<String> threeList = new ArrayList<String>();

        for(String s : zhangList) {
            if(s.length() == 3) {
                threeList.add(s);
            }
        }

//        System.out.println(threeList);

        //遍历上一步得到的集合
        for(String s : threeList) {
            System.out.println(s);
        }
        System.out.println("--------");

        //Stream流来改进
//        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

使用Stream流示例代码

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

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

        //Stream流来改进
        list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
    }
}

Stream流的好处
- 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：获取流、过滤姓张、过滤长度为3、逐一打印
- Stream流把真正的函数式编程风格引入到Java中
- 代码简洁

5.2Stream流的常见生成方式【应用】

Stream流的思想

在这里插入图片描述

Stream流的三类方法
- 获取Stream流
  - 创建一条流水线,并把数据放到流水线上准备进行操作
- 中间方法
  - 流水线上的操作
  - 一次操作完毕之后,还可以继续进行其他操作
- 终结方法
  - 一个Stream流只能有一个终结方法
  - 是流水线上的最后一个操作
生成Stream流的方式
- Collection体系集合
  
  使用默认方法stream()生成流， default Stream stream()
- Map体系集合
  
  把Map转成Set集合，间接的生成流
- 数组
  
  通过Arrays中的静态方法stream生成流
- 同种数据类型的多个数据
  
  通过Stream接口的静态方法of(T… values)生成流

代码演示

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

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

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

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

5.3Stream流中间操作方法【应用】

概念

中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作

常见方法

方法名	说明
Stream filter(Predicate predicate)	用于对流中的数据进行过滤
Stream limit(long maxSize)	返回此流中的元素组成的流，截取前指定参数个数的数据
Stream skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream distinct()	返回由该流的不同元素（根据Object.equals(Object) ）组成的流

filter代码演示

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

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

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

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

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

limit&skip代码演示

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

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

        //需求1：取前3个数据在控制台输出
        list.stream().limit(3).forEach(System.out::println);
        System.out.println("--------");

        //需求2：跳过3个元素，把剩下的元素在控制台输出
        list.stream().skip(3).forEach(System.out::println);
        System.out.println("--------");

        //需求3：跳过2个元素，把剩下的元素中前2个在控制台输出
        list.stream().skip(2).limit(2).forEach(System.out::println);
    }
}

concat&distinct代码演示

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

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

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

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

        //需求3：合并需求1和需求2得到的流，并把结果在控制台输出
//        Stream.concat(s1,s2).forEach(System.out::println);

        //需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
        Stream.concat(s1,s2).distinct().forEach(System.out::println);
    }
}

5.4Stream流终结操作方法【应用】

概念

终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作
常见方法

方法名说明

void forEach(Consumer action) 对此流的每个元素执行操作

long count() 返回此流中的元素数

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

代码演示

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

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

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

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

5.5Stream流的收集操作【应用】

概念

对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中
常用方法

方法名说明

R collect(Collector collector) 把结果收集到集合中

方法名	说明
R collect(Collector collector)	把结果收集到集合中

工具类Collectors提供了具体的收集方式

方法名	说明
public static Collector toList()	把元素收集到List集合中
public static Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

代码演示

public class CollectDemo {
    public static void main(String[] args) {
        //创建List集合对象
        List<String> list = new ArrayList<String>();
        list.add("林青霞");
        list.add("张曼玉");
        list.add("王祖贤");
        list.add("柳岩");

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

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

        //创建Set集合对象
        Set<Integer> set = new HashSet<Integer>();
        set.add(10);
        set.add(20);
        set.add(30);
        set.add(33);
        set.add(35);

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

        //需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
        Set<Integer> ages = setStream.collect(Collectors.toSet());
        for(Integer age : ages) {
            System.out.println(age);
        }
        */
        //定义一个字符串数组，每一个字符串数据由姓名数据和年龄数据组合而成
        String[] strArray = {"林青霞,30", "张曼玉,35", "王祖贤,33", "柳岩,25"};

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

        //需求6：把使用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);
        }
    }
}

5.6Stream流综合练习【应用】

案例需求

现在有两个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;
    }
}

测试类

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

        ArrayList<String> womanList = new ArrayList<String>();
        womanList.add("林心如");
        womanList.add("张曼玉");
        womanList.add("林青霞");
        womanList.add("柳岩");
        womanList.add("林志玲");
        womanList.add("王祖贤");
  
        /*
        //男演员只要名字为3个字的前三人
        Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
  
        //女演员只要姓林的，并且不要第一个
        Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
  
        //把过滤后的男演员姓名和女演员姓名合并到一起
        Stream<String> stream = Stream.concat(manStream, womanStream);
  
        //把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
//        stream.map(Actor::new).forEach(System.out::println);
        stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
        */
  
        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()));
    }
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

学习笔记

Java

JavaEE学习记录day09集合03 Map集合、Stream流的相关文章

java.lang.NoClassDefFoundError: javax/ws/rs/core/Configuration

我正在实现轻松的网络服务并且正在使用 jboss 4 0 但我遇到以下异常 java lang NoClassDefFoundError javax ws rs core Configuration 我的 web xml 是
我可以为 Spring Boot 应用程序创建多个入口点吗？

In 春季启动需要指定一个主类它是应用程序的入口点通常这是一个具有标准 main 方法的简单类如下所示 SpringBootApplication public class MySpringApplication public s
使用 Java NIO 直接访问 Windows 磁盘

我正在使用一个使用 Java NIO 的库来直接将文件映射到内存但我在直接读取磁盘时遇到问题 I can直接使用读取磁盘FileInputStream与 UNC 合作例如 File disk new File PhysicalDrive
Spring Batch 多线程

我正在编写一个 Spring Batch 并希望在需要时对其进行扩展我的 ApplicationContext 看起来像这样 Configuration EnableBatchProcessing EnableTransactionMan
Eclipse 说“更新 Android Developer Toolkit”

我不知何故弄乱了我的 Eclipse 和 Android 设置我不知道如何修复它问题症状如下在首选项 gt Android 中我尝试选择 android sdk linux 的位置选择时出现错误此 Android SDK 需要
Spring 可以理解 @Inject 替换 Weld 作为 JSR-299 实现吗？

我从几个网页中注意到 Spring 3 0 显然支持来自 JSR 330 的 Inject 由于我们确实希望在 Web 应用程序和独立应用程序的库中使用 JSR 299 语法进行依赖项注入并且有 Weld 的替代方案因此如果 Sprin
UiBinder 中的 gwt 按钮

我需要创建一个按钮所以它是一个带有图像的按钮 gwt with UiBinder 但我不确定如何进行这是我的ui xml code
全屏独占模式下的 AWT 框架在窗口弹出对话框中最小化

我正在开发一个在全屏独占模式下使用 awt 框架的应用程序一切正常直到弹出窗口可见这会抢走焦点我的应用程序将被最小化这是我的框架的初始化代码 if ApplicationConfig getInstance useFullscre
在 Eclipse 中导航 Java 调用堆栈

在调试器中像GDB http sources redhat com gdb 当您在断点处停止时您可以轻松地向上移动调用堆栈并检查相关的源和堆栈帧数据在 Eclipse 中如何做到这一点 In the 调试视角 http www ibm
找不到模块：javafx.controls

我已经下载了JavaFX SDK 解压它并设置PATH TO FX系统变量如下本说明 https openjfx io openjfx docs install javafx 我使用了以下代码示例 import javafx applic
如何在Android Studio中关联.mp3文件

我想根据列表视图项单击播放 mp3 文件但是根据我的代码我运行我的应用程序出现此窗口因此由于缺少音频选项我真的不知道需要选择其中哪一个为了关联我的 mp3 文件 mainList setOnItemClickListener ne
如何更改tomcat jmx密码的文件权限

我正在尝试保护 Windows 平台上托管的本地 tomcat 实例上的 JMX 访问我已经创建了访问权限和密码文件并使用以下 VM 参数插入这些文件 Dcom sun management jmxremote password fil
在java中将jpeg/png转换为像素数组

如何将包含 jpeg 或 png 的字符串转换为像素数组最好是一维理想情况下使用java内置的类原来你需要公共文件上传 http commons apache org fileupload 看着那这用户指南 http commons
使用 java.nio.file.Paths 接口时缺少方案（IllegalArgumentException）

这是一个非常简单的java问题我在 Linux 系统上使用 Java 8 和 eclipse kepler 我一直在尝试尝试NIO 2 我的代码是 package lucasTest import java io IOException
如何告诉 Java SAX 解析器忽略无效字符引用？

当尝试使用字符引用解析不正确的 XML 时例如 x1 Java 的 SAX 解析器因致命错误而惨死例如 org xml sax SAXParseException Character reference x1 is an invalid
获取运行时生成的类的字节

我正在使用一个 Java 框架该框架使用自定义类加载器在运行时生成一些代理类我想为任何这样的类获取自定义 ClassLoader 从 loadClass 返回的与该类对应的原始字节数组这可能吗我知道如果一个类作为资源存在那么
Java可以进行进程监控吗？

是否可以用Java编写一个在托盘中运行的应用程序并且当启动某个应用程序时它可以检测到它我想对某些程序执行此操作以了解我每周使用它们多长时间我是 Java 新手所以我不知道 Java 是否是最适合此操作的语言或者它是否具有对操作
我可以从同一个 jar 文件执行两个不同的类吗？

我有一个项目在一个包中我制作了服务器在第二个包中我制作了客户端它运行良好我想创建一个 Jar 文件是否可以使用同一个 jar 文件分别运行客户端和服务器我使用了只有一个 main 的 jar 文件当我运行 jar 文件时它会
LinkedBlockingQueue 抛出 InterruptedException

我有这段代码 ALinkedBlockingQueue应该只抛出一个Exception如果在等待添加到队列时被中断但这个队列是无限的所以它应该尽快添加为什么我的关闭方法会抛出一个InterruptedException private
Ant 类路径和 junit.jar

我有一个 build xml 它允许我运行 junit 测试这是相关部分

随机推荐

Nginx配置文件详细说明

原创 http www cnblogs com xiaogangqq123 archive 2011 03 02 1969006 html 在此记录下Nginx服务器nginx conf的配置文件说明部分注释收集与网络运行用户 user
微信小程序：自定义导航栏

看到有的微信小程序的页面左上角有了个小房子可以返回首页这是怎么做到的其实这是微信开放的自定义的自定义导航栏来完成但是最开始对于一个页面很多的小程序其实有点一言难尽因为你自定义你可能要所有页面都要添加一遍现在小程序可以自定
34. Search for a Range

这道题一开始没看别人的算法第一个想法是用递归做自己憋了两个小时终于憋出来了然而超时递归的想法是先用二分法找到一个target 然后从target左右再用二分法找边界然而真的是太慢了 class Solution public
VSCode问题记录

20230304 0 引言这几年的编程方式还真是各种变化从一开始直接VIM 到后面使用jupyter进行机器学习相关然后再过渡到vim的形式并加以tmux批量化最后去年使用了vscode作为IDE 随着工具的变化那么很多习惯也都随
UnityVR--EventManager--事件中心2

目录前言事件中心的结构 EventManager事件管理器 EventType事件类型 EventListener监听及回调 EventDataBase回调时需要传递的参数总结前言上一篇事件中心1 中简单解释了委托事件监听
【Java SE】类和对象(全网最细详解)

点进来你就是我的人了博主主页戳一戳欢迎大佬指点欢迎志同道合的朋友一起加油喔目录前言一面向对象的初步认知 1 什么是面向对象 2 面向对象和面向过程的区别二类和对象的基本概念三类和对象的定义和使用 1 类的创建 2 对象
数据库的url配置8.0

spring datasource username root spring datasource password lhh12345 spring datasource url jdbc mysql localhost 3306 myba
numpy.diag()结构及用法

numpy diag v k 0 官方文档以一维数组的形式返回方阵的对角线或非对角线元素或将一维数组转换成方阵非对角线元素为0 两种功能角色转变取决于输入的v 1 更深层的见numpy diagnal 参数详解 v array l
windows获取系统DPI

dc GetDeviceCaps LOGPIXELSX 每英寸水平逻辑像素数 dc GetDeviceCaps LOGPIXELSY 每英寸垂直逻辑像素数 dc GetDeviceCaps HORZRES 水平像素总数 dc GetDevi
[Java]获取java方法注释实例

Method methods company class getMethod getId null PK pk methods getAnnotation PK class System out println pk
vue指令中v-show和v-if以及keep-alive的区别

v if 属于条件显示满足条件就显示元素不满足就删除元素通过操作DOM元素完成 v if的首次渲染显示的开销较小因为它只渲染满足条件的那一个元素切换组件时其开销较大因为它每切换以此就要重新触发生命周期渲染显示新元素 v if值
JS实现轮播图(自动+手动)

网页轮播图效果核心原理 tips 代码在文章末尾这个ul就是我们这四张图片的父盒子我们通过对这个父盒子添加动画函数来实现移动然后给父盒子来一个溢出隐藏就达到了轮播的效果动画函数如下 function animate obj tar
【python爬虫】8.温故而知新

文章目录前言回顾前路代码实现体验代码功能拆解获取数据解析提取数据存储数据程序实现与总结前言 Hello又见面了上一关我们学习了爬虫数据的存储并成功将QQ音乐周杰伦歌曲信息的数据存储进了csv文件和excel文件学到
8.typescript-函数的类型

今儿个甚是乏累呢但是 lt 下面可能是正题儿 gt 1 函数声明 1 function student x string y number string 2 return 我是 x 今年 y 岁 3 4 5 console log stu
商品期货怎么玩？ 1手交易需要多少钱？

期货市场中有许多大宗商品把他们统称为商品期货近几年我国商品期货品种不时在增加固然期货风险比较高但收益也十分可观而且商品期货开户几乎没有门槛国内商品期货免费开户无资金限制凭身份证和银行卡即可办理开设期货帐户能在网上开期货帐
Unity XCode iOS 实现拍照和相册选择上传头像

显示弹窗通过UIAlertController来创建一个弹窗 if defined cplusplus extern C endif 导出接口供unity使用 void IOS Open IOSCameraController app I
剑指 Offer 25. 合并两个排序的链表(java+python)

输入两个递增排序的链表合并这两个链表并使新链表中的节点仍然是递增排序的示例1 输入 1 gt 2 gt 4 1 gt 3 gt 4 输出 1 gt 1 gt 2 gt 3 gt 4 gt 4 限制 0 lt 链表长度 lt 1000 思
sql语句学习(b站韩顺平的demo)

表的CRUD varchar varchar2 char的区别时间时间戳使用创建表创建一张表表结构与已经存在的表一致查看表的信息表中增加一列修改表中的列删除表中的列修改表名修改表的字符集修改表中的列名表中数据的插入
关于算法，我们都应知道的

定义算法是指对特定问题求解步骤的一种描述特性 1 有穷性算法是由若干条指令组成的有穷序列总是在执行若干次后结束不可能永不停止 2 确定性每条语句有确定的含义无歧义 3 可行性算法在当前环境条件下可以通过有限次运算实现 4 输
JavaEE学习记录day09集合03 Map集合、Stream流

JavaEE学习记录day09集合03 Map集合 Stream流 1 Map集合 1 1Map集合概述和特点理解 Map集合概述 interface Map

JavaEE学习记录day09集合03 Map集合、Stream流

JavaEE学习记录day09集合03 Map集合、Stream流

1.Map集合

1.1Map集合概述和特点【理解】

1.2Map集合的基本功能【应用】

1.3Map集合的获取功能【应用】

1.4Map集合的遍历(方式1)【应用】

1.5Map集合的遍历(方式2)【应用】

2.HashMap集合

2.1HashMap集合概述和特点【理解】

2.2HashMap集合应用案例【应用】

3.TreeMap集合

3.1TreeMap集合概述和特点【理解】

3.2TreeMap集合应用案例一【应用】

3.3TreeMap集合应用案例二【应用】

4.可变参数

4.1可变参数【应用】

4.2创建不可变集合【理解】

5.Stream流

5.1体验Stream流【理解】

5.2Stream流的常见生成方式【应用】

5.3Stream流中间操作方法【应用】

5.4Stream流终结操作方法【应用】

5.5Stream流的收集操作【应用】

5.6Stream流综合练习【应用】

JavaEE学习记录day09集合03 Map集合、Stream流 的相关文章

随机推荐

热门标签

JavaEE学习记录day09集合03 Map集合、Stream流的相关文章