Java核心技术--------＞Collection集合体系（二）

前置知识：可变参数

可变参数

• 就是以中国特殊形参，定义在方法，构造器的形参列表里，格式是：（数据类型...可变参数名）

• //注意事项：一个形参列表中，只能有一个可变参数
  

• //可变形参必须放在形参列表的最后面

• import java.util.*;
  
  public class ColletionTest1 {
      public static void main(String[] args) {
          //特点：
          test(1,2,3,4,5);//可以传输多个数据
  
      }
  
      //注意事项：一个形参列表中，只能有一个可变参数
      //可变形参必须放在形参列表的最后面
      public static void test(int...args){
          //可变参数在方法内部，本身就是一个数组
          System.out.println(args.length);
          System.out.println(Arrays.toString(args));
      }
  
  
  }
  

---

Collections

• 是一个用来提供的常用静态方法

  import java.util.*;
  
  public class ColletionTest1 {
      public static void main(String[] args) {
          //addAll添加
          List<String> names = new ArrayList<>();
          Collections.addAll(names,"zhangsan","李四","王五","啊六");
          System.out.println(names);
  
          //sort排序
          List<Integer> list = new ArrayList<>();
          Collections.addAll(list,9,2,34,5,62,74,18,9);
          System.out.println(list);
          Collections.sort(list);
          System.out.println(list);
  
          //shuffle打乱
          Collections.shuffle(list);
          System.out.println(list);
      }
  
  
  }
  

  

---

综合案例：斗地主游戏

package CardGame;

public class card {
    private String number;
    private String color;
    //每张牌存在大小的
    private  int size;

    public card() {
    }

    public card(String number, String color, int size) {
        this.number = number;
        this.color = color;
        this.size = size;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    @Override
    public String toString() {
        return color + number;
    }
}

package CardGame;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Room {
    //有一副牌
    private List<card> allCard = new ArrayList<>();

    public Room(){
        //做出54张牌
        //点数：个数确定，类型确定
        String[] number = {"3","4","5","6","7","8","9","10","J","Q","K","A","2"};
        //花色：个数确定，类型确定 ♥, ♣,♦,♠
        String[] color = {"♠","♥","♣","♦"};
        //遍历点数，再遍历花色，组织牌
        int size = 0;
        for (String number1 : number) {
            //number = 3;
            size++;
            for (String color1 : color) {
                card c = new card(number1,color1,size);
                allCard.add(c);
            }
        }
        //单独存入大小王
        card c1 = new card("","Joker1",++size);
        card c2 = new card("", "Joker2",++size);
        Collections.addAll(allCard,c1,c2);
        System.out.println("新牌："+allCard);
    }

    public void start() {
        //1,洗牌
        Collections.shuffle(allCard);
        System.out.println("洗牌后："+allCard);

        //发牌，首先肯定要有定义一个玩家，用集合来代表玩家
        List<card> linhuchong = new ArrayList<>();
        List<card> jiumozhi = new ArrayList<>();
        List<card> renyingying = new ArrayList<>();

        //正式发牌，发出53张牌，剩余三张作为底牌
        for (int i = 0; i < allCard.size()-3; i++) {
            card c = allCard.get(i);
            //判断发牌给谁
            if (i % 3 == 0){
                linhuchong.add(c);
            } else if (i % 3 == 1) {
                jiumozhi.add(c);
            } else if (i % 3 == 2 ){
                renyingying.add(c);
            }
        }

        //对玩家的牌进行排序
        sortCard(linhuchong);
        sortCard(jiumozhi);
        sortCard(renyingying);
        //看牌
        System.out.println("阿聪>>>"+linhuchong);
        System.out.println("啊鸠>>>"+jiumozhi);
        System.out.println("盈盈>>>"+renyingying);
        List<card> lastThreeCard = allCard.subList(allCard.size()-3,allCard.size());
        System.out.println("底牌>>>"+lastThreeCard);
        jiumozhi.addAll(lastThreeCard);
        System.out.println("啊鸠抢到地主牌后>>>"+jiumozhi);
    }

    private void sortCard(List<card> cards) {
        Collections.sort(cards, new Comparator<card>() {
            @Override
            public int compare(card o1, card o2) {
                //return o1.getSize() - o2.getSize();//升序
                return o2.getSize() - o1.getSize();//降序
            }
        });
    }


}

package CardGame;

public class GameDeno {
    public static void main(String[] args) {
        //牌类
        //房间
        Room m = new Room();
        m.start();
    }
}

---

Map集合

概述：

• 双列集合，（key1 = value1），一次需要存入一堆数据为一个元素
• Map集合的每个元素”key = value“称为一个键值对/简直对象，Map集合也被叫做”键值对集合
• Map集合的所有键是不允许重复的，但值是可以重复的，键和值是一一对应的，每一个健只能找到自己相对应的值
• map集合在什么业务场景下使用：
  • 商品1 = 2；商品2 = 4；购物车（需要存入一一对应的数据时，就可以考虑使用map集合来做）
• Map集合体系：
  • 
• Map集合体系的特点：
  • 注意：Map系列集合的特点都是由键决定的，值知识一个附属品，值是不做要求的
  • HashMap（由键决定的特点）：无序，不重复，无索引（用的最多）
  • LinkedHashMap:（由键决定特点）：有序，不重复，无索引
  • TreeMap（由键决定特点）:按照大小默认升序排序，不重复，无索引

