Java TreeSet/HashSet Map集合

Set集合

Set并没有独有定义方法，所有方法均继承自Collection

不包含重复元素的集合。 更正式地，集合不包含一对元素e1和e2 ，使得e1.equals(e2) ，并且最多一个空元素。 正如其名称所暗示的那样，这个接口模拟了数学集
HashSet
此类实现Set接口，由哈希表（实际为HashMap实例）支持。 对集合的迭代次序不作任何保证。特别是，它不能保证顺序在一段时间内保持不变。 这个类允许null元素,基于hashCode实现元素不重复，通过重写hashCode()和equals()保证所有元素不重复
当存入元素的hashcode相同时进行equals，返回true则拒绝存入。
HashSet构造方法
HashSet()
构造一个新的空集合; 背景HashMap实例具有默认初始容量（16）和负载因子（0.75）。

HashSet(Collection<? extends E> c)
构造一个包含指定集合中的元素的新集合。

HashSet(int initialCapacity)
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和默认负载因子（0.75）。

HashSet(int initialCapacity, float loadFactor)
构造一个新的空集合; 背景HashMap实例具有指定的初始容量和指定的负载因子。
抽象方法
toArray()
返回一个包含此集合中所有元素的数组。

对Set类集合做遍历：

import java.util.HashSet;
public class SetLearn {
    public static void main(String[] args) {
        HashSet<String> st= new HashSet<String >();
        st.add("A");
        st.add("b");
        st.add("C");
        st.add("d");

        System.out.println(st.size());
        st.remove("C");
        System.out.println(st.size());
        for(String str:st){		//对所有元素遍历
            System.out.println(str);
        }
    }
}

Set集合的add当地址重复时，返回false，但是地址不重复内容重复时返回true，所以要重写equals
注意：equals的调用在hashCode调用后面；若hashCode不同则不会调用equals，所以要重写hashCode()

@Override
    public String toString(){
        return "Student name="+name+" age="+age+" score="+score+" sex="+sex+"\t"+this.hashCode();
    }
    @Override
    public boolean equals(Object obj){
        System.out.println("Hello");
        if (this==obj)return true;
        if (obj==null)return false;
        if (this.getClass()!=obj.getClass())return false;

        Student s=(Student)obj;

        if (this.name.equals(s.name)&&this.sex.equals(s.sex)&&this.score.equals(s.score)&&this.age.equals(s.age))
            return true;
        return false;
    }
    @Override
    public int hashCode(){
        return this.age.hashCode()+this.sex.hashCode()+this.score.hashCode()+this.name.hashCode();
    }

TreeSet：
TreeSet基于Set接口中的SortedSet实现

• 基于排序顺序实现元素不重复
• 实现SortedSet接口，对集合元素自动排序
• 要求继承Comparable接口，指定排序规则
• 通过compareTo方法确定是否为重复元素

LinkHashSet：
哈希表和链表实现了Set接口，具有可预测的迭代次序。 这种实现不同于HashSet，它维持于所有条目的运行双向链表。
以链表进行存储，保留元素插入顺序
构造方法：

LinkedHashSet() 
构造一个具有默认初始容量（16）和负载因子（0.75）的新的，空的链接散列集。  
LinkedHashSet(Collection<? extends E> c) 
构造与指定集合相同的元素的新的链接散列集。  
LinkedHashSet(int initialCapacity) 
构造一个具有指定初始容量和默认负载因子（0.75）的新的，空的链接散列集。  
LinkedHashSet(int initialCapacity, float loadFactor) 
构造具有指定的初始容量和负载因子的新的，空的链接散列集 

import java.util.HashSet;
import java.util.TreeSet;

public class SetLearn {
    public static void main(String[] args) {
        HashSet<Student> st = new HashSet<Student>();
        Student s1 = new Student("zhangsan", 23, 100D, "male");
        Student s2 = new Student("zhaoliu", 24, 85D, "male");
        Student s3 = new Student("wangwu", 26, 90D, "male");
        Student s4 = new Student("lisi", 23, 96D, "male");
        st.add(s1);
        st.add(s2);
        st.add(s3);
        st.add(s4);
        for (Student student : st) {
            System.out.println(student);
        }
        System.out.println("----------");

        TreeSet<Student> strp = new <Student>TreeSet();
        strp.add(s4);
        strp.add(s3);

        for (Student s:strp
             ) {
            System.out.println(s);
        }
    }
}
class Student implements Comparable<Student> {
    String name;
    String sex;
    Integer age;
    Double score;

