javaSE进阶版各种集合和Stream流

Collection的其他相关知识：

Collections:是一个用来操作集合的工具类其中包括

1、给集合批量添加元素

可变参数的注意事项： 一个形参列表中只能有一个可变参数，并且可变参数必须放到形参列表的最后面。
public static void sum(int...nums){
    // 原理和本质：可变参数对外可以灵活的接收数据，对内本质就是一个数组。
    System.out.println(nums.length);
    System.out.println(Arrays.toString(nums));
}

2、打乱List集合中的元素顺序：

Collectons.shuffle(集合)

3、批量增添数据

Collections.addAll(names,"","","","");

4、方法一：让对象的类实现Comparable接口，重写compareTo方法，指定大小比较规则

Collections.sort(students);
public int compareTo(Student o) {
    return this.age - o.age; // 升序
}

方法二：指定Comparator比较器对象，在指定比较规则

Collections.sort(Student,new Comparator<Student>())

public int compare(Student o1,Student o2){

return Double.compare(o2.getHight() , o1,getHeight());

}

}

subList集合中可以截取所填参数之间的数据；

案例：map集合称为双列集合简称键值对集合

Map集合体系

1.Map集合是什么？什么时候可以考虑使用Map集合？

lMap集合是键值对集合

l需要存储一一对应的数据时，就可以考虑使用Map集合来做

2.Map集合的实现类有哪些？各自的特点是？

lHashMap:元素按照键是无序，不重复，无索引，值不做要求。

lLinkedHashMap:元素按照键是有序，不重复，无索引，值不做要求。

lTreeMap：元素按照建是排序，不重复，无索引的，值不做要求。

Map集合的常用方法：

Map<String ,Integer > map = new HashMap<>();

map.put("手表","2")添加方法 //可以添加空值

Map集合的常用API

常用的MapApi方法：

Map<String, Integer> map = new HashMap<>();
map.put("手表" ,2);
map.put("iphone" ,31);
map.put("huawei" ,365);
map.put("iphone" ,1);
map.put("娃娃", 31); // 31
map.put("Java入门",31);
map.put(null,null);
System.out.println(map);

1、获取集合的大小：

map.size();

2、清空集合

map.clear();

3、判断集合是否为空

map.isEmpty();

4、根据键获取对应的值

map.get("huawei")

5、根据键删除整个数据，返回删除数据对应的值

map.remove("iphone")

6、判断是否包含某个值

map.contaninsValue(1);

7、判断是否包含某个键

map.containsKey("娃娃")

8、获取Map集合的全部键，到一个set集合中返回的

Set<String > keys = map.keySet();

9、获取Map集合的全部值：到一个Collection集合中返回的

Collection<Integer> values = map.values();

Map集合的第一张遍历方法;找键值：

/ 1、先获取Map集合的全部键到一个Set集合中去。
Set<String> keys = map.keySet();

// 2、遍历键找值
for (String key : keys) {
    // 根据键提取值
    Integer value = map.get(key);
    System.out.println(key + "===>" + value);
}

第二种遍历：键值对遍历

Set<Map.Entry<String, Integer>> entries = map.entrySet();
for (Map.Entry<String, Integer> entry : entries) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println(key + "===>" + value);
}

第三中遍历：Lambda

map.forEach(new BiConsumer<String, Integer>() {
    @Override
    public void accept(String key, Integer value) {
        System.out.println(key + "====>" + value);
    }
});

总结：

案例：

答案：

package com.itheima.d5_map_travesal;

import java.util.*;

public class MapTest4 {
    public static void main(String[] args) {
        // 目标：使用Map集合完成投票案例。
        // 1、准备同学们选择的景点，80个选择。
        String[] names = {"玉龙雪山", "伶仃岛", "漓江", "五台山"};

        // 2、定义一个集合存储80个学生的选择。
        List<String> selects = new ArrayList<>();
        Random r = new Random();
        for (int i = 0; i < 80; i++) {
            selects.add(names[r.nextInt(names.length)]);
        }
        System.out.println(selects);

        // 3、统计每个景点想去的人数是多少。
        // 定义一个Map集合(键是景点，值是出现的次数)，用于存储最终统计的结果
        Map<String, Integer> map = new HashMap<>(); // map = {}

        // 4、遍历每个学生选择景点去map集合中统计：
        // selects = [伶仃岛, 五台山, 五台山, 五台山, 五台山, 漓江, 玉龙雪山, 伶仃岛, 漓江, .....
        for (String name : selects) {
            // 5、去map集合中看这个景点是否之前统计过，如果统计过，其值+1，如果没有统计过存入“景点=1”
//            if(map.containsKey(name)){
//                // 如果统计过，其值+1
//                map.put(name, map.get(name) + 1);
//            }else {
//                // 如果没有统计过存入“景点=1”
//                map.put(name, 1);
//            }
            map.put(name, map.containsKey(name) ? map.get(name) + 1 : 1);
        }

        System.out.println(map);

    }
}

HashMap:按照键，无序，不重复，无索引。值不做要求，键和值都可以是null

 Map<String, Integer> map = new HashMap<>(); // 一行经典代码

TreeMap

特点：不重复、无索引。可排序

目标：了解TreeMap集合：按照你键升序排序，不重复，无索引。

方式一：键类实现Comparable接口，重写比较规则。
方式二：让集合自带比较器对象(优先用这个)

Map<Movie, String> map = new TreeMap<>((o1, o2) -> Double.compare(o2.getScore(),o1.getScore()));

Stream流的使用：

1、获取集合的Stream流：default Stream<E> stream()

Colection.addAll();

