【Java SE】9.Java集合（下）

📘博客主页：程序员葵安

💻︎素材来源：黑马程序员JAVA课堂

🫶感谢大家点赞👍🏻收藏⭐评论✍🏻

                文章目录

一、 Map集合

1.1 Map集合概述和特点

1.2 Map集合的常见API

1.3 Map集合的遍历

二、HashMap集合

2.1 HashMap集合概述和特点

2.2 HashMap集合应用

三、LinkedHashMap

四、TreeMap

4.1 TreeMap集合概述和特点

4.2 TreeMap集合应用

五、可变参数

六、Collections集合工具类

---

一、 Map集合

1.1 Map集合概述和特点

概述：

interface Map<K,V>  K：键的类型；V：值的类型

特点：

• 双列集合,一个键对应一个值
• 键不可以重复,值可以重复

创建：

Map<K,V> map = new HashMap<K,V>();

1.2 Map集合的常见API

方法名	说明
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;

public class MapDemo1 {
    public static void main(String[] args) {

        //put方法
        System.out.println("put方法：");
        //创建Map对象
        Map<String,String> m = new HashMap<>();
        //添加元素
        String value1 = m.put("郭靖","黄蓉");
        System.out.println(value1);
        m.put("韦小宝","沐剑屏");
        m.put("伊志平","小龙女");

        String value2 = m.put("韦小宝","双儿");
        System.out.println(value2);
        //打印输出
        System.out.println(m);
        //put细节
        //添加/覆盖
        //添加数据，如果键不存在，直接把键对象添加到Map集合中，方法返回null
        //添加数据，如果键已经存在，会覆盖键对应的值，方法返回被覆盖的值

        System.out.println();

        //remove删除方法
        System.out.println("remove方法：");
        String result = m.remove("郭靖");
        System.out.println(result);
        System.out.println(m);

        System.out.println();

        //clear清空方法
        //m.clear();

        //containsKey判断是否包含
        System.out.println("containsKey方法：");
        boolean keyResult1 = m.containsKey("韦小宝");
        System.out.println(keyResult1);
        boolean keyResult2 = m.containsKey("郭靖");
        System.out.println(keyResult2);
        System.out.println(m);

        System.out.println();

        //containsValue判断是否包含
        System.out.println("containsValue方法：");
        boolean valueResult1 = m.containsValue("小龙女");
        System.out.println(valueResult1);
        boolean valueResult2 = m.containsValue("黄蓉");
        System.out.println(valueResult2);
        System.out.println(m);

        System.out.println();

        //isEmpty判断是否为空
        System.out.println("isEmpty方法：");
        boolean emptyResult = m.isEmpty();
        System.out.println(emptyResult);
        System.out.println(m);

        System.out.println();
        
        //size方法
        System.out.println("size方法：");
        int sizeResult = m.size();
        System.out.println(sizeResult);
        System.out.println(m);
    }
}

1.3 Map集合的遍历

方法1：键找值

代码示例：

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

  public class MapDemo2 {
      public static void main(String[] args) {
          //创建集合对象
          Map<String, String> map = new HashMap<String, String>();
  
          //添加元素
          map.put("张无忌", "赵敏");
          map.put("郭靖", "黄蓉");
          map.put("杨过", "小龙女");
  
          //获取所有键的集合。用keySet()方法实现
          Set<String> keySet = map.keySet();
          //遍历键的集合，获取到每一个键。用增强for实现
          for (String key : keySet) {
              //根据键去找值。用get(Object key)方法实现
              String value = map.get(key);
              System.out.println(key + "," + value);
          }
      }
  }

方法2：键值对

public class MapDemo3 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //获取所有键值对对象的集合
        Set<Map.Entry<String, String>> entrySet = map.entrySet();
        //遍历键值对对象的集合，得到每一个键值对对象
        for (Map.Entry<String, String> me : entrySet) {
            //根据键值对对象获取键和值
            String key = me.getKey();
            String value = me.getValue();
            System.out.println(key + "," + value);
        }
    }
}

方法3：Lambda表达式

