Map,HashMap,TreeMap,可变参数,不可变集合

目录

Map集合的获取功能

 Map集合的第一种遍历方式:通过键找值的方式

Map集合遍历的第二种方式:使用Entry对象遍历

HashMap的特点

HashMap集合概述和特点

HashMap集合应用案例

TreeMap 

TreeMap集合概述和特点

TreeMap集合应用案例

可变参数 

 创建不可变集合


Map集合的特点:
java.util.Map<k,v>集合
    1.Map集合是一个双列集合,一个元素包含两个值(一个key,一个value)键值。
    2.Map集合中的元素,key和value的数据类型可以相同,也可以不同
    3.Map集合中的元素,key是不允许重复的,value是可以重复的
    4.(键+值)这个整体称为“键值对”,或者“键值对对象”,在Java中叫“Entry对象”
    5.Map集合中的元素,key和value是一一对应

基本方法介绍

方法名说明
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 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("郭襄"));//null
        System.out.println(map.remove("xiaoo"));//null


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

Map集合的获取功能

  • 方法介绍

    方法名说明
    V get(Object key)根据键获取值
    Set<K> keySet()获取所有键的集合
    Collection<V> values()获取所有值的集合
    Set<Map.Entry<K,V>> entrySet()获取所有键值对对象的集合
   //创建集合对象
        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);//小龙女  黄蓉  赵敏
        }

 Map集合的第一种遍历方式:通过键找值的方式

Map集合中的方法:
     Set<K> keySet() 返回此映射中包含的键的 Set 视图。   此方法作用是把map中的所有键提取出来存在set集合中
实现步骤:
    1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
    2.遍历set集合,获取Map集合中的每一个key
    3.通过Map集合中的方法get(key),通过key找到value
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集合遍历的第二种方式:使用Entry对象遍历

    Map集合中的方法:
        Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。

    实现步骤:
        1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
        2.遍历Set集合,获取每一个Entry对象
        3.使用Entry对象中的方法getKey()getValue()获取键与值

Set里面存的是Map.Entry对象,而Entry对象里面存的是键值对泛型(K,V)

先遍历set集合,依次取出entry对象,在调用entry对象的getkey/value方法,获取键值。

通过entryset方法把键值对封装成一个对象(用一容器装载)存入set集合里面,通过遍历集合获得每一个entry对象(获得每一个容器),通过entry的getkey,getvalue方法获取里面的键,值(获取容器的内容)。

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是Map里面的一个实现类。
没有额外需要学习的特有方法,直接使用Map里面的方法就可以了

HashMap跟HashSet一样底层是哈希表结构的

HashMap集合概述和特点

  • HashMap底层是哈希表结构的

  • 依赖hashCode方法和equals方法保证键的唯一

  • 如果键要存储的是自定义对象,需要重写hashCode和equals方法

  • 如果键存的是String类型,不需要重写,java已经自定义好了

  • 哈希类在创建对象,往里面加值时候自动调动哈希表,hashcode  equals


HashMap集合应用案例

  • 案例需求

    • 创建一个HashMap集合,键是学生对象(Student),值是居住地 (String)。存储多个元素,并遍历。

    • 要求保证键的唯一性:如果学生对象的成员变量值相同,我们就认为是同一个对象

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

   XXX空参,全参构造,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;
    }
}
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);
        }
    }
}


TreeMap的特点
TreeMap是Map里面的一个实现类。
没有额外需要学习的特有方法,直接使用Map里面的方法就可以了TreeMap跟TreeSet一样底层是红黑树结构的

TreeMap 

TreeMap集合概述和特点

  • TreeMap底层是红黑树结构

  • 依赖自然排序或者比较器排序,对进行排序

  • 如果存储的是自定义对象,需要实现自定义类的Comparable接口或者在创建TreeMap对象时候给出比较器排序规则


TreeMap集合应用案例

  • 案例需求

    • 创建一个TreeMap集合,键是学生对象(Student),值是籍贯(String),学生属性姓名和年龄,按照年龄进行排序并遍历

    • 要求按照学生的年龄进行排序,如果年龄相同则按照姓名进行排序

public class Student implements Comparable<Student>{
    private String name;
    private int 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;
    }
}
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);
                }
        );
    }

可变参数 

使用前提:
    当方法的参数列表数据类型已经确定,但是参数的个数不确定,就可以使用可变参数.
使用格式:定义方法时使用
    修饰符 返回值类型 方法名(数据类型...变量名){}
可变参数的原理:
    可变参数底层就是一个数组,根据传递参数个数不同,会创建不同长度的数组,来存储这些参数
    传递的参数个数,可以是0个(不传递),1,2...多个

可变参数的注意事项

  • 这里的变量其实是一个数组

  • 如果一个方法有多个参数,包含可变参数,可变参数要放在最后

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

 创建不可变集合【长度不可变,内容不可变】

JDK9的新特性:
    List接口,Set接口,Map接口:里边增加了一个静态的方法of,方法的形参就是可变参数,可以给集合一次性添加多个元素。底层相当于是创建了一个集合,吧数据存入到集合中,但是这个集合不可以变化
  • 在List、Set、Map接口中,都存在of方法,可以创建一个不可变的集合

    • 这个集合不能添加,不能删除,不能修改

    • 但是可以结合集合的带参构造,实现集合的批量添加

  • Map接口中,还有一个ofEntries方法可以提高代码的阅读性

    • 首先会把键值对封装成一个Entry对象,再把这个Entry对象添加到集合当中

       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集合对象

方法的形参为可变参数,返回值是个不可变的集合】 

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的一个静态方法entry把其封装成entry对象】
【再把entry对象放入到map集合中】
        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);
    }
}

     解析: ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d")); 

ArrayList的构造方法

ArrayList(Collection<? extends E> c)

参数为传入collection的集合,而List.of 方法返回值也是List集合

作用:将List.of的不可变集合元素内容添加到ArrayList集合内 

  • 0
    点赞
  • 0
    收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:1024 设计师:我叫白小胖 返回首页
评论

打赏作者

奋斗的菜鸡LeeSivan

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值