Day 20 Map集合

Map集合和Collection集合的区别

都是容器,能够存和取

Collection 集合的单列集合 ,里面的只能存储一种引用类型的元素

Map 集合双列集合Map<k,v> 一系列键值对元素,键必须唯一，值可以重复

Collection理解为 “光棍”
Map集合理解为"夫妻对"
Collection]的具体的子实现类TreeSet和HashSet都和Map有关系(TreeMap/HashMap)

遍历方式不同的
Collection有自己的迭代器
map集合:常用的方式,获取素有的键的集合,通过键找值;
举例
Map<String,String>
“杨过” ,“小龙女”
“郭靖” ,“黄蓉”
“陈玄风”,“梅超风”
“令狐冲”,"任盈盈

认识Map集合

要通过学号获取学生姓名?

•  Collection<Student> 这个Student的属性:学号,以及姓名,年龄,地址,就可以通过getXXX()来获取内容!
  

•  有的需求结构必须使用Map<K,V> 键值对,因为针对Key就是键有效(Key必须唯一的),跟值无关,键必须唯一 ,Value值可以重复
  

•  Map<Integer,Student>    K:Integer学号  V:Student 学生   Map本身就能够描述一个实体(就是描述事物的)
  

•  单独来存储学号,Value存储学生类型,Integer必须唯一
  

•          通过学号查询学生,通过学生就获取学生的基本信息
  

Map

Map的基本功能:

V put(K key, V value)

添加键值对,注意实现:如果键是第一次添加,返回值null;

如果键重复,后面的值将前面的值会覆盖掉,返回第一次键对应的值;

•      boolean containsKey(Object key):判断是否包含指定的键
  

•      boolean containsValue(Object value):判断是否包含指定的值
  

•      boolean isEmpty():判断集合是否为空,Map为空,true;否则,false
  

•      V remove(Object key)：删除Map中的键,返回该键对应的值
  

•      Collection<V> values():获取Map集合中的所有值的集合---是Collection,里面将所有的Value集中起来
  

•      void clear():清空map集合
  

HashMap

遍历1 获取所有键的Set类型集合

/**
 * @author 刘涛
 * @date 2022/8/22 15:57
 * 方式1:推荐的方式
 *  Map集合遍历
 *          获取Map集合中所有的键的集合,增强for遍历所有的键,通过键获取值
 *          Set<K> keySet()--->获取Map集合中所有的键的集合
 *          V get(Object key)------->通过键获取值
 */
public class MapDemo2 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>() ;

        //添加元素
        map.put("杨过","小龙女") ;
        map.put("郭靖","黄蓉") ;
        map.put("令狐冲","岳莹莹") ;
        map.put("陈玄风","梅超风") ;
        map.put("刘备","大乔") ;
        map.put("刘备","小乔") ;

        // Set<K> keySet()--->获取Map集合中所有的键的集合
        Set<String> set = map.keySet();
        //遍历所有的键
        for(String key:set){
            //V get(Object key)------->通过键获取值
            String value = map.get(key);
            System.out.println(key+"="+value);
        }

    }
}

遍历2 获取所有键值对的集合

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

/**
 * @author 刘涛
 * @date 2022/8/22 16:04
 *
 * Map集合遍历方式2:不推荐   获取所有的键值对象 Set<Map.Entry<K,V>> entrySet()
 *              Map.Entry<K,V>键值对象就有
 *                          K getKey():获取键
 *                          V getVvalue():获取值
 */
public class MapDemo3 {
    public static void main(String[] args) {
        //创建Map集合
        Map<String,String> map = new HashMap<>() ;

        //添加元素
        map.put("杨过","小龙女") ;
        map.put("郭靖","黄蓉") ;
        map.put("令狐冲","岳莹莹") ;
        map.put("陈玄风","梅超风") ;
        map.put("刘备","大乔") ;

        //获取所有的键值对象 Set<Map.Entry<K,V>> entrySet()----理解为"结婚证"
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历所有的键值对
        for(Map.Entry<String, String> en :entrySet){
            // K getKey():获取键
            String key = en.getKey();
            // V getVvalue():获取值
            String value = en.getValue();
            System.out.println(key+"="+value) ;
        }
    }
}

/**
 * @author 刘涛
 * @date 2022/8/22 17:00
 * HashMap<K,V>,如果是自定义类型,保证元素唯一,键必须唯一!
 * K--->Student类型
 * V--->学生的地址String
 *
 * 之前将HashSet的时候,的add方法依赖于HashMap的put方法---->间接依赖于Object的hashCode和equals()方法
 * 默认比的地址值是否相同,equals,如果存储K键是String类型,jdk提供的----已经重写了
 *
 * 而现在的键是自定义类型,Student类型必须重写equals和hashCode,才能保证键必须唯一!
 *
 * Map集合针对键有效,跟值无关,键必须唯一!(自定义类型,jdk提供的类型几乎重写过了equals和hashCode方法)
 */

