第八章_集合(3)_Map集合&Stream流

无休止符

已于 2022-04-09 20:06:07 修改

阅读量3.4k

点赞数 5

分类专栏： JavaEE初级（一）Java基础文章标签： java

于 2022-04-09 20:05:09 首次发布

本文链接：https://blog.csdn.net/qq23001186/article/details/124062736

版权

JavaEE初级（一）Java基础专栏收录该内容

36 篇文章 3 订阅

订阅专栏

一、Map

1、Map集合的基本使用

Map集合概述：interface Map<K,V> K -> 键的类型；V：值的类型
Map集合的特点
- 双列集合，一个键对应一个值
- 键不可以重复，值可以重复
Map集合的基本使用

import java.util.HashMap;
import java.util.Map;

public class MyMap1 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("itheima001","小智");
        map.put("itheima002","小美");
        map.put("itheima003","大胖");
        System.out.println(map);
    }
}

2、Map集合的常用方法

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

import java.util.HashMap;
import java.util.Map;
/**
 * Map的基本方法
 */
public class MyMap2 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<>();
        map.put("itheima001","小智");
        map.put("itheima002","小美");
        map.put("itheima003","大胖");
        map.put("itheima004","小黑");
        map.put("itheima005","大师");
        //method1(map);
        //method2(map);
        //method3(map);
        //method4(map);
        //method5(map);
        //method6(map);
        //method7(map);
    }
    private static void method7(Map<String, String> map) {
        //        int size()              集合的长度，也就是集合中键值对的个数
        int size = map.size();
        System.out.println(size);
    }
    private static void method6(Map<String, String> map) {
        //        boolean isEmpty()       判断集合是否为空
        boolean empty1 = map.isEmpty();
        System.out.println(empty1);//false
        map.clear();
        boolean empty2 = map.isEmpty();
        System.out.println(empty2);//true
    }
    private static void method5(Map<String, String> map) {
        //        boolean containsValue(Object value) 判断集合是否包含指定的值
        boolean result1 = map.containsValue("aaa");
        boolean result2 = map.containsValue("小智");
        System.out.println(result1);
        System.out.println(result2);
    }
    private static void method4(Map<String, String> map) {
        //        boolean containsKey(Object key) 判断集合是否包含指定的键
        boolean result1 = map.containsKey("itheima001");
        boolean result2 = map.containsKey("itheima006");
        System.out.println(result1);
        System.out.println(result2);
    }
    private static void method3(Map<String, String> map) {
        //        void clear()            移除所有的键值对元素
        map.clear();
        System.out.println(map);
    }
    private static void method2(Map<String, String> map) {
        //        V remove(Object key)    根据键删除键值对元素
        String s = map.remove("itheima001");
        System.out.println(s);
        System.out.println(map);
    }
    private static void method1(Map<String, String> map) {
        //        V put(K key,V value)    添加元素
        //如果要添加的键不存在，那么会把键值对都添加到集合中
        //如果要添加的键是存在的，那么会覆盖原先的值，把原先值当做返回值进行返回。
        String s = map.put("itheima001", "aaa");
        System.out.println(s);
        System.out.println(map);
    }
}

3、Map集合遍历

Map集合的获取方法

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

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

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MyMap3 {
    public static void main(String[] args) {
        //创建集合并添加元素
        Map<String,String> map = new HashMap<>();
        map.put("1号丈夫","1号妻子");
        map.put("2号丈夫","2号妻子");
        map.put("3号丈夫","3号妻子");
        map.put("4号丈夫","4号妻子");
        map.put("5号丈夫","5号妻子");
        //获取到所有的键
        Set<String> keys = map.keySet();
        //遍历Set集合得到每一个键
        for (String key : keys) {
            //通过每一个键key，来获取到对应的值
            String value = map.get(key);
            System.out.println(key + "---" + value);
        }
    }
}

map第二种遍历方式

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

public class MyMap4 {
    public static void main(String[] args) {
        //创建集合并添加元素
        Map<String,String> map = new HashMap<>();
        map.put("1号丈夫","1号妻子");
        map.put("2号丈夫","2号妻子");
        map.put("3号丈夫","3号妻子");
        map.put("4号丈夫","4号妻子");
        map.put("5号丈夫","5号妻子");
        //首先要获取到所有的键值对对象。
        //Set集合中装的是键值对对象（Entry对象）
        //而Entry里面装的是键和值
        Set<Map.Entry<String, String>> entries = map.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            //得到每一个键值对对象
            String key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "---" + value);
        }
    }
}

