69期-Java SE-016_集合-2-001-002

落日映苍穹つ 2021-12-03 15:43 209阅读 0赞

### Set集合
    
    Set是Collection的子接口，Set接口采用散列的存储方式，所有元素是无序的，可以存储一组无序且唯一的对象。
    
    实际开发中不能直接实例化Set对象，需要对其实现类进行实例化同时完成相关业务操作，Set常用的实现类HashSet、LinkedHashSet、TreeSet。
    
    #### HashSet
    
    存储一组无序且唯一的对象，这里的无序是指元素的存储顺序和遍历顺序不一致。
    
    ```java
    import java.util.HashSet;
    import java.util.Iterator;
    
    public class Test {
        public static void main(String[] args) {
            HashSet hashSet = new HashSet();
            hashSet.add("Hello");
            System.out.println(hashSet.size());
            hashSet.add("World");
            System.out.println(hashSet.size());
            hashSet.add("Java");
            System.out.println(hashSet.size());
            hashSet.add("Hello");
            System.out.println(hashSet.size());
            Iterator iterator = hashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
            hashSet.remove("Hello");
            iterator = hashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
        }
    }
    ```
    
    #### LinkedHashSet
    
    LinkedHashSet是Set的另外一个实现类，可以存储一组有序且唯一的元素，这里的有序是指元素的存储顺序和遍历顺序一致。
    
    ```java
    import java.util.Iterator;
    import java.util.LinkedHashSet;
    
    public class Test2 {
        public static void main(String[] args) {
            LinkedHashSet linkedHashSet = new LinkedHashSet();
            linkedHashSet.add("Hello");
            linkedHashSet.add("World");
            linkedHashSet.add("Java");
            System.out.println(linkedHashSet.size());
            linkedHashSet.add("Hello");
            System.out.println(linkedHashSet.size());
            Iterator iterator = linkedHashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
            linkedHashSet.remove("World");
            iterator = linkedHashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
        }
    }
    ```
    
    程序如何判断两个对象是否相等？通过继承自Object类的equals()方法来进行判断的。
    
    LinkedHashSet 判断两个对象是否相等的原理：首先会判断两个对象的hashCode是否相等，什么是hashCode？根据一定的规则奖与对象相关的信息、如内存地址、属性值等，映射成一个数值，这个数值称为散列值，也就是该对象的hashCode。两个不同对象的hashCode可能相等，但是两个hashCode不相等的对象一定不是同一个对象。
    
    集合在判断两个对象是否相等时，会优先比较它们的hashCode，如果不相等，则认为不是同一个对象，如果相等，还不能认为两个对象是相等的，需要通过equals方法进行进一步的验证，如果equals方法返回true，则是同一个对象，否则不是同一个对象，正常添加。
    
    #### TreeSet
    
    TreeSet中保存的元素也是有序的，并且TreeSet的有序和LinkedHashSet的有序有所不同，LinkedHashSet的有序是指元素的存储顺序和遍历顺序是一致的，元素按什么顺序存进去，遍历时就按照什么顺序取出。
    
    TreeSet的有序是指集合内部会自动给所有的元素按照升序进行排列，即无论存入的元素是什么顺序，遍历时都会按照升序进行输出，TreeSet中存储的元素也是唯一的。
    
    ```java
    import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Test4 {
        public static void main(String[] args) {
            TreeSet treeSet = new TreeSet();
            treeSet.add(1);
            treeSet.add(3);
            treeSet.add(6);
            treeSet.add(2);
            treeSet.add(5);
            treeSet.add(4);
            treeSet.add(1);
            Iterator iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                int num = (int)iterator.next();
                System.out.println(num);
            }
            System.out.println("**************************");
            treeSet.remove(6);
            iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                int num = (int)iterator.next();
                System.out.println(num);
            }
        }
    }
    ```
    
    ```java
    import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Test5 {
        public static void main(String[] args) {
            TreeSet treeSet = new TreeSet();
            treeSet.add(new A(1));
            treeSet.add(new A(3));
            treeSet.add(new A(6));
            treeSet.add(new A(2));
            treeSet.add(new A(5));
            treeSet.add(new A(4));
            treeSet.add(new A(1));
            Iterator iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                A a = (A)iterator.next();
                System.out.println(a);
            }
            System.out.println("*********************");
            treeSet.remove(new A(5));
            iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                A a = (A)iterator.next();
                System.out.println(a);
            }
        }
    }
    
    class A implements Comparable{
        private int num;
        public A(int num) {
            this.num = num;
        }
        @Override
        public String toString() {
            return "A [num=" + num + "]";
        }
        /**
         * A.compareTo(B)
         * 返回值：
         * 1表示A大于B
         * 0表示A等于B
         * -1表示A小于B
         */
        @Override
        public int compareTo(Object o) {
            // TODO Auto-generated method stub
            A a = (A)o;
            if(this.num>a.num) {
                return 1;
            }else if(this.num == a.num) {
                return 0;
            }else {
                return -1;
            }
        }
        
    }
    ```
    
    
    
    ### Map
    
    Set、List接口都是Collection的子接口，Map接口时与Collection完全独立的另外一个体系，它们之间的区别在于Set、List、Collection只能操作单个元素，而Map可以操作一对元素，因为Map中的元素都是以key-value的键值对形式来存储的。
    
    Map接口定义时使用了泛型，并且定义了两个泛型K和V，K表示key，规定了键元素的数据类型，V表示value，规定了值元素的数据类型。
    
    常用方法：
    
    - int size()                                    获取集合长度
    - boolean isEmpty()                                                       判断集合是否为空
    - boolean containsKey(Object key)                             判断集合中是否存在某个key值
    - boolean containsValue(Object value)                      判断集合中是否存在某个value值
    - V get(Object key)                                                         获取集合中key对应的value值
    - V put(K key,V value)                                                     向集合中存入一组key-value的元素
    - V remove(Object key)                                                  删除集合中key对应的value值
    - void putAll(Map map)                                                 向集合中添加另外一个Map集合
    - void clear()                                                                    清空集合
    - Set<K> keySet()                                                            取出集合中所有的key，返回一个Set集合
    - Collection<V> values()                                                取出集合中所有的value，返回一个Collection集合
    - Set<Map,Entry<K,V>> entrySet()                               将Map对象转为Set对象
    - int hashCode()                                                              获取集合的散列值
    - boolean equals(Object o)                                           判断两个集合是否相等
    
    ### Map接口的实现类
    
    - HashMap：存储一组无序、key不可重复，但value可重复的元素。
    - Hashtable：存储一组无序、key不可重复、但value可重复的元素。
    - TreeMap：存储一组有序、key不可重复、但value可重复的元素，可以按照key值进行排序。
    
    HashMap的使用
    
    ```java
    import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Test6 {
        public static void main(String[] args) {
            HashMap<String,String> hashMap = new HashMap();
            hashMap.put("h", "Hello");
            hashMap.put("w","World");
            hashMap.put("j","Java");
            hashMap.put("s", "JavaSE");
            hashMap.put("m", "JavaME");
            hashMap.put("e", "JavaEE");
            System.out.println(hashMap);
            hashMap.remove("e");
            System.out.println(hashMap);
            hashMap.put("m", "Model");
            System.out.println(hashMap);
            hashMap.put("m2", "Model");
            System.out.println(hashMap);
            if(hashMap.containsKey("a")) {
                System.out.println("集合中存在值为a的key");
            }else {
                System.out.println("集合中不存在值为a的key");
            }
            if(hashMap.containsValue("Java")) {
                System.out.println("集合中存在值为Java的value");
            }else {
                System.out.println("集合中不存在值为Java的value");
            }
            Set keys = hashMap.keySet();
            Iterator iterator = keys.iterator();
            while(iterator.hasNext()) {
                String key = (String)iterator.next();
                System.out.println(key);
            }
            System.out.println("******************************");
            Collection<String> values = hashMap.values();
            Iterator iter = values.iterator();
            while(iter.hasNext()) {
                String value = (String) iter.next();
                System.out.println(value);
            }
            System.out.println("*********************************");
            Set keys2 = hashMap.keySet();
            Iterator iter2 = keys2.iterator();
            while(iter2.hasNext()) {
                String key = (String) iter2.next();
                String value = hashMap.get(key);
                System.out.println(key+"---"+value);
            }
        }
    }
    ```
    
    Hashtable的使用与HashMap基本一致，Hashtable是早期的实现类，与HashMap的区别是Hashtable是线程安全的，但是性能较低，HashMap是非线程安全，但是性能较高，从实际开发角度讲，HashMap的使用频率更高。
    
    ```java
    import java.util.Collection;
    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.Set;
    
    public class Test7 {
        public static void main(String[] args) {
            Hashtable<String,String> hashtable = new Hashtable();
            hashtable.put("h", "hello");
            hashtable.put("w", "world");
            hashtable.put("j", "Java");
            hashtable.put("s", "JavaSE");
            hashtable.put("m", "JavaME");
            hashtable.put("e", "JavaEE");
            System.out.println(hashtable);
            hashtable.remove("e");
            System.out.println(hashtable);
            hashtable.put("m", "Model");
            System.out.println(hashtable);
            System.out.println(hashtable.containsKey("a"));
            System.out.println(hashtable.containsValue("Java"));
            Collection<String> values = hashtable.values();
            Iterator iterator = values.iterator();
            while(iterator.hasNext()) {
                String value = (String)iterator.next();
                System.out.println(value);
            }
            System.out.println("*********");
            Set keys = hashtable.keySet();
            Iterator iter = keys.iterator();
            while(iter.hasNext()) {
                String key = (String)iter.next();
                String value = hashtable.get(key);
                System.out.println(key+"---"+value);
            }
        }
    }
    ```