TreeMap

1.自然排序

import sun.reflect.generics.tree.Tree;

import java.util.Set;
import java.util.TreeMap;

/**
 * @author 刘涛
 * @date 2022/8/22 17:14
 * TreeMap<K,V>集合也是Map集合的子实现类
 * TreeSet<E>集合依赖于TreeMap实现
 *
 * 包保证元素必须进行排序的,使用TreeMap<K,V>,如果是自定义类型,要保证唯一而且还要排序
 * 底层是一种红黑树结构;
 *
 * public TreeMap():自然排序,键的这个类型必须实现Comarepable接口
 *public TreeMap(Comparator<K> comparator):比较器排序,自定义一个类实现Comparator或者是使用接口匿名内部类
 */
public class TreeMapDemo {
    public static void main(String[] args) {
        //TreeMap<Student,String>: K:学生类型 ,V: 爱好 String类型
        //按照学生的年龄从小到大排序
        TreeMap<Student,String> tm = new TreeMap<>() ;//自然排序

        Student s1  = new Student("gaoyuanyuan",36) ;
        Student s2  = new Student("gaoyuanyuan",36) ;
        Student s3  = new Student("zhangjianing",36) ;
        Student s4  = new Student("zhangsan",20) ;
        Student s5  = new Student("wenzhang",19) ;
        Student s6  = new Student("wenzhang",25) ;
        Student s7  = new Student("mayili",43) ;
        Student s8  = new Student("yaodi",30) ;
        Student s9  = new Student("mayili",43) ;

        tm.put(s1,"演戏-律师") ;
        tm.put(s2,"演戏-杨桃") ;
        tm.put(s3,"演戏-电视剧唐砖") ;
        tm.put(s4,"踢足球") ;
        tm.put(s5,"撩妹") ;
        tm.put(s6,"演戏") ;
        tm.put(s7,"打篮球") ;
        tm.put(s8,"排球") ;
        tm.put(s9,"乒乓球") ;

        //获取所有的键的集合
        Set<Student> set = tm.keySet();
        for(Student s:set){
            //通过键获取值
            String value = tm.get(s);
            System.out.println(s.getName()+"---"+s.getAge()+"---"+value);
        }

    }
}

自定义类型实现 Compareable 接口

/**
 * @author 刘涛
 * @date 2022/8/22 17:03
 */

//完成自然排序
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 s) {
        按照学生的年龄从小到大排序
        int num = this.age - s.age ;
        //年龄相等,不一定是同一个人
        int num2 = (num==0)?this.name.compareTo(s.name):num ;
        return num2;
    }
}

2. 比较器排序

import java.util.Comparator;
import java.util.Set;
import java.util.TreeMap;

/**
 * @author 刘涛
 * @date 2022/8/22 17:14
 * TreeMap<K,V>集合也是Map集合的子实现类
 * TreeSet<E>集合依赖于TreeMap实现
 *
 * 包保证元素必须进行排序的,使用TreeMap<K,V>,如果是自定义类型,要保证唯一而且还要排序
 * 底层是一种红黑树结构;
 *
 * public TreeMap():自然排序,键的这个类型必须实现Comarepable接口
 *public TreeMap(Comparator<K> comparator):比较器排序,自定义一个类实现Comparator或者是使用接口匿名内部类
 */