import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;

public class MapDemo4 {
    public static void main(String[] args) {
        //创建集合对象
        Map<String, String> map = new HashMap<String, String>();

        //添加元素
        map.put("张无忌", "赵敏");
        map.put("郭靖", "黄蓉");
        map.put("杨过", "小龙女");

        //匿名内部类
        map.forEach(new BiConsumer<String, String>() {
            @Override
            public void accept(String key, String value) {
                System.out.println(key + "," + value);
            }
        });
        System.out.println();
        //lambda简化
        map.forEach((key, value) -> System.out.println(key + "," + value));
    }
}

二、HashMap集合

2.1 HashMap集合概述和特点

• HashMap底层是哈希表结构的
• 依赖hashCode方法和equals方法保证键的唯一
• 如果键要存储的是自定义对象，需要重写hashCode和equals方法

2.2 HashMap集合应用

需求：

• 创建一个HashMap集合，键是学生对象(Student)，值是居住地 (String)。存储多个元素，并遍历。
• 要求保证键的唯一性：如果学生对象的成员变量值相同，我们就认为是同一个对象

代码示例：

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

public class HashMapDemo {
    public static void main(String[] args) {
        //创建HashMap对象
        HashMap<Student, String> hm = new HashMap<>();

        //创建3个学生对象
        Student s1 = new Student("张三", 23);
        Student s2 = new Student("李四", 24);
        Student s3 = new Student("王五", 25);

        //添加元素
        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.getName()+" "+key.getAge()+" "+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.getName()+" "+key.getAge()+" "+value);
        }

        System.out.println();

        //lambda表达式
        hm.forEach((key,value) -> System.out.println(key.getName() + " " + key.getAge() + " " +value));

    }
}


public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}

三、LinkedHashMap

由键决定：有序、不重复、无索引

原理：哈希表+双链表

代码示例：

import java.util.LinkedHashMap;

public class LinkedHashMapDemo{
    public static void main(String[] args) {
        //创建集合
        LinkedHashMap<String,Integer> lhm = new LinkedHashMap<>();

        //添加元素
        lhm.put("c", 789);
        lhm.put("b", 456);
        lhm.put("a", 123);
        lhm.put("d", 111);

        //打印集合
        System.out.println(lhm);
    }
}

四、TreeMap

4.1 TreeMap集合概述和特点

• TreeMap底层是红黑树结构
• 依赖自然排序或者比较器排序,对键进行排序（默认从小到大）
• 如果键存储的是自定义对象,需要实现Comparable接口或者在创建TreeMap对象时候给出Comparator比较器排序规则

4.2 TreeMap集合应用

需求：

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

代码示例：

import java.util.TreeMap;

public class TreeMapDemo {
    public static void main(String[] args) {
        //创建集合
        TreeMap<Student,String> tm = new TreeMap<>();

        //创建三个学生对象
        Student s1 = new Student("zhangsan", 23);
        Student s2 = new Student("lisi", 24);
        Student s3 = new Student("abo", 24);
        Student s4 = new Student("wangwu", 25);

        //添加元素
        tm.put(s1, "江苏");
        tm.put(s2, "天津");
        tm.put(s3, "北京");
        tm.put(s4, "上海");

        System.out.println(tm);
    }
}

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

    /**
     * 获取
     * @return name
     */
    public String getName() {
        return name;
    }

    /**
     * 设置
     * @param name
     */
    public void setName(String name) {
        this.name = name;
    }

    /**
     * 获取
     * @return age
     */
    public int getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }

    @Override
    public int compareTo(Student o) {
        int i = this.getAge() - o.getAge();
        i = i == 0 ? this.getName().compareTo(o.getName()) : i;
        return i;
    }
}

五、可变参数

本质上是一个数组

作用：在形参中接收多个数据

格式：数据类型...参数名称

注意：

• 形参最多只能写一个可变参数
• 如果除了可变参数还有其他形参，可变参数写最后

代码示例：

import java.util.ArrayList;
import java.util.Collections;

