Day15 集合（二）

Set简介

定义

public interface Set<E> extends Collection<E> {}

Set是一个继承于Collection的接口，即Set也是集合中的一种。Set是没有重复元素的集合。

SotedSet

接口，排序，自然升序排序的

public static void main(String[] args) {
        // SortedSet
        SortedSet<String> set = new TreeSet<>();
        set.add("cc");
        set.add("aa");
        set.add("bb");
        System.out.println(set);// [aa, bb, cc]
        System.out.println(set.first());//aa
        System.out.println(set.last());//cc
        System.out.println(set.subSet("aa", "cc"));//[aa, bb]
    }

HashSet

哈希表

调用hashCode()

​       equals()判断

顺序:先调用hashCode()算出值，如果hashCode()的值相同了，进一步调用equals()判断是否相同。相同不存储，不相同可以进行链式存储。

import java.util.HashSet;
import java.util.Set;
class Person{
    private int no;
    private String name;
    public Person(int no, String name) {
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return no+","+name;
    }
    @Override
    public int hashCode() {
        return name.hashCode()+no;
    }
    @Override
    public boolean equals(Object obj) {
        //this   
        //obj
        Person per = (Person)obj;
        return this.no == per.no && this.name.equals(per.name) ? true :false;
    }
    
}
public class TestSet1 {
    public static void main(String[] args) {
        Set<Person> set = new HashSet<>(); 
        Person guo = new Person(11, "xiaoguo");
        Person huang = new Person(11,"xiaoguo");
        Person yang = new Person(22,"xiaoyang");
        set.add(guo);
        set.add(huang);
        set.add(yang);
        set.forEach(System.out::println);
        
        //Set 
/*        Set<String> set = new HashSet<>();
        set.add("aa");
        set.add("bb");
        set.add("cc");
//        set.forEach(System.out::println);
        set.add("aa");
        set.forEach(System.out::println);*/

    }

}

TreeSet

import java.util.NavigableSet;
import java.util.TreeSet;

public class TestSet4 {

    public static void main(String[] args) {
        // NavigableSet
        NavigableSet<Double> set = new TreeSet<>((d1,d2)->(int)(d2-d1));
        set.add(34.5);
        set.add(56.34);
        set.add(67.2);
        System.out.println(set);
        // 小于等于 指定参数 的最大 元素
        System.out.println(set.floor(58.9));
        //大于等于 指定参数 的 最小元素
        System.out.println(set.ceiling(58.9));
        //降序排列的集合
        set.descendingSet().forEach(System.out::println);
        //返回 降序的迭代器
        set.descendingIterator().forEachRemaining(System.out::println);
        //删除 第一元素
        set.pollFirst();
        System.out.println(set);
        set.pollLast();
        System.out.println(set);
    }

}

HashSet、LinkedHashSet和TreeSet的区别

HashSet：哈希表，数据唯一，重写hashCode()和equals()方法，效率最高

LinkedHashSet：链表和哈希表，元素有序，按照元素插入的顺序排序的

TreeSet：二叉树，默认是自然升序排序的，也可以自己制定顺序

Map接口

定义

public interface Map<K,V> { }

Map 是一个键值对(key-value)映射接口。Map映射中不能包含重复的键；每个键最多只能映射到一个值。
Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。
Map 映射顺序。有些实现类，可以明确保证其顺序，如 TreeMap；另一些映射实现则不保证顺序，如 HashMap 类。
Map 的实现类应该提供2个“标准的”构造方法：第一个，void（无参数）构造方法，用于创建空映射；第二个，带有单个 Map 类型参数的构造方法，用于创建一个与其参数具有相同键-值映射关系的新映射。实际上，后一个构造方法允许用户复制任意映射，生成所需类的一个等价映射。尽管无法强制执行此建议（因为接口不能包含构造方法），但是 JDK 中所有通用的映射实现都遵从它。

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

public class TestMap1 {

    public static void main(String[] args) {
        // Map
        Map<Integer,String> map = new HashMap<>();
        //键唯一
        map.put(1, "aa");
        map.put(2, "bb");
        map.put(3, "cc");
        System.out.println(map);
        //集合 中键值对个数
        System.out.println(map.size());
        //
        System.out.println(map.isEmpty());//false
        //判断键 是否存在
        System.out.println(map.containsKey(1));
        //判断值 是否存在
        System.out.println(map.containsValue("cc"));
        //按照键移除 键值对
//        map.remove(2);
        map.remove(1, "aa");
        System.out.println(map);
        //键的集合  Set类型
        System.out.println(map.keySet());
        //值得集合 Collection
        System.out.println(map.values());
        //
//        map.clear();
//        System.out.println(map.isEmpty());
        System.out.println(map);
        map.put(2, null);
        map.put(null, null);
        System.out.println(map);
    }

}

遍历

import java.util.Hashtable;
import java.util.Map;

public class TestMap2 {

