集合Set与Map

集合Set与Map

HashSet

​ 底层结构：哈希表（数组+链表+红黑树） ------------->由HashMap维护

​ 优点：集数组，链表，红黑树为一体，所以综合能力较好，查询，增删效率较高

​ 缺点：实现了Set接口，所以无序

​ 应用场景：实现存储不同的数据，对查询，增删效率要求较高的时候建议使用HashSet

​ 无新增接口

​ 去重：在需要存储的自定义引用数据类型中重写hashcode与equals方法

具体使用简单代码如下：

class Main{
	public static void main(String[] args) {
        //创建HashSet
        HashSet<Person> hash = new HashSet<>();

        //存储Person对象
        hash.add(new Person("张三",18));
        hash.add(new Person("李四",17));
        hash.add(new Person("张三",18));

        System.out.println(hash);
        System.out.println(new Person("张三",18).hashCode());
        System.out.println(new Person("张三",18).hashCode());
    }
}
class Person{
    private String name;
    private int age;
    
    //省略构造器，set/get方法，toString方法
    //重写equals与hashCode
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        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);
    }
}

比较器

1. 内部比较器

又叫自然排序，是定义在类型内部的比较方式，实现了 java.lang.Comparable 接口

使用方法：实现Comparable接口,重写compareTo(T o)方法

方法内部指定比较规则：
compareTo 返回值 int 类型 T1.compareTo(T2) -> 0: 相等 整数:T1>T2 负数:T1<T2

优缺点：

优点: 默认比较方式,定义在类的内部

缺点: 固定,硬编码,不够灵活

代码：以上面的Person为例

class Person implements Comparable<Person>{
    ......
        ......
    //重写compareTo方法，以年龄为例
    public int compareTo(Student o) {
        return this.getAge.-o.getAge();
    }
}

2. 外部比较器

又叫订制排序，是一个定义在一个类型(要比较的对象数据的类型)的外部的比较方式

使用方法：实现 java.util.Comparator<T>接口,重写compare(T t1, T t2)

定义比较规则
返回值: 0: 相等 正数:T1>T2 负数:T1<T2

//三种方式
//1、定义一个实现接口的类
class Demo implements Comparator<Person>{
    @Override
    public int compare(Person o1, Person o2) {
        //return o2.getAge()-o1.getAge();		使用年龄比较
        return o1.getName().compareTo(o2.getName());		//使用姓名比较
    }
}
//2.使用匿名内部类方式  -------->  简化简化没有类本身作用的实现类
Comparator<Person> com = new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge()-o2.getAge();
    }
};
//3.使用Lmabda表达式
com = (x,y)->y.getAge()-x.getAge();

Arrays.sort(数组)

默认升序排序，

使用Arrays.sort(数组)比较自定义引用数据类型的数组

需要用到比较器才能进行比较

    public static void main(String[] args) {
        //数组
        Person[] arr = {
            new Person("zhangsan",18),
            new Person("lisa",16),
            new Person("wangwu",19),
            new Person("赵六",19)
        };

        System.out.println(Arrays.toString(arr));
        //使用默认比较规则   Person类中的compareTo方法
        Arrays.sort(arr);
        //使用参数2指定的外部比较规则
        Arrays.sort(arr, (t1,t2)->t1.getAge()-t2.getAge());
        System.out.println(Arrays.toString(arr));
    }

Map<k,v>

集合中的元素由键值对k-v组成
k(key): 可以为任意引用数据类型数据 --> Set 无序不可重复
v(value): 可以为任意引用数据类型数据 --> Collection 可重复无序
一个key只能对应一个value->映射关系
可以根据key操作value,Map的无序与去重 由key决定

Map集合的一些常用方法：

public static void main(String[] args) {
    //创建Map集合
    Map<Integer,String> map = new HashMap<>();
    //V put(K key, V value) 将指定的值与此映射中的指定键相关联（可选操作）。
    map.put(1001,"zhangsan");
    map.put(1002,"lisi");
    System.out.println(map.put(1003,"wangwu"));

    System.out.println(map);

    System.out.println(map.put(1002,"LISA"));
    System.out.println(map);
    //V get(Object key) 返回指定键映射到的值，如果此映射不包含键的映射，则返回 null 。
    System.out.println(map.get(1001));

    //boolean containsKey(Object key) 如果此映射包含指定键的映射，则返回 true 。
    //boolean containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true 。
    System.out.println(map.containsKey(1003));
    System.out.println(map.containsValue("zhangsan"));

    //V remove(Object key) 如果存在，则从该映射中移除键的映射（可选操作）。
    System.out.println(map.remove(1001));
    System.out.println(map);

}

Map集合的遍历方式

1. keySet 获取所有的key值,返回一个set集合
2. values() 获取map集合中所有键值对的value,返回一个Collection集合
3. entrySet() 获取所有的键值对->Map.Entry 类型->表示一个键值对

public static void main(String[] args) {
    //创建Map集合
    Map<Integer,String> map = new HashMap<>();
    map.put(1001,"zhangsan");
    map.put(1002,"lisi");
    map.put(1003,"wangwu");
    
	//1.keySet
    Set<Integer> keys= map.keySet();
    for(Integer i:keys){
        System.out.println(i+"-->"+map.get(i));
    }

    //2.values()
    Collection<String> col = map.values();
    for(String s:col){
        System.out.println(s);
    }

    //3)entrySet
    Set<Map.Entry<Integer,String>> set = map.entrySet();
    Iterator<Map.Entry<Integer,String>> it = set.iterator();
    for(;it.hasNext();){
        Map.Entry entry = it.next();
        System.out.println(entry.getKey()+"-->"+entry.getValue());
    }
}

HashMap

底层结构: 哈希表(数组+链表+红黑树)

特点: 查询,增删效率较高

新增内容: 没有新增功能

遍历方式: 与Map接口相同

扩容问题: 初始容量16,newCap = oldCap << 1 数组每次扩容原容量的两倍

​ DEFAULT_INITIAL_CAPACITY 初始容量 16

​ DEFAULT_LOAD_FACTOR : 默认加载因子 0.75

​ threshold : 扩容临界值 DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY