java基础（14）（set集合，hashSet集合，linkedHashSet，map集合，hashMap，linkedHashMap，collections工具类）

set集合

    一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

    在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

特点

    元素不重复

    没有索引

常用方法

     boolean add(E e)  set 中尚未存在指定的元素，则添加此元素（可选操作）。
     boolean contains(Object o) 如果 set 包含指定的元素，则返回 true。
     boolean equals(Object o) 比较指定对象与此 set 的相等性。
     boolean remove(Object o) 如果 set 中存在指定的元素，则将其移除（可选操作）。
     int size() 返回 set 中的元素数（其容量）。
     int hashCode()  返回 set 的哈希码值。
     boolean isEmpty()  如果 set 不包含元素，则返回 true。
     Iterator<E> iterator() 返回在此 set 中的元素上进行迭代的迭代器。
     Object[] toArray() 返回一个包含 set 中所有元素的数组。
    <T> T[]
     toArray(T[] a) 返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。
     void clear() 移除此 set 中的所有元素（可选操作）。

HashSet集合

    此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。

    此类为基本操作提供了稳定性能，这些基本操作包括 add、remove、contains 和 size，假定哈希函数将这些元素正确地分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例的大小（元素的数量）和底层 HashMap 实例（桶的数量）的“容量”的和成比例。因此，如果迭代性能很重要，则不要将初始容量设置得太高（或将加载因子设置得太低）。

    注意，此实现不是同步的。

特点

    元素不重复

    没有索引

    集合是无序的（存储元素的顺序与去除元素顺序可能不一致）

常用方法

 
boolean    add(E e)
如果此 set 中尚未包含指定元素，则添加指定元素。
void    clear()
从此 set 中移除所有元素。
Object    clone()
返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。
boolean    contains(Object o)
如果此 set 包含指定元素，则返回 true。
boolean    isEmpty()
如果此 set 不包含任何元素，则返回 true。
Iterator<E>    iterator()
返回对此 set 中元素进行迭代的迭代器。
boolean    remove(Object o)
如果指定元素存在于此 set 中，则将其移除。
int    size()
返回此 set 中的元素的数量（set 的容量）。

方法练习 

   

 /**
     * @Describe
     * @Author Double LiFly
     * @date 2021/4/23 14:38
     */
    public class SetDemo01 {
        public static void main(String[] args) {
            /**
             *  boolean add(E e)  set 中尚未存在指定的元素，则添加此元素（可选操作）。
             *  boolean contains(Object o) 如果 set 包含指定的元素，则返回 true。
             *  boolean equals(Object o) 比较指定对象与此 set 的相等性。
             *  boolean remove(Object o) 如果 set 中存在指定的元素，则将其移除（可选操作）。
             *   int size() 返回 set 中的元素数（其容量）。
             *  int hashCode()  返回 set 的哈希码值。
             *  boolean isEmpty()  如果 set 不包含元素，则返回 true。
             *  Iterator<E> iterator() 返回在此 set 中的元素上进行迭代的迭代器。
             *  Object[] toArray() 返回一个包含 set 中所有元素的数组。
             * <T> T[]
             *  toArray(T[] a) 返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。
             *  void clear() 移除此 set 中的所有元素（可选操作）。
             */
            Set<String> set = new HashSet<>();
            //boolean add(E e)  set 中尚未存在指定的元素，则添加此元素（可选操作）。
            set.add("小张");
            set.add("小李");
            set.add("小赵");
            set.add("小王");
     
            //boolean contains(Object o) 如果 set 包含指定的元素，则返回 true。
            set.contains("小张");
     
            //boolean equals(Object o) 比较指定对象与此 set 的相等性。
            boolean b = set.equals("小李");
            System.out.println(b);
     
            //int size() 返回 set 中的元素数（其容量）。
            System.out.println(set.size());
     
            //int hashCode()  返回 set 的哈希码值。
            System.out.println(set.hashCode());
     
            //boolean isEmpty()  如果 set 不包含元素，则返回 true。
            System.out.println(set.isEmpty());
     
            //boolean remove(Object o) 如果 set 中存在指定的元素，则将其移除（可选操作）。
            System.out.println(set.remove("小赵"));
     
            //Iterator<E> iterator() 返回在此 set 中的元素上进行迭代的迭代器。
            Iterator<String> iterator = set.iterator();
            while (iterator.hasNext()){
                System.out.println(iterator.next());
            }
     
            //Object[] toArray() 返回一个包含 set 中所有元素的数组。
            String[] array = set.toArray(new String[set.size()]);
            for (String s : array) {
                System.out.println(s);
            }
        }
    }

linkedHashSet

    具有可预知迭代顺序的 Set 接口的哈希表和链接列表实现。此实现与 HashSet 的不同之外在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，即按照将元素插入到 set 中的顺序（插入顺序）进行迭代。注意，插入顺序不 受在 set 中重新插入的 元素的影响。（如果在 s.contains(e) 返回 true 后立即调用 s.add(e)，则元素 e 会被重新插入到 set s 中。）

    此实现可以让客户免遭未指定的、由 HashSet 提供的通常杂乱无章的排序工作，而又不致引起与 TreeSet 关联的成本增加。使用它可以生成一个与原来顺序相同的 set 副本，并且与原 set 的实现无关

特点

    元素不可重复

    没有索引

    集合是有序的（存储元素的顺序与取出元素的顺序是一致的）

构造方法

     

   LinkedHashSet()
                  构造一个带默认初始容量 (16) 和加载因子 (0.75) 的新空链接哈希 set。

    面试有可能问道初始容量和加载因子

map集合

    将键映射到值的对象。一个映射不能包含重复的键；每个键最多只能映射到一个值。

    此接口取代 Dictionary 类，后者完全是一个抽象类，而不是一个接口。

    Map 接口提供三种collection 视图，允许以键集、值集或键-值映射关系集的形式查看某个映射的内容。映射顺序 定义为迭代器在映射的 collection 视图上返回其元素的顺序。某些映射实现可明确保证其顺序，如 TreeMap 类；另一些映射实现则不保证顺序，如 HashMap 类。

map与collection集合的区别 

    collection集合

    单列集合，一次只能添加一个元素

    有的是有索引，又得没有索引

    有的集合是可以存储重复的元素，又得则不可以

    有的元素是无序的，有的是有序的

map集合

    map集合是双列集合，由key和value组成

    key是不允许重复的，value是允许重复的

    key允许存null值，但是只能存储唯一的一个

map集合中常用的子类
HashMap

    存储数据采用的哈希表结构，元素的存取顺序不能保证一致。由于要保证键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

LinkedHashMap

    HashMap下有个子类LinkedHashMap，存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致；通过哈希表结构可以保证的键的唯一、不重复，需要重写键的hashCode()方法、equals()方法。

map接口中常用的方法
方法名    说明
public V put(K key, V value)    把指定的键与指定的值添加到Map集合中。
public V remove(Object key)    把指定的键 所对应的键值对元素 在Map集合中删除，返回被删除元素的值。
public V get(Object key)    根据指定的键，在Map集合中获取对应的值。
boolean containsKey(Object key)    判断集合中是否包含指定的键。
public Set<K> keySet()    获取Map集合中所有的键，存储到Set集合中。
public Set<Map.Entry<K,V>> entrySet()    获取到Map集合中所有的键值对对象的集合(Set集合)。

常用方法的练习

   

 /**
     * @Describe
     * @Author Double LiFly
     * @date 2021/4/26 14:03
     */
    public class MapDemo01 {
        public static void main(String[] args) {
            /**
             *  public V put(K key, V value)             : 向集合中添加一个键值对的映射.
             *  public V remove(Object key)              : 根据传入的键, 删除集合中的映射关系.
             *  public V get(Object key)                 : 根据传入的键, 获取对应的值.
             *  boolean containsKey(Object key)          : 判断是否包含传入的键
             *  boolean containsValue(Object value)    : 判断是否包含传入的值
             *  boolean isEmpty()                         : 判断集合是否为空
             *  int size()                              : 获取集合的元素个数
             *  public Set<K> keySet()                  : 获取所有键的集合
             *  public Set<Map.Entry<K,V>> entrySet() : 获取所有entry对象(键值对对象)的集合
             */
            Map<String,String> map = new HashMap<>();
            //public V put(K key, V value)             : 向集合中添加一个键值对的映射.
            //如果没有重复的键，就是存储一堆元素
            //有重复的键，就是修改功能，就是覆盖
            map.put("杨过","小龙女");
            map.put("郭靖","黄蓉");
            map.put("张无忌","赵敏");
     
     
            //public V remove(Object key)              : 根据传入的键, 删除集合中的映射关系.
            //如果出入的键没在集合中则会返回null值
            map.remove("郭靖");
           /* String s = map.remove("郭襄");//null
            System.out.println(map);
            System.out.println(s);*/
     
           //public V get(Object key)                 : 根据传入的键, 获取对应的值.
           /* String s = map.get("张无忌");
            System.out.println(s);*/
     
            //boolean containsKey(Object key)          : 判断是否包含传入的键
           /* boolean b = map.containsKey("小花");
            System.out.println(b);//false*/
     
           //boolean containsValue(Object value)    : 判断是否包含传入的值
           /* boolean b = map.containsValue("赵敏");
            System.out.println(b);*/
     
            //boolean isEmpty()                         : 判断集合是否为空
            boolean empty = map.isEmpty();
            System.out.println(empty);
     
            //int size()                              : 获取集合的元素个数
            int size = map.size();
            System.out.println(size);
     
            //public Set<K> keySet()                  : 获取所有键的集合
     
            //public Set<Map.Entry<K,V>> entrySet() : 获取所有entry对象(键值对对象)的集合
     
     
        }
    }

map获取元素的的两种方式

  

  /**
     * @Describe
     * @Author Double LiFly
     * @date 2021/4/26 14:16
     */
    public class MapDemo02 {
        public static void main(String[] args) {
            /**
             * //public Set<K> keySet()                  : 获取所有键的集合
             *
             *         //public Set<Map.Entry<K,V>> entrySet() : 获取所有entry对象(键值对对象)的集合
             */
     
            Map<String,String> map = new HashMap<>();
            map.put("杨过","小龙女");
            map.put("郭靖","黄蓉");
            map.put("张无忌","赵敏");
            //public Set<K> keySet()                  : 获取所有键的集合
            //先获取所有的键，再通过键获取对应的值
     
            Set<String> set = map.keySet();
            for (String key : set) {
                System.out.println(key+":"+map.get(key));
            }
     
            //public Set<Map.Entry<K,V>> entrySet() : 获取所有entry对象(键值对对象)的集合
            /**
             * 将map集合中的k和v封装成一个对象Entry
             * 在Entry对象中提供了两个方法
             * getKey();获取key
             * getValue();获取value
             */
            Set<Map.Entry<String, String>> entrySet = map.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey()+":"+entry.getValue());
            }
     
        }
    }

总结

    当给HashMap中存放自定义对象时，如果自定义对象作为key存在，这时要保证对象唯一，必须复写对象的hashCode和equals方法(如果忘记，请回顾HashSet存放自定义对象)。如果要保证map中存放的key和取出的顺序一致，可以使用java.util.LinkedHashMap集合来存放

linkedHashMap

    Map 接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现与 HashMap 的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序通常就是将键插入到映射中的顺序（插入顺序）。注意，如果在映射中重新插入 键，则插入顺序不受影响。（如果在调用 m.put(k, v) 前 m.containsKey(k) 返回了 true，则调用时会将键 k 重新插入到映射 m 中。）

特点

    有序，而且key不允许重复

    数据结构：哈希表+链表

map集合案例

  

  /**
     * @Describe
     * @Author Double LiFly
     * @date 2021/4/26 14:31
     */
    public class MapTest02 {
        public static void main(String[] args) {
            /**
             * 计算一个字符串中每个字符出现次数。
             * 使用HashMap集合，完成此案例
             */
            Map<Character,Integer> map = new HashMap<>();
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入一个字符串");
            String s = scanner.nextLine();
            char[] chars = s.toCharArray();
            for (char key : chars) {
                //如果没有当前的字符说明第一次出现map.put(key,1),value设为1
                if (!map.containsKey(key)){
                    map.put(key,1);
                }else {
                    //如果没有当前的字符，说明不是第一次出现，该key的value+1
                    map.put(key,map.get(key)+1);
                }
            }
            //keySet遍历map集合
            Set<Character> set = map.keySet();
            for (Character key : set) {
                System.out.println(key+":"+map.get(key));
            }
            //entrySet遍历map集合
            Set<Map.Entry<Character, Integer>> entrySet = map.entrySet();
            for (Map.Entry<Character, Integer> entry : entrySet) {
                System.out.println(entry.getKey()+":"+entry.getValue());
            }
        }
    }

简化步骤

   

 /**
     * @Describe
     * @Author Double LiFly
     * @date 2021/4/26 14:40
     */
    public class MapTest02_01 {
        public static void main(String[] args) {
            /**
             * 简化
             */
            Map<Character,Integer> map = new HashMap<>();
            System.out.println("请输入一个字符串");
            for (char key : new Scanner(System.in).nextLine().toCharArray()) {
                map.put(key,map.get(key)==null?1: map.get(key) + 1);
            }
            //keySet遍历map集合
            for (Character key : map.keySet())
                System.out.println(key+":"+map.get(key));
     
            //entrySet遍历map集合
            for (Map.Entry<Character, Integer> entry :  map.entrySet())
                System.out.println(entry.getKey()+":"+entry.getValue());
     
        }
    }

collections工具类

    此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。

常用方法的使用

   

 /**
     * @Describe
     * @Author Double LiFly
     * @date 2021/4/26 16:50
     */
    public class CollectionDemo01 {
        public static void main(String[] args) {
            /**
             *  public static <T> boolean addAll(Collection<T> c, T... elements):
             *  public static void shuffle(List<?> list):
             *  public static <T> void sort(List<T> list):
             *  public static void reverse(List<?> list)
             */
            ArrayList<Integer> list = new ArrayList<>();
            list.add(10);
            list.add(58);
            list.add(20);
            list.add(25);
            Collections.sort(list);
            System.out.println(list);
            Collections.reverse(list);
            System.out.println(list);
            Collections.shuffle(list);
            System.out.println(list);
     
        }
    }