    public static void main(String[] args) {
        // Map  遍历
        Map<Integer,String> map = new Hashtable<>();
//        Map<Integer,String> map = new HashMap<>();
        //键唯一
        map.put(1, "aa");
        map.put(2, "bb");
        map.put(3, "cc");
        //1.单独遍历
        map.keySet().forEach(System.out::println);
        map.values().forEach(System.out::println);
        //2 整体遍历 ，遍历键值
        map.forEach((k,v)->System.out.println(k+","+v));
        //3
        //获得键值对集合
        map.entrySet().forEach(System.out::println);
        //4.迭代器遍历
        map.entrySet().iterator().forEachRemaining(System.out::println);
        map.entrySet().iterator().forEachRemaining(e->System.out.println(e.getKey()+","+e.getValue()));
    }

}

说明：
(01) Map提供接口分别用于返回 键集、值集或键-值映射关系集。
        entrySet()用于返回键-值集的Set集合
        keySet()用于返回键集的Set集合
       values()用户返回值集的Collection集合
       因为Map中不能包含重复的键；每个键最多只能映射到一个值。所以，键-值集、键集都是Set，值集时Collection。

(02) Map提供了“键-值对”、“根据键获取值”、“删除键”、“获取容量大小”等方法。

HashMap、Hashtable、LinkedHashMap和TreeMap的区别

HashMap：空键值对

Hashtable：线程安全的。少用

LinkedHashMap：按照插入的顺序

TreeMap：键 按照自然排序

效率：HashMap > LinkedHashMap > TreeMap

Queue接口

方法

队列：是一组操作受限的线性表，只能在对尾增加，在对头删除，先进先出。

双端队列

栈的方法

push、pop

public class TestDeque1 {

    public static void main(String[] args) {
        // Deque双端队列
        //模拟队列
        Deque<String> d = new ArrayDeque<>(); 
/*        d.add("aa");
        d.addLast("bb");
        d.addLast("cc");
        while(d.size() > 0) {
//            System.out.println(d.poll());
            System.out.println(d.pollFirst());
        }*/
        //模拟栈
/*        d.addFirst("aa");
        d.addFirst("bb");
        d.addFirst("cc");
        while(d.size() > 0 ) {
            System.out.println(d.pollFirst());
        }*/
        //使用栈的方法
        d.push("aa");
        d.push("bb");
        d.push("cc");
        while(d.size() > 0) {
            System.out.println(d.pop());
        }
    
    }

}

实现类

ArrayDeque、LinkedList(栈)

public class TestDeque2 {
    public static void main(String[] args) {
        // 银行排队
        Person1 zhangsan = new Person1("张三");
        Person1 guojing = new Person1("郭靖");
        Person1 yangkang = new Person1("杨康");
        Person1 huangrong = new Person1("黄蓉");
        Person1 wangwu = new Person1("王五");
        Person1[] person = {zhangsan,guojing,yangkang,huangrong,wangwu};
        Deque<Person1> d = new ArrayDeque<>();
        //入队，分配号码
        for(int i = 0; i < 5; i++) {
            person[i].setNo(i+1);
            d.addLast(person[i]);
        }
        //出队
        while(d.size() > 0) {
            System.out.println("* "+d.pollFirst()+" 办理完成");
            if(d.size() > 0) {
                System.out.println("剩余：");
                d.forEach(System.out::println);
            }else {
                System.out.println("后边没有队伍了");
            }
        }
        System.out.println("全部办理完成");
    
    }

}

public class TestQueue1 {

    public static void main(String[] args) {
        // Queue队列
        Queue<String> q = new LinkedList<>();
        //向队尾添加
        q.add("aa");//失败 抛异常
        q.add("bb");
        q.offer("cc");//添加失败 false
//        q.offer(null);队列 不允许 添加 null值 ，LinkedList特殊 ，最好 不要用 Null
        System.out.println(q);
        //模拟队列 操作：出队
    /*    System.out.println(q.poll());//
        System.out.println(q.poll());
        System.out.println(q.poll());*/
        //循环
/*        for(;;) {
            String s = q.poll();
            
            if(s == null) {
                break;
            }
            System.out.println(s);
        }*/
        while(q.size() > 0) {
            //移除 出队
//            System.out.println(q.poll());
            //只  获得不会移除
//            System.out.println(q.peek());
        }
        
    }

Collections类的一些常用方法

sort、sort(集合,比较器)、binarySearch、reverse、max、min、frequency、fill

public class TestCollections {
    
    public static void main(String[] args) {
        //Collections 对集合操作的类
        List<String> list = new ArrayList<>();
        //向集合中添加多个元素
        Collections.addAll(list, "aa","cc","bb");
        System.out.println(list);
        //自然升序排序
        Collections.sort(list);
        System.out.println(list);
        //指定比较器排序
//        Collections.sort(list, (s1,s2)->s2.compareTo(s1));
        System.out.println(list);
        //二分查找 ：前提 是 自然升序排序
        System.out.println(Collections.binarySearch(list, "cc"));
        //最大值 和 最小值
        System.out.println(Collections.max(list));//
        System.out.println(Collections.min(list));//
        //反转集合的元素
        Collections.reverse(list);
        System.out.println(list);
        //元素 在 集合中出现的次数
        Collections.addAll(list, "aa","aa");
        System.out.println(Collections.frequency(list, "aa"));
        //洗牌
        Collections.shuffle(list);
        System.out.println(list);
        //填充
        Collections.fill(list, "xxx");
        System.out.println(list);
    }

}