二、HashMap

HashMap集合概述和特点
- HashMap底层是哈希表结构的
- 依赖hashCode方法和equals方法保证键的唯一
- 如果键要存储的是自定义对象，需要重写hashCode和equals方法
案例：HashMap集合存储自定义对象并遍历

//学生类
public class Student{
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
	//GET...SET...
    @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;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
//测试类
import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Map的练习
 */
public class MyMap5 {
    public static void main(String[] args) {
        HashMap<Student,String> hm = new HashMap<>();
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);
        hm.put(s1,"江苏");
        hm.put(s2,"北京");
        hm.put(s3,"天津");
        //第一种：先获取到所有的键，再通过每一个键来找对应的值
        Set<Student> keys = hm.keySet();
        for (Student key : keys) {
            String value = hm.get(key);
            System.out.println(key + "----" + value);
        }
        System.out.println("===================================");
        //第二种：先获取到所有的键值对对象。再获取到里面的每一个键和每一个值
        Set<Map.Entry<Student, String>> entries = hm.entrySet();
        for (Map.Entry<Student, String> entry : entries) {
            Student key = entry.getKey();
            String value = entry.getValue();
            System.out.println(key + "----" + value);
        }
        System.out.println("===================================");
        //第三种：
        hm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "----" + value);
                }
        );
    }
}

三、TreeMap

TreeMap集合概述和特点
- TreeMap底层是红黑树结构
- 依赖自然排序或者比较器排序,对键进行排序
- 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出比较器排序规则（排序的时候只关心键的排序，与值无关）
案例1：学生排序

//学生类
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;
    }

	//GET...SET...

    @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;
    }*/
}
//测试类
import java.util.Comparator;
import java.util.TreeMap;

/**
 * 需求：创建一个TreeMap集合，键是学生对象(Student)，值是籍贯(String)。
 *           学生属性姓名和年龄，按照年龄进行排序并遍历。
 */
public class Test1 {
    public static void main(String[] args) {
        TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                int result = o1.getAge() - o2.getAge();
                result = result== 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            }
        });
        Student s1 = new Student("xiaohei",23);
        Student s2 = new Student("dapang",22);
        Student s3 = new Student("xiaomei",22);
        tm.put(s1,"江苏");
        tm.put(s2,"北京");
        tm.put(s3,"天津");
        tm.forEach(
                (Student key, String value)->{
                    System.out.println(key + "---" + value);
                }
        );
    }
}

案例2：统计字符串中每个字符出现次数

import java.util.TreeMap;

/**
 * 字符串“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> 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 + "）");
                }
        );
    }
}

四、可变参数

可变参数：可变参数又称参数个数可变，用作方法的形参出现，那么方法参数个数就是可变的了
可变参数定义格式：修饰符返回值类型方法名(数据类型… 变量名) { }
可变参数的注意事项
- 这里的变量其实是一个数组
- 如果一个方法有多个参数，包含可变参数，可变参数要放在最后
案例1：定义一个方法求N个数的和

public class MyVariableParameter2 {
    public static void main(String[] args) {
        //在JDK5之前，会把所有的数据都先放到一个数组中
        //我们自己定义的方法，形参只要写一个数组就可以了。
        int [] arr = {1,2,3,4,5};
        int sum1 = getSum(arr);
        System.out.println(sum1);
    }
    private static int getSum(int[] arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum;
    }
}

案例2：使用可变参数求N个数的和

public class MyVariableParameter3 {
    public static void main(String[] args) {
//        int [] arr = {1,2,3,4,5};
//        System.out.println(arr);
        int sum1 = getSum(1, 2, 3, 4, 5);
        System.out.println(sum1);
    }
    public static int getSum(int number,int... arr) {
        //System.out.println(arr);
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum;
    }
}

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

    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);
    }

案例2：set中of用法

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

案例3：map中of、ofEntries用法

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

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

五、Stream流

1、Stream流概念

体验Stream流

import java.util.ArrayList;
import java.util.List;

/**
 * 体验Stream流
 * 创建一个集合，存储多个字符串元素
 * "张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"
 * 把集合中所有以"张"开头的元素存储到一个新的集合
 * 把"张"开头的集合中的长度为3的元素存储到一个新的集合
 * 遍历上一步得到的集合
 *
 */
