Java学习笔记（十一）--Set集合 Map集合

HashSet

1.元素顺序：元素唯一，但是无序（它不保证Set的迭代顺序，特别是它不保证该顺序永久不变）。

2.如何保证元素的唯一性：重写hashCode()和equals()两个方法。
执行流程：
首先判断哈希值是否相同：
（1）如果不同，就直接添加到集合；
（2）如果相同，继续执行equals()，看其返回值：
-如果是false，就直接添加到集合；
-如果是true，说明元素重复不添加。

使用：看到哈希结构的集合，就要考虑可能需要重写这两个方法。（自动生成就可以了：shift+alt+s）
重写的方法如下：

    @Override
public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }
    /* (non-Javadoc)
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

3.HashSet底层结构是哈希表。
哈希表结构：是一个元素为链表的数组结构。

---

TreeSet

1.元素顺序：使用元素的自然排序对元素进行排序，或者根据创建Set时提供的Comparator进行排序。

2.底层算法：二叉树。

3.二叉树存储元素的原则：
当存入第二个元素的时候，会与之前的元素做减法：
-如果为负说明比之前的元素小，往左放；
-如果为正说明比之前的元素大，往右放；
-如果为零，不存储。

需求：创建集合存储Integer类型的元素（20,18,23,22,17,24,19,18,24）。

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建TreeSet集合
        TreeSet<Integer> ts = new TreeSet<Integer>();

        //给集合添加元素
        ts.add(20);
        ts.add(18);
        ts.add(23);
        ts.add(22);
        ts.add(17);
        ts.add(24);
        ts.add(19);
        ts.add(18);
        ts.add(24);

        //遍历集合
        for (Integer it : ts) {
            System.out.println(it);
        }
    }

}

运行结果：

需求：存储字符串并遍历（字母a-z排序）。

public class TreeSetDemo2 {
    public static void main(String[] args) {
        //创建TreeSet集合
        TreeSet<String> ts = new TreeSet<String>();

        //给集合添加元素
        ts.add("hello");
        ts.add("bat");
        ts.add("c++");
        ts.add("java");
        ts.add("php");

        //遍历集合
        for (String str : ts) {
            System.out.println(str);
        }
    }

}

运行结果：

4.自然比较法和比较器比较法：
（1）自然比较法：当使用无参构造创建集合时，自定义对象实现Comparable接口，并重写compareTo()方法。

//学生类中实现Comparable接口，并重写compareTo()方法如下
    @Override
    public int compareTo(Student s) {
        //按照年龄进行排序
        int num=this.age-s.age;
        //如果年龄相同按照姓名排序
        int num2= num==0 ? this.name.compareTo(s.name):num;

        return num2;
    }

（2）比较器比较法：当使用有参构造创建集合时，可以使用匿名内部类的方式，传入Comparator进行排序。

//这里也是通过学生类来举例，先比较年龄，再比较姓名
TreeSet<Student> ts=new TreeSet<Student>(new Comparator<Student>(){

            public int compare(Student s1, Student s2) {
                int num = s1.getAge() - s2.getAge();
                int num2 = num==0?s1.getName().compareTo(s2.getName()):num;
                return num2;
            }
        });

---

Set的遍历

1.Iterator迭代器比较法
2.增强for循环

---

HashSet与TreeSet的相同点与不同点

1.相同点：
单列集合，元素不可重复。
2.不同点：
（1）底层存储的数据结构不同：
HashSet底层用的是HashMap哈希表结构存储，而TreeSet底层用的是TreeMap树结构存储。
（2）存储时保证数据唯一性依据不同：
HashSet是通过重写HashCode()方法和equals()方法来保证的，而TreeSet通过Comparable接口的compareTo()方法来保证的。
3.有序性不一样：
HashSet无序，TreeSet有序。

---

Map

1.Map：将键映射到值得对象。一个映射不能包含重复的键，每个键最多只能映射到一个值。
2.Map接口中的部分方法：
-获取功能

Set<Map.Entry<K,V>> entrySet() //获取键值对对象的集合，遍历键值对对象，再利用getKey(),getValue()取出键和值
V get(Object key) //根据键获取值
Set<K> keySet() //获取所有的键
Collection<V> values() //获取所有的值

-删除功能:

void clear() //移除集合中的所有键值对元素
V remove(Object key) //根据键移除键值对元素，并返回值

-判断功能:

boolean containsKey(Object key) //判断集合中是否包含指定的键
boolean containsValue(Object value) //判断集合中是否包含指定的值
boolean isEmpty() //判断集合是否为空

-添加功能

V put(K key,V value) //集合添加键值对

-长度功能

int size() //键值对对数

需求：存入（String,String）主要讲解遍历方式，键：丈夫 值：妻子。

public class HashMapDemo {
    public static void main(String[] args) {
        /**
         *  2.HashMap
             2.1元素顺序：元素顺序不可预测
             2.2底层算法：哈希算法
             2.3对键没有要求（仅仅相对于TreeMap来说）
         */
        //存入（String,String）主要讲解遍历方式，键：丈夫  值：妻子
        HashMap<String,String> hs = new HashMap<String,String>();

        //给集合添加元素
        hs.put("丈夫1","妻子1");
        hs.put("丈夫2","妻子2");
        hs.put("丈夫3","妻子3");
        hs.put("丈夫4","妻子4");
        hs.put("丈夫5","妻子5");

        //遍历，通过键找值
        Set<String> ks = hs.keySet();
        for (String key : ks) {
            System.out.println(key+"  "+hs.get(key));
        }
        System.out.println("--------------------------");
        //通过entrySet来遍历
        Set<Entry<String, String>> entrySet = hs.entrySet();
        for (Entry<String, String> entry : entrySet) {
            System.out.println(entry.getKey()+"  "+entry.getValue());
        }
    }

}