public class Test {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list = new ArrayList<>();
        //批量添加元素
        Collections.addAll(list,"张三","李四","王五","赵六");
        //打印集合
        System.out.println(list);

        //shuffle打乱
        Collections.shuffle(list);
        System.out.println(list);
    }
}

六、Collections集合工具类

常用API

public static <T> boolean addAll(Collection<T> c, T... element) 批量添加元素

public static void shuffle(List<?> list) 打乱List集合元素的顺序

 代码示例：

public class Test {
    public static void main(String[] args) {
        int sum = getSum(1,2,3,4,5);
        System.out.println(sum);
    }

    public static int getSum(int...args){
        int sum = 0;
        for(int i : args){
            sum += i;
        }
        return sum;
    }
}

其他API 

 public static <T> void sort(List<T> list) 排序

        public static <T> void sort(List<T> list, Comparator<T> c) 根据指定的规则进行排序

        public static <T> int binarySearch (List<T> list,  T key) 以二分查找法查找元素

        public static <T> void copy(List<T> dest, List<T> src) 拷贝集合中的元素

        public static <T> int fill (List<T> list,  T obj) 使用指定的元素填充集合

        public static <T> void max/min(Collection<T> coll) 根据默认的自然排序获取最大/小值

        public static <T> void swap(List<?> list, int i, int j) 交换集合中指定位置的元素

代码示例：

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

public class CollectionsDemo2 {
    public static void main(String[] args) {
        System.out.println("-------------sort默认规则--------------------------");
        //默认规则，需要重写Comparable接口compareTo方法。Integer已经实现，按照从小到大的顺序排列
        //如果是自定义对象，需要自己指定规则
        ArrayList<Integer> list1 = new ArrayList<>();
        Collections.addAll(list1, 10, 1, 2, 4, 8, 5, 9, 6, 7, 3);
        Collections.sort(list1);
        System.out.println(list1);


        System.out.println("-------------sort自己指定规则规则--------------------------");
        Collections.sort(list1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list1);

        Collections.sort(list1, (o1, o2) -> o2 - o1);
        System.out.println(list1);

        System.out.println("-------------binarySearch--------------------------");
        //需要元素有序
        ArrayList<Integer> list2 = new ArrayList<>();
        Collections.addAll(list2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(Collections.binarySearch(list2, 9));
        System.out.println(Collections.binarySearch(list2, 1));
        System.out.println(Collections.binarySearch(list2, 20));

        System.out.println("-------------copy--------------------------");
        //把list3中的元素拷贝到list4中
        //会覆盖原来的元素
        //注意点：如果list3的长度 > list4的长度，方法会报错
        ArrayList<Integer> list3 = new ArrayList<>();
        ArrayList<Integer> list4 = new ArrayList<>();
        Collections.addAll(list3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.addAll(list4, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
        Collections.copy(list4, list3);
        System.out.println(list3);
        System.out.println(list4);

        System.out.println("-------------fill--------------------------");
        //把集合中现有的所有数据，都修改为指定数据
        ArrayList<Integer> list5 = new ArrayList<>();
        Collections.addAll(list5, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        Collections.fill(list5, 100);
        System.out.println(list5);

        System.out.println("-------------max/min--------------------------");
        //求最大值或者最小值
        ArrayList<Integer> list6 = new ArrayList<>();
        Collections.addAll(list6, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(Collections.max(list6));
        System.out.println(Collections.min(list6));

        System.out.println("-------------max/min指定规则--------------------------");
        // String中默认是按照字母的abcdefg顺序进行排列的
        // 现在我要求最长的字符串
        // 默认的规则无法满足，可以自己指定规则
        // 求指定规则的最大值或者最小值
        ArrayList<String> list7 = new ArrayList<>();
        Collections.addAll(list7, "a","aa","aaa","aaaa");
        System.out.println(Collections.max(list7, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        }));

        System.out.println("-------------swap--------------------------");
        ArrayList<Integer> list8 = new ArrayList<>();
        Collections.addAll(list8, 1, 2, 3);
        Collections.swap(list8,0,2);
        System.out.println(list8);
    }
}