![1603260-20190711214110876-98665160.png][]

Test.java

import java.util.HashSet;
    import java.util.Iterator;
    
    public class Test {
        public static void main(String[] args) {
            HashSet hashSet = new HashSet();
            hashSet.add("Hello");
            System.out.println(hashSet.size());
            hashSet.add("World");
            System.out.println(hashSet.size());
            hashSet.add("Java");
            System.out.println(hashSet.size());
            hashSet.add("Hello");
            System.out.println(hashSet.size());
            Iterator iterator = hashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
            hashSet.remove("Hello");
            iterator = hashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
        }
    }

Test2.java

import java.util.Iterator;
    import java.util.LinkedHashSet;
    
    public class Test2 {
        public static void main(String[] args) {
            LinkedHashSet linkedHashSet = new LinkedHashSet();
            linkedHashSet.add("Hello");
            linkedHashSet.add("World");
            linkedHashSet.add("Java");
            System.out.println(linkedHashSet.size());
            linkedHashSet.add("Hello");
            System.out.println(linkedHashSet.size());
            Iterator iterator = linkedHashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
            linkedHashSet.remove("World");
            iterator = linkedHashSet.iterator();
            while(iterator.hasNext()) {
                String item = (String)iterator.next();
                System.out.println(item);
            }
        }
    }