运行结果：

需求：存入（String,Student）键：String(国籍) 值：Student。

public class HashMapDemo {
    public static void main(String[] args) {
        //存入（String,Student）键：String(国籍)  值：Student
        HashMap<String,Student> hm = new HashMap<String,Student>();

        //创建学生对象
        Student s1 = new Student("张三",21);
        Student s2 = new Student("樱桃小丸子",22);
        Student s3 = new Student("金韩一",23);
        Student s4 = new Student("Jackson",22);

        //添加键值对到集合中
        hm.put("中国",s1);
        hm.put("日本",s2);
        hm.put("韩国",s3);
        hm.put("美国",s4);

        //遍历，通过键找值
        Set<String> ks = hm.keySet();
        for (String key : ks) {
            System.out.println(key+"  "+hm.get(key));
        }


    }

}

运行结果：

3.HashMap
（1）元素顺序：元素顺序不可预测
（2）底层算法：哈希算法
（3）对键没有要求（仅仅相对于TreeMap来说）

4.Treemap
（1）元素顺序：元素顺序与键的排序规则有关
（2）底层算法：Tree算法

5.遍历：
（1）获取建的集合
（2）遍历键
（3）根据键找值foreach()
1.foreach()：例如：根据丈夫找妻子（根据键找值）
2.entrySet()：例如：先找到夫妻的结婚证，再从结婚证里面找到丈夫和妻子（先找到键值对对象，再从键值对对象里面找到键和值）

6.HashMap与TreeMap的相同点与不同点：
（1）相同点：主要用于存储键(key)值(value)对，根据键得到值，因此键不允许键重复,但允许值重复。
（2）不同点：
HashMap里面存入的键值对在取出的时候是随机的,也是我们最常用的一个Map.根据键可以直接获取它的值，具有很快的访问速度。在Map 中插入、删除和定位元素，HashMap 是最好的选择。
TreeMap取出来的是排序后的键值对。但如果您要按自然顺序或自定义顺序遍历键，那么TreeMap会更好。