2、获取Map集合的Stream流

Map<String ,Integer> map = new HashMap<>();

3、获取键值对流

Stream<Map.Entry<String,Integer>> kvs= map.entrySet().stream();

4、获取键流：

Stream<String> ks= map.keySet().stream();

5、获取值流

Steam<Integer> vs = map.values().stream();

6、获取数据的Stream

String[] names = {};

Stream<String> as1 = Array.strea(name);

Stream<String>as2 = Stream.of(names);

stream流

使用步骤：

1

方法：

Stream流解决问题

获取集合的Stream流

Collection<String> c = new ArrayList<>();

Collectons.addAll(c,填入数据)

Stream<String> s = c.stream();

获取Map集合的Stream流

Map<String,Integer> map = new HashMap<>();

获取键流

Stream <String >ks = map.keySet().stream();

获取值流

Stream <Integer>vs = map.values().stream();

获取键值对流

Stream<Map.Entry<String,Integer>>kvs = map.entrySdet().stream();

获取数组的liu

String []name = {};

Stream<String >as1 =Arrays.stream(names);

Sream<String>as2 = Stream.of(names);

Steam流的常见方法：

1、过滤方法：

list.stream().filter(s->s.startsWith("张")&&s.length()==3).forEath(System.out::println);

/ 方式一：对象类可以实现Comparable接口，指定比较规则  // sorted方法就可以按照规则进行排序，否则报错！
movies.stream().sorted().forEach(m -> System.out.println(m)); // 排序

// 方式二：自带比较器
movies.stream().sorted((m1, m2) -> Double.compare(m2.getScore(), m1.getScore())).forEach(System.out::println);

// 3、limit取前几个
System.out.println("-----------------------------------------------");
movies.stream().sorted((m1, m2) -> Double.compare(m2.getScore(), m1.getScore())).limit(2).forEach(System.out::println);

// 4、跳过前几个skip
System.out.println("-----------------------------------------------");
movies.stream().sorted((m1, m2) -> Double.compare(m2.getScore(), m1.getScore())).skip(2).forEach(System.out::println);


// 5、distinct去重复: 依赖对象的hashCode和equals方法！！
System.out.println("-----------------------------------------------");
movies.stream().sorted((m1, m2) -> Double.compare(m2.getScore(), m1.getScore())).distinct().forEach(System.out::println);

// 6、map加工方法(映射)：把流上的数据加工成新数据。
System.out.println("-----------------------------------------------");
movies.stream().sorted((m1, m2) -> Double.compare(m2.getScore(), m1.getScore()))
        .map(m -> new Actor(m.getActor(), m.getScore())).forEach(System.out::println);

movies.stream().map(m -> "这是一部电影：" + m.getName()).forEach(System.out::println);

// 7、合并流。
// 把两个流接起来 。
Stream<String> s1 = Stream.of("张三", "楚留香", "西门吹牛");
Stream<String> s2 = Stream.of("李四", "石观音");
// public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
Stream<String> s3 = Stream.concat(s1, s2);
s3.forEach(System.out::println);

public static void main(String[] args) {
    // 目标：Stream流的常见终结方法。
    List<Movie> movies = new ArrayList<>();
    movies.add(new Movie("摔跤吧，爸爸", 9.5, "阿米尔汗"));
    movies.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
    movies.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
    movies.add(new Movie("阿甘正传", 7.5, "汤姆汉克斯"));

    // 1、forEach
    movies.stream().forEach(System.out::println);

    System.out.println("--------------------------------------------------");
    // 2、count
    long count = movies.stream().distinct().count();
    System.out.println(count);
    System.out.println("--------------------------------------------------");

    // 3、取最大值
    Movie movie = movies.stream().max((m1, m2) -> Double.compare(m1.getScore(), m2.getScore())).get();
    System.out.println(movie);

    Movie movie2 = movies.stream().min((m1, m2) -> Double.compare(m1.getScore(), m2.getScore())).get();
    System.out.println(movie2);

    // 4、收集Stream流：把流中的数据恢复到集合或者数组中去。
    List<String> list = new ArrayList<>();
    list.add("张无忌");
    list.add("周芷若");
    list.add("赵敏");
    list.add("张强");
    list.add("张三丰");
    list.add("张三丰");

    // 收集到List集合
    Stream<String> zs = list.stream().filter(s -> s.startsWith("张"));
    List<String> names1 = zs.collect(Collectors.toList());
    System.out.println(names1);

    // 收集到Set集合(流只能用一次)
    Stream<String> zs2 = list.stream().filter(s -> s.startsWith("张"));
    Set<String> names2 = zs2.collect(Collectors.toSet());
    System.out.println(names2);

    // 收集到数组。
    Stream<String> zs3 = list.stream().filter(s -> s.startsWith("张"));
    Object[] array = zs3.toArray();
    System.out.println("内容：" + Arrays.toString(array));

    // 拓展
    // 收集到Map集合。
    List<Movie> movies1 = new ArrayList<>();
    movies1.add(new Movie("摔跤吧，爸爸", 9.5, "阿米尔汗"));
    movies1.add(new Movie("三傻宝莱坞", 8.5, "阿米尔汗2"));
    movies1.add(new Movie("三傻宝莱坞", 18.5, "阿米尔汗2"));
    movies1.add(new Movie("阿甘正传", 7.5, "汤姆汉克斯"));
    Map<String, Double> map =  movies1.stream().limit(3)
            .collect(Collectors.toMap(movie1 -> movie1.getName(), movie1 -> movie1.getScore(), (v1, v2) -> v1));

    System.out.println(map);
}