Test3.java

import java.util.Iterator;
    import java.util.LinkedHashSet;
    
    public class Test3 {
        public static void main(String[] args) {
            LinkedHashSet linkedHashSet = new LinkedHashSet();
            linkedHashSet.add(new A(1));
            linkedHashSet.add(new A(1));
            Iterator iterator = linkedHashSet.iterator();
            while(iterator.hasNext()) {
                A a = (A)iterator.next();
                System.out.println(a);
            }
        }
    }
    
    //class A{
    //    private int num;
    //    public A(int num) {
    //        this.num = num;
    //    }
    //    @Override
    //    public String toString() {
    //        return "A [num=" + num + "]";
    //    }
    //    @Override
    //    public int hashCode() {
    //        // TODO Auto-generated method stub
    //        return 1;
    //    }
    //    @Override
    //    public boolean equals(Object obj) {
    //        // TODO Auto-generated method stub
    //        return true;
    //    }
    //}

Test4.java

import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Test4 {
        public static void main(String[] args) {
            TreeSet treeSet = new TreeSet();
            treeSet.add(1);
            treeSet.add(3);
            treeSet.add(6);
            treeSet.add(2);
            treeSet.add(5);
            treeSet.add(4);
            treeSet.add(1);
            Iterator iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                int num = (int)iterator.next();
                System.out.println(num);
            }
            System.out.println("**************************");
            treeSet.remove(6);
            iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                int num = (int)iterator.next();
                System.out.println(num);
            }
        }
    }

Test5.java