public class MyStream1 {
    public static void main(String[] args) {
        //集合的批量添加
        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
        //遍历list1把以张开头的元素添加到list2中。
        ArrayList<String> list2 = new ArrayList<>();
        for (String s : list1) {
            if(s.startsWith("张")){
                list2.add(s);
            }
        }
        //遍历list2集合，把其中长度为3的元素，再添加到list3中。
        ArrayList<String> list3 = new ArrayList<>();
        for (String s : list2) {
            if(s.length() == 3){
                list3.add(s);
            }
        }
        for (String s : list3) {
            System.out.println(s);
        }
        System.out.println("=======================");
       //Stream流
        list1.stream().filter(s->s.startsWith("张"))
                .filter(s->s.length() == 3)
                .forEach(s-> System.out.println(s));
    }
}

Steam流的思想

在这里插入图片描述

Stream流的三类方法
- 获取Stream流：创建一条流水线,并把数据放到流水线上准备进行操作
- 中间方法：流水线上的操作，一次操作完毕之后,还可以继续进行其他操作
- 终结方法：一个Stream流只能有一个终结方法，是流水线上的最后一个操作

2、获取Stream流的方式

四种获取Stream流的方式
- Collection体系集合：使用默认方法stream()生成流， default Stream stream()
- Map体系集合：把Map转成Set集合，间接的生成流
- 数组：通过Arrays中的静态方法stream生成流
- 同种数据类型的多个数据：通过Stream接口的静态方法of(T… values)生成流

    private static void method1() {
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
//        Stream<String> stream = list.stream();
//        stream.forEach(s-> System.out.println(s));
        list.stream().forEach(s-> System.out.println(s));
    }
    
    private static void method2() {
        HashMap<String,Integer> hm = new HashMap<>();
        hm.put("zhangsan",23);
        hm.put("lisi",24);
        hm.put("wangwu",25);
        hm.put("zhaoliu",26);
        hm.put("qianqi",27);
        //双列集合不能直接获取Stream流
        //keySet
        //先获取到所有的键
        //再把这个Set集合中所有的键放到Stream流中
        //hm.keySet().stream().forEach(s-> System.out.println(s));
        
        //entrySet
        //先获取到所有的键值对对象
        //再把这个Set集合中所有的键值对对象放到Stream流中
        hm.entrySet().stream().forEach(s-> System.out.println(s));
    }
    
    private static void method3() {
        int [] arr = {1,2,3,4,5};
        Arrays.stream(arr).forEach(s-> System.out.println(s));
    }
    
    private static void method4() {
        Stream.of(1,2,3,4,5,6,7,8).forEach(s-> System.out.println(s));
    }

3、Stream流的中间操作方法

中间操作的概念：中间操作的意思是，执行完此方法之后，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 MyStream3 {
    public static void main(String[] args) {
//        Stream<T> filter(Predicate predicate)：过滤
//                Predicate接口中的方法	boolean test(T t)：对给定的参数进行判断，返回一个布尔值
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        //filter方法获取流中的 每一个数据.
        //而test方法中的s,就依次表示流中的每一个数据.
        //我们只要在test方法中对s进行判断就可以了.
        //如果判断的结果为true,则当前的数据留下
        //如果判断的结果为false,则当前数据就不要.
//        list.stream().filter(
//                new Predicate<String>() {
//                    @Override
//                    public boolean test(String s) {
//                        boolean result = s.startsWith("张");
//                        return result;
//                    }
//                }
//        ).forEach(s-> System.out.println(s));

        //因为Predicate接口中只有一个抽象方法test
        //所以我们可以使用lambda表达式来简化
//        list.stream().filter(
//                (String s)->{
//                    boolean result = s.startsWith("张");
//                        return result;
//                }
//        ).forEach(s-> System.out.println(s));

        list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
    }
}

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);
      }
  }

4、Stream流终结操作方法

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

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

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

import java.util.ArrayList;
import java.util.function.Consumer;

public class MyStream5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("张三丰");
        list.add("张无忌");
        list.add("张翠山");
        list.add("王二麻子");
        list.add("张良");
        list.add("谢广坤");
        //method1(list);