public class TreeMapDemo {
    public static void main(String[] args) {
        //TreeMap<Student,String>: K:学生类型 ,V: 爱好 String类型
        //按照学生的年龄从小到大排序
        //接口匿名内部类的方式
        TreeMap<Student,String> tm = new TreeMap<>(new Comparator<Student>() {
            @Override
            public int compare(Student s1, Student s2) {
                //主要条件:按照年龄从大到小
                int num = s2.getAge()-s1.getAge() ;
                //年龄相等,比较姓名内容是否一致
                int num2 = (num==0)?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        }) ;//比较器排序

        Student s1  = new Student("gaoyuanyuan",36) ;
        Student s2  = new Student("gaoyuanyuan",36) ;
        Student s3  = new Student("zhangjianing",36) ;
        Student s4  = new Student("zhangsan",20) ;
        Student s5  = new Student("wenzhang",19) ;
        Student s6  = new Student("wenzhang",25) ;
        Student s7  = new Student("mayili",43) ;
        Student s8  = new Student("yaodi",30) ;
        Student s9  = new Student("mayili",43) ;

        tm.put(s1,"演戏-律师") ;
        tm.put(s2,"演戏-杨桃") ;
        tm.put(s3,"演戏-电视剧唐砖") ;
        tm.put(s4,"踢足球") ;
        tm.put(s5,"撩妹") ;
        tm.put(s6,"演戏") ;
        tm.put(s7,"打篮球") ;
        tm.put(s8,"排球") ;
        tm.put(s9,"乒乓球") ;

        //获取所有的键的集合
        Set<Student> set = tm.keySet();
        for(Student s:set){
            //通过键获取值
            String value = tm.get(s);
            System.out.println(s.getName()+"---"+s.getAge()+"---"+value);
        }

    }
}

/**
 * @author 刘涛
 * @date 2022/8/22 17:03
 */


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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Collections 工具

/**
 * Collections:是Jdk提供的针对集合操作的工具类
 * 里面的很多静态功能,排序,求最值等等
 * public static T max(Collection<T> coll):求集合中最大值
 * public static T min(Collection<T> coll):求集合中最小值
 * public static void shuffle(List<?> list):随机置换 (针对List集合打乱元素)
 * public static <T extends Comparable<? super T>> void sort(List<T> list):针对List集合自然排序
 * public static <T extends Comparable<? super T>> void      sort(List<T> list,Comparator<T> c):
 *              针对List集合比较器排序
 *
 *
 *              TreeSet集合人家本身就可以排序 取决构造方法
 *
 *              而List集合要进行自然排序或者比较器排序需要使用      * Collections.sort(list集合对象)

泛型的高级通配符（了解）

<?> :表示任意Java类型包含Object <? extends E>:向下限定:E类型及其他的子类 ,最起码和E类型保持一致 <? super E>:向上限定:E类型及其他的父类 class Animal{ } class Dog extends Animal{} //测试 Collection<?> c1 = new ArrayList() ;

Collection<?> c2 = new ArrayList() ; Collection<?> c3 = new ArrayList() ;

Collection<? extends Object> c4= new ArrayList() ;
Collection<? extends Object> c5= new ArrayList() ;
Collection<? extends Animal> c6= new ArrayList() ;
Collection<? extends Animal> c7= new ArrayList() ;
Collection<? super Dog> c7= new ArrayList() ;
Collection<? super Dog> c8= new ArrayList() ;

静态导入

静态导入,前提这个类方法的是静态,导入方法的级别

​ import static 包名.类名.静态方法名;

注意:

• 如果我们在使用静态导入的时候,导入方法级别,前提是自定义的方法名不能和它冲突,如果冲突,系统
• 不知道这个方法是自定义的还是jdk提供的这个类的方法,此时静态导入就不能用了,必须显示的指明是哪个类的方法

可变参数

当方法的形式参数有多个,可以使用… 表示多个参数

public static void main(String[] args) {

        //调用方法
        int sum = getSum(10, 12, 13, 15 );
        System.out.println(sum);

        System.out.println("--------------------------------------------------") ;
        printA(10,20,30,40,50,15);//可变参数

    }

    //明确4个参数,求和
    public static int getSum(int a,int b,int c,int d){
        return  a+ b+c+d ;
    }

    //定义多个数据求和,不明确参数有多少个,jdk5提供新特性 可变参数 ...
    public static void printA(int ... a){
            //此时可变参数a就相当于数组 里面存储很多数据
        for(int x = 0 ; x  < a.length ; x++){
            System.out.print(a[x]+"\t"); //\t 制表符,类似tab键 缩进
        }
        System.out.println();
    }

异常

/**
 * @author liutao
 * @date 2022/8/23 14:14
 * public final void join()  线程礼让!
 *                 throws InterruptedException
 *      等待该线程终止(等待某个线程结束,才能执行其他线程互相抢占cpu执行权)
 *      方法本身会抛出异常(中断异常),等会谁在调用这个方法可以抛throws(抛出到方法上)
 *      或者     捕获异常
 *      (jvm内存解析代码,如果异常信息和它处理的信息异常,它会创建异常对象,将异常信息打印在控制台上,展示日志)
 *              try{
 *                  //代码
 *              }catch(异常类名 变量名){
 *                  //处理异常,跟踪底层原码   变量名.printStackTrace():将信息打印
 *              }
 *
 *              开发中:使用捕获异常(业务逻辑层:捕获),自己写代码可以抛出异常 (给方法上抛throws)
 */

*** 集合重点**

Collection和Map区别

他们的遍历方式

Map的两种遍历方式对比

TreeSet集合存储自定义类型,如何实现自然排序和比较器排序

Map集合针对键有效,跟值无关,TreeMap<k,v>k如果是自定义类型,如何自然排序和比较器排序…