import java.util.Iterator;
    import java.util.TreeSet;
    
    public class Test5 {
        public static void main(String[] args) {
            TreeSet treeSet = new TreeSet();
            treeSet.add(new A(1));
            treeSet.add(new A(3));
            treeSet.add(new A(6));
            treeSet.add(new A(2));
            treeSet.add(new A(5));
            treeSet.add(new A(4));
            treeSet.add(new A(1));
            Iterator iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                A a = (A)iterator.next();
                System.out.println(a);
            }
            System.out.println("*********************");
            treeSet.remove(new A(5));
            iterator = treeSet.iterator();
            while(iterator.hasNext()) {
                A a = (A)iterator.next();
                System.out.println(a);
            }
        }
    }
    
    class A implements Comparable{
        private int num;
        public A(int num) {
            this.num = num;
        }
        @Override
        public String toString() {
            return "A [num=" + num + "]";
        }
        /**
         * A.compareTo(B)
         * 返回值：
         * 1表示A大于B
         * 0表示A等于B
         * -1表示A小于B
         */
        @Override
        public int compareTo(Object o) {
            // TODO Auto-generated method stub
            A a = (A)o;
            if(this.num>a.num) {
                return 1;
            }else if(this.num == a.num) {
                return 0;
            }else {
                return -1;
            }
        }
        
    }

Test6.java

import java.util.Collection;
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    public class Test6 {
        public static void main(String[] args) {
            HashMap<String,String> hashMap = new HashMap();
            hashMap.put("h", "Hello");
            hashMap.put("w","World");
            hashMap.put("j","Java");
            hashMap.put("s", "JavaSE");
            hashMap.put("m", "JavaME");
            hashMap.put("e", "JavaEE");
            System.out.println(hashMap);
            hashMap.remove("e");
            System.out.println(hashMap);
            hashMap.put("m", "Model");
            System.out.println(hashMap);
            hashMap.put("m2", "Model");
            System.out.println(hashMap);
            if(hashMap.containsKey("a")) {
                System.out.println("集合中存在值为a的key");
            }else {
                System.out.println("集合中不存在值为a的key");
            }
            if(hashMap.containsValue("Java")) {
                System.out.println("集合中存在值为Java的value");
            }else {
                System.out.println("集合中不存在值为Java的value");
            }
            Set keys = hashMap.keySet();
            Iterator iterator = keys.iterator();
            while(iterator.hasNext()) {
                String key = (String)iterator.next();
                System.out.println(key);
            }
            System.out.println("******************************");
            Collection<String> values = hashMap.values();
            Iterator iter = values.iterator();
            while(iter.hasNext()) {
                String value = (String) iter.next();
                System.out.println(value);
            }
            System.out.println("*********************************");
            Set keys2 = hashMap.keySet();
            Iterator iter2 = keys2.iterator();
            while(iter2.hasNext()) {
                String key = (String) iter2.next();
                String value = hashMap.get(key);
                System.out.println(key+"---"+value);
            }
        }
    }

Test7.java

import java.util.Collection;
    import java.util.Hashtable;
    import java.util.Iterator;
    import java.util.Set;
    
    public class Test7 {
        public static void main(String[] args) {
            Hashtable<String,String> hashtable = new Hashtable();
            hashtable.put("h", "hello");
            hashtable.put("w", "world");
            hashtable.put("j", "Java");
            hashtable.put("s", "JavaSE");
            hashtable.put("m", "JavaME");
            hashtable.put("e", "JavaEE");
            System.out.println(hashtable);
            hashtable.remove("e");
            System.out.println(hashtable);
            hashtable.put("m", "Model");
            System.out.println(hashtable);
            System.out.println(hashtable.containsKey("a"));
            System.out.println(hashtable.containsValue("Java"));
            Collection<String> values = hashtable.values();
            Iterator iterator = values.iterator();
            while(iterator.hasNext()) {
                String value = (String)iterator.next();
                System.out.println(value);
            }
            System.out.println("*********");
            Set keys = hashtable.keySet();
            Iterator iter = keys.iterator();
            while(iter.hasNext()) {
                String key = (String)iter.next();
                String value = hashtable.get(key);
                System.out.println(key+"---"+value);
            }
        }
    }

转载于:https://www.cnblogs.com/HiJackykun/p/11172960.html

[1603260-20190711214110876-98665160.png]: /images/20211203/694cc81dd56f437dbd5537659d03d4f4.png