    public Student() {
        super();
    }

    public Student(String name, Integer age, Double score, String sex) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Student name=" + name + " age=" + age + " score=" + score + " sex=" + sex + "\t" + this.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        System.out.println("Hello");
        if (this == obj) return true;
        if (obj == null) return false;
        if (this.getClass() != obj.getClass()) return false;

        Student s = (Student) obj;

        if (this.name.equals(s.name) && this.sex.equals(s.sex) && this.score.equals(s.score) && this.age.equals(s.age))
            return true;
        return false;
    }

    @Override
    public int hashCode() {
        return this.age.hashCode() + this.sex.hashCode() + this.score.hashCode() + this.name.hashCode();
    }


    public int compareTo(Student p) {
        if (this.score > p.score) {
            return -1;//降序排序
        } else if (this.score < p.score) {
            return 1;
        }
        return 0;
    }
}

Map体系集合

Map接口特点

• 存储任意键值对(KEY,VALUE)
• 键：无序，无下标，不可重复
• 值：无序，无下标，可重复

Map父接口
接口方法：
boolean containsKey(Object key)
返回 true如果这Map包含一个指定的键映射。
boolean containsValue(Object value)
返回 true如果映射到指定的值的一个或多个键。
V get(Object key)
返回指定的键映射的值，或 null，如果这个Map不包含的键映射。
V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。 Key重复会覆盖原值
V remove(Object key)
如果存在（可选操作），则从该Map中移除一个键的映射。
Set keySet()
返回一个 Set的关键视图包含在这个Map。
Collection values()
返回一个 Collection视图的值包含在这个Map。
Set<Map.Entry<K,V>> entrySet()
返回一个 Set视图的映射包含在这个Map。
Set keySet()
返回一个 Set的关键视图包含在这个Map。
Collection values()
返回一个 Collection视图的值包含在这个Map。

Map集合的实现类：

HashMap<K,V>:
基于哈希表的 Map接口的实现。这种实现提供了所有可选的Map操作，并允许 null值和 null键,这类不能保证Map的秩序；特别是，它并不能保证Map将随时间保持恒定。
map不要用for循环和整数做KEY
String 作为KEY是最常见的
特点：线程不安全，运行效率快

HashTable<K,V>
这个类实现了一个哈希表，它映射了值的键。任何非 null对象可以作为key或值。
成功地向哈希表中存储或检索对象，作为key的对象必须实现hashCode法和equals方法
特点：线程安全，运行效率慢

对map遍历：

Set<String> keys= map.keySet();//遍历所有键并输出
        for (String s:keys) {
            System.out.println(s);
        }

Collection <String> value= map.values();//遍历所有值并输出
        for (String y:value) {
            System.out.println(y);

Map.entry详解

遍历键和值
Set<Map.Entry<String,String>> entries=map.entrySet();//遍历后返回一个链表数组，数组每个对象都是Entry链表节点
        for (Map.Entry<String,String> entry:entries)
        {
           // System.out.println(entry.getKey()+"\t"+entry.getValue());
            System.out.println(entry);//Map的toString方法
        }

Properties类：
不支持泛型。优势：操作文件和流。
key和value都是String，常用于配置文件读取

public class Properties
extends Hashtable<Object,Object>
的 Properties类代表一个持久的特性。的 Properties可以保存到流或流中加载。属性列表中的每个键和它的相应值是一个字符串。

方法：
Object setProperty(String key, String value)
调用方法 put Hashtable。
String getProperty(String key)
在这个属性列表中搜索指定的键的属性。

import java.util.Properties;

public class PropertiesLearn {
    public static void main(String[] args) {
        System.out.println("PropertiesLearning file");
        Properties prop=new Properties();
        //prop.put("aaa",new Object());   不安全，设计存在瑕疵，继承了一个不该继承的父类，没有泛型
        prop.setProperty("JP","japan");
        prop.setProperty("US","America");
        System.out.println(prop.getProperty("US"));
    }
}

TreeMap类
Map接口常用实现类
TreeSet底层是通过TreeMap实现的
和TreeSet区别：
TreeMap实现的是SortedMap接口(Map子接口),可以对Key自动排序