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(, "xiaoguo");
         Person huang = new Person(,"xiaoguo");
         Person yang = new Person(,"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(, "aa");
         map.put(, "bb");
         map.put(, "cc");
         System.out.println(map);
         //集合 中键值对个数
         System.out.println(map.size());
         //
         System.out.println(map.isEmpty());//false
         //判断键 是否存在
         System.out.println(map.containsKey());
         //判断值 是否存在
         System.out.println(map.containsValue("cc"));
         //按照键移除 键值对
 //        map.remove(2);
         map.remove(, "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(, 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(, "aa");
        map.put(, "bb");
        map.put(, "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() > ) {
            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 = ; i < ; i++) {
             person[i].setNo(i+);
             d.addLast(person[i]);
         }
         //出队
         while(d.size() > ) {
             System.out.println("* "+d.pollFirst()+" 办理完成");
             if(d.size() > ) {
                 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() > ) {
             //移除 出队
 //            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);
    }

}