//        long count()：返回此流中的元素数
        long count = list.stream().count();
        System.out.println(count);
    }

    private static void method1(ArrayList<String> list) {
        // void forEach(Consumer action)：对此流的每个元素执行操作
		// Consumer接口中的方法	void accept(T t)：对给定的参数执行此操作
        //在forEach方法的底层,会循环获取到流中的每一个数据.
        //并循环调用accept方法,并把每一个数据传递给accept方法
        //s就依次表示了流中的每一个数据.
        //所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.
        list.stream().forEach(
                new Consumer<String>() {
                    @Override
                    public void accept(String s) {
                        System.out.println(s);
                    }
                }
        );
        System.out.println("====================");
        //lambda表达式的简化格式
        //是因为Consumer接口中,只有一个accept方法
        list.stream().forEach(
                (String s)->{
                    System.out.println(s);
                }
        );
        System.out.println("====================");
        //lambda表达式还是可以进一步简化的.
        list.stream().forEach(s->System.out.println(s));
    }
}

Stream流数据无法直接修改

import java.util.ArrayList;
import java.util.List;

/**
 * Stream流的收集方法
 * 练习:
 * 定义一个集合，并添加一些整数1,2,3,4,5,6,7,8,9,10
 * 将集合中的奇数删除，只保留偶数。
 * 遍历集合得到2，4，6，8，10。
 */
public class MyStream6 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list.add(i);
        }
        list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
        System.out.println("====================");
        for (Integer integer : list) {
            System.out.println(integer);
        }
    }
}

5、Stream流搜集操作

收集操作：对数据使用Stream流的方式操作完毕后,可以把流中的数据收集到集合中
常用方法：R collect(Collector collector) -> 把结果收集到集合中

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

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

toList&toSet

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

public class MyStream7 {
    public static void main(String[] args) {
        ArrayList<Integer> list1 = new ArrayList<>();
        for (int i = 1; i <= 10; i++) {
            list1.add(i);
        }
        list1.add(10);
        list1.add(10);
        //collect负责收集数据，不负责创建容器,也不负责把数据添加到容器中
        //Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.
        List<Integer> list = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toList());
        System.out.println(list);
        Set<Integer> set = list1.stream().filter(number -> number % 2 == 0)
                .collect(Collectors.toSet());
        System.out.println(set);
    }
}

toMap

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

/**
 * Stream流的收集方法
 *
 * 创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄
 * "zhangsan,23"
 * "lisi,24"
 * "wangwu,25"
 * 保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
 */
public class MyStream8 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("zhangsan,23");
        list.add("lisi,24");
        list.add("wangwu,25");
        Map<String, Integer> map = list.stream().filter(
                s -> {
                    String[] split = s.split(",");
                    int age = Integer.parseInt(split[1]);
                    return age >= 24;
                }
         //collect方法只能获取到流中剩余的每一个数据.
         //在底层不能创建容器,也不能把数据添加到容器当中
         //Collectors.toMap 创建一个map集合并将数据添加到集合当中
          // s 依次表示流中的每一个数据
          //第一个lambda表达式就是如何获取到Map中的键
          //第二个lambda表达式就是如何获取Map中的值
        ).collect(Collectors.toMap(
                s -> s.split(",")[0],
                s -> Integer.parseInt(s.split(",")[1]) ));
        System.out.println(map);
    }
}

6、Stream流综合案例

案例需求：现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
- 男演员只要名字为3个字的前三人
- 女演员只要姓林的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类

public class Actor {
    private String name;

    public Actor() {
    }

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

    public String getName() {
        return name;
    }

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

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

测试类

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

public class MyStream9 {
    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> stream1 = manList.stream().filter(name -> name.length() == 3).limit(2);
        //女演员只要姓杨的，并且不要第一个
        Stream<String> stream2 = womanList.stream().filter(name -> name.startsWith("杨")).skip(1);
        Stream.concat(stream1,stream2).forEach(name -> {
            Actor actor = new Actor(name);
            System.out.println(actor);
        });
    }
}

无休止符

关注

5
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
0
评论
第八章_集合(3)_Map集合&Stream流

目录一、Map1、Map集合的基本使用2、Map集合的常用方法3、Map集合遍历二、HashMap三、TreeMap四、可变参数五、Stream流1、Stream流概念2、获取Stream流的方式3、Stream流的中间操作方法4、Stream流终结操作方法5、Stream流搜集操作6、Stream流综合案例一、Map1、Map集合的基本使用Map集合概述：interface Map<K,V> K -> 键的类型；V：值的类型Map集合的特点双列集合，一个键对应一个值键不
复制链接

扫一扫