  • import java.util.HashMap;
    import java.util.Map;
    import java.util.TreeMap;
    
    public class MapTest1 {
        public static void main(String[] args) {
            Map<String,Integer> map = new HashMap<>();//有序，不重复，无索引
            map.put("手表",100);
            map.put("手表",200);//后面重复的数据会覆盖前面的数据（键）
            map.put("手机",400);
            map.put("java",10);
            map.put(null,null);
            System.out.println(map);
    
            Map<Integer,String>  Map1 = new TreeMap<>();//可排序，不重复，无索引
            Map1.put(23,"java");
            Map1.put(23,"mysql");
            Map1.put(21,"李四");
            Map1.put(22,"王五");
            System.out.println(Map1);
    
        }
    }
    

常用方法：

import java.util.*;

public class MapTest1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();//有序，不重复，无索引
        map.put("手表",100);
        map.put("手表",200);//后面重复的数据会覆盖前面的数据（键）
        map.put("手机",400);
        map.put("java",10);
        map.put(null,null);
        System.out.println(map);

        Map<Integer,String>  Map1 = new TreeMap<>();//可排序，不重复，无索引
        Map1.put(23,"java");
        Map1.put(23,"mysql");
        Map1.put(21,"李四");
        Map1.put(22,"王五");
        System.out.println(Map1);

        //获取集合的大小
        System.out.println(map.size());
        //清空集合
        map.clear();
        System.out.println(map);
        //判断集合是否为空
        System.out.println(map.isEmpty());
        //获取键对应的值
        System.out.println(Map1.get(21));
        System.out.println(Map1.get(200));//没有这个键返回null
        //根据键删除对应的值，返回这个值
        System.out.println(Map1.remove(21));
        System.out.println(Map1);
        //判断是否包含某个键
        System.out.println(Map1.containsKey(21));
        System.out.println(Map1.containsKey(23));
        //判断是否包含某个值
        System.out.println(Map1.containsValue("王五"));
        //获取map全部的键
        Set<Integer> keys = Map1.keySet();
        System.out.println(keys);
        //获取map全部的值
        Collection<String> values = Map1.values();
        System.out.println(values);
        //把其他map集合的数据导入自己的集合中来
        Map<String,Integer> map3 = new HashMap<>();
        map3.put("a",30);
        map3.put("b",40);
        map3.put("c",50);
        Map<String,Integer> map4 = new HashMap<>();
        map4.put("d",60);
        map4.put("e",70);
        System.out.println(map4);
        map4.putAll(map3);
        System.out.println(map3);
        System.out.println(map4);



    }
}

遍历方式：

1、键找值：

import java.util.*;

public class MapTest1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();//有序，不重复，无索引
        map.put("手表",100);
        map.put("手表",200);//后面重复的数据会覆盖前面的数据（键）
        map.put("手机",400);
        map.put("java",10);
        map.put("python",20);
        System.out.println(map);
        Set<String> keys = map.keySet();
        for (String key : keys) {
            int value = map.get(key);
            System.out.println(key+"--->"+value);
        }




    }
}

2、键值对

import java.util.*;

public class MapTest1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();//有序，不重复，无索引
        map.put("手表",100);
        map.put("手表",200);//后面重复的数据会覆盖前面的数据（键）
        map.put("手机",400);
        map.put("java",10);
        map.put("python",20);
        System.out.println(map);
        Set<Map.Entry<String,Integer>> entries = map.entrySet();
        for (Map.Entry<String, Integer> entry : entries) {
            String key = entry.getKey();
            int value = entry.getValue();
            System.out.println(key+"-->"+value);

        }


    }
}

3、lambda

import java.util.*;

public class MapTest1 {
    public static void main(String[] args) {
        Map<String,Integer> map = new HashMap<>();//有序，不重复，无索引
        map.put("手表",100);
        map.put("手表",200);//后面重复的数据会覆盖前面的数据（键）
        map.put("手机",400);
        map.put("java",10);
        map.put("python",20);
        System.out.println(map);
        map.forEach((k,v)->{
            System.out.println(k+"-->"+v);
        });


    }
}

HashMap：无序，不重复，无索引

底层原理：

• HashMap跟HashSet的底层原理是一摸一样，都是基于哈希表实现的
• 实际上：原来学的set系列集合的底层就是基于map实现的，知识set集合中的元素只要键数据，不要值数据而已

LinkedHashMap:有序，不重复，无索引

底层原理：

• 底层数据结构依然是基于哈希表实现的，只是每个键值对元素又额外的多了一个双链表的机制记录元素顺序（保证有序）
• 实际上：原理啊学习的linkedhashset集合的底层原理就是LinkedHashMap

TreeMap:不重复，无索引（默认升序排序，只对键排序）

底层原理：

• TreeMap和TreeSet集合的底层原理是一样的，都是 基于红黑树实现的排序
• 

补充知识：集合嵌套：

集合的嵌套是什么：指的是集合中的元素有事一个集合

Map集合案例-省和市：

package text02;

import java.util.*;

public class Test {
    public static void main(String[] args) {
        //1、定义一个map集合存储全部的省份的信息，和其对应的城市信息
        Map<String,List<String>> map = new HashMap<>();
        List<String> cities1 = new ArrayList<>();
        Collections.addAll(cities1,"南京市","扬州市","苏州市");
        map.put("江苏省",cities1);

        List<String> cities2 = new ArrayList<>();
        Collections.addAll(cities2,"武汉市","孝感市","十堰市");
        map.put("湖北省",cities2);

        List<String> cities3 = new ArrayList<>();
        Collections.addAll(cities3,"石家庄市","唐山市","邢台市");
        map.put("河北省",cities3);


        List<String> c3 = map.get("河北省");
        for (String s : c3) {
            System.out.print(s+"\t");
        }

        List<String> c1 = map.get("江苏省");
        for (String s : c1) {
            System.out.print(s+"\t");
        }

        List<String> c2 = map.get("湖北省");
        for (String s : c2) {
            System.out.print(s+"\t");
        }

        System.out.println();
        map.forEach((p,c)->{
            System.out.println(p+"-->"+c);
        });


    }
}

---

stream流

stream是什么？

• 也叫Stream流，是jdk8开始增的一套API（Java.util.stream.）,可以用于操作集合或数组的数据。
• 优势：stream流的大量结合了lambda的语法风格来编程，提供了一种更加强大，更加简单的方式操作集合或则数组中的数据，代码简洁，可读性更高

案例：

package text02;

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

public class Test {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"z","g","p");
        System.out.println(names);

        //将上面每个元素添加高一个新集合去
        List<String> list = new ArrayList<>();
        for (String name : names) {
            if (name.startsWith("z") && name.length() == 1){
                list.add(name);
            }
        }
        System.out.println(list);



        //stream
        List<String> list2 = names.stream().filter(s ->s.startsWith("g"))
                .filter(a -> a.length()==1).collect(Collectors.toList());
        System.out.println(list2);
    }
}

Stream流的使用步骤：

1、获取Stream流：

package text02;

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

public class Test {
    public static void main(String[] args) {
        //1、如何让获取list集合的stream流
        List<String> names = new ArrayList<>();
        Collections.addAll(names,"张三丰","的马四月","李白","李太白");
        Stream<String> stream = names.stream();

        //2、如何获取set集合的stream流
        Set<String> set = new HashSet<>();
        Collections.addAll(set,"张三丰","的马四月","李白","李太白");
        Stream<String> stream1 = set.stream();
        stream1.filter(s -> s.contains("的")).forEach(s-> System.out.println(s));

        //3、如何获取map集合的Stream流
        Map<String,Double> map = new HashMap<>();
        map.put("古力娜扎",172.3);
        map.put("吃力热巴",168.8);
        map.put("马儿咋哈",160.9);
        map.put("卡尔砸吧",175.3);

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

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

        Set<Map.Entry<String,Double>> entires = map.entrySet();
        Stream<Map.Entry<String,Double>> kvs = entires.stream();
        kvs.filter(e-> e.getKey().contains("巴"))
                .forEach(e -> System.out.println(e.getKey()+"-->"+e.getValue()));

        //4、如何获取数组的stream流
        String[] names2 = {"张三丰","的马四月","李白","李太白"};
        Stream<String> s1 = Arrays.stream(names2);
        Stream<String> s2 = Stream.of(names2);
        

    }
}

2、stream流调用中间方法

package text02;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Objects;

public class test01 {
    public static void main(String[] args) {
        List<Double> scores = new ArrayList<>();
        Collections.addAll(scores,88.5, 68.0, 9.5, 99.6,100.0);
        //需求1：找出成绩大于60分的数据，升序排序，再输出
        scores.stream().filter(s -> s>=60).sorted().forEach(s-> System.out.println(s));
        System.out.println("------------------------------");


        List<Student> students = new ArrayList<>();
        Student s1 = new Student("蜘蛛精",26,172.5);
        Student s2 = new Student("蜘蛛精",26,172.5);
        Student s3 = new Student("紫霞",23,167.5);
        Student s4 = new Student("白品品",25,172.5);
        Student s5 = new Student("牛魔王",35,182.2);
        Student s6 = new Student("牛夫人",34,168.5);
        Collections.addAll(students,s1,s2,s3,s4,s5,s6);
        //需求2： 找出年龄大于等于23，且年龄小于30的学生，并按照降序输出
        students.stream().filter(s -> s.getAge() >= 23 && s.getAge()<=30)
                .sorted((o1, o2) -> o2.getAge() - o1.getAge())
                .forEach(s -> System.out.println(s));
        System.out.println("------------------------------");



        //需求3、取出身高最高的前三名学生，并输出
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                .limit(3).forEach(System.out::println);
        System.out.println("------------------------------");

        //需求4、取出身高倒数的两名学生，并输出
        students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
                .skip(students.size() -2).forEach(System.out::println);
        System.out.println("------------------------------");


        //需求5、找出身高超过168的学生叫什么名字，要求取出重复的名字并输出
        students.stream().filter(s -> s.getHeight()>168).map(Student::getName)
                .distinct().forEach(s -> System.out.println(s));
        students.stream().filter(s -> s.getHeight()>168)
                .forEach(student -> System.out.println(student));
        System.out.println("------------------------------");

        //distinct去重复，自定义类型的对象（希望内容一样就认为重复，重写）
        students.stream().filter(student -> student.getHeight()>168)
                .distinct().forEach(System.out::println);

        
    }
}

3、stream流的常见终结方法

• 中介方法是指调用完成后，不会返回新stream了，没法继续使用流了。

• 收集stream流：就是把stream流操作偶的结果转会到集合或则数组中去返回
• stream：方便操作集合或数组的手段；集合/数组：才是开发中的目的。
• 

• package text02;
  
  import java.util.*;
  import java.util.stream.Collectors;
  
  public class test01 {
      public static void main(String[] args) {
  
          List<Student> students = new ArrayList<>();
          Student s1 = new Student("蜘蛛精",26,172.5);
          Student s2 = new Student("蜘蛛精",26,172.5);
          Student s3 = new Student("紫霞",23,167.5);
          Student s4 = new Student("白品品",25,172.5);
          Student s5 = new Student("牛魔王",35,182.2);
          Student s6 = new Student("牛夫人",34,168.5);
          Collections.addAll(students,s1,s2,s3,s4,s5,s6);
          //1、需求1：请计算身高超过168有几个人
          long size = students.stream().filter(s -> s.getHeight()>168).count();
          System.out.println(size);
  
          //2、找出射高最高的学生对象并输出
          Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
          System.out.println(s);
  
          //3、找出身高最矮的学生对象，并输出
          Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
          System.out.println(ss);
  
          //需求4、请找出射高超过170的学生对象，并防盗一个新的集合中取返回
          List<Student> students1 = students.stream().filter(a -> a.getHeight()>170).collect(Collectors.toList());
          System.out.println(students1);
  
          Set<Student> students2 = students.stream().filter(a -> a.getHeight()>170).collect(Collectors.toSet());
          System.out.println(students2);
  
          //需求5、请找出身高超过170学生对象，并把学生对象的名字和身高，存入一个map集合返回
          Map<String, Double> map =
                  students.stream().filter(a -> a.getHeight() > 170)
                          .distinct().collect(Collectors.toMap(Student::getName, Student::getHeight));
          System.out.println(map);
  
  
  
      }
  }