HashSet保证元素唯一性原码判断过程：

1、调用HashMap的hash()方法,hash()方法通过处理+调用hashCode()方法来获取hash值。

2、在HashTable中查表，如果没有相同hashCode的元素直接添加。

3、如果存在，就和该元素比较hash值&&（地址值||equals值）

4、如果返回false就添加，返回true,就设置Value值，（因为这是在调用hashMap中的方法），这对set没有影响，相当于不添加

            T|reeSet：可以对Set集合中的元素进行排序。默认按照字母的自然排序。底层数据结构是二叉树。保证元素唯一性的依据：比较器方法的返回值。

比较器对象有2个接口：Comparator------->compare()方法

    Comparable-------->compareTo()方法

Comparator和Comparable用法的区别。

Comparator是一个比较器类，用于外部实现，并创建比较器对象传入集合。

Comparable是元素类区实现的，重现CompareTo()方法直接传入集合就可以排序了。

4、Set集合的代码练习

1、HashSet的练习

添加元素，并包含相同的元素，观察输出顺序与结果。

package it.heima.set;
import java.util.HashSet;
public class HashSetDemo {
public static void main(String[] args) {
HashSet<String> hashSet=new HashSet<>();
hashSet.add("hello");
hashSet.add("java");
hashSet.add("world");
hashSet.add("world");
for(String item:hashSet){
System.out.println(item);
}
}
}

添加自定义对象：

package it.heima.set;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.HashSet;
public class HashSetDemo3 {
public static void main(String[] args) throws Exception {
Student s1=new Student(10,"张三");
Student s2=new Student(10,"张三");
Student s3=new Student(11,"李四");
Student s5=new Student(11,"张三");
HashSet<Student> hashSet=new HashSet<>();
hashSet.add(s1);
hashSet.add(s2);
hashSet.add(s3);
hashSet.add(s5);
System.out.println(hashSet);
/*Class c=HashSet.class;
//Constructor con=c.getDeclaredConstructor();
//Object obj=con.newInstance();
Method method=c.getDeclaredMethod("add", Object.class);
method.invoke(hashSet, "String");
System.out.println(hashSet);*/
}
}
class Student{
@Override
public int hashCode() {
return this.name.hashCode()<<2+this.age*15;
}
@Override
public String toString() {
return "Student [age=" + age + ", name=" + name + "]";
}
int age;
String name;
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(int age, String name) {
super();
this.age = age;
this.name = name;
}
@Override
public boolean equals(Object obj) {
Student s=(Student)obj;
return (this.age==s.age)&&(this.name.equals(s.name));
}
}

Set集合的toString方法：底层是继承自AbstractCollection的toString（），AbstractCollection的toString（）重写了Object的toString（），是通过迭代器迭代元素，并通过StringBuilder拼接实现的。

2、TreeSet的代码练习

添加方法的源代码解析:

1、通过调用TreeMap里的put()实现

2、判断Comparator是否为空，否则调用Comparator的compare()

3、是则将key的值向上转型Comparable，调用CompareTo()

TreeSet的代码练习：

package it.heima.set;
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo1 {
public static void main(String[] args) {
/*IdComparator id=new IdComparator();
TreeSet<Person> tree=new TreeSet<>(id);*/
TreeSet<Person> tree=new TreeSet<>();
Person s1=new Person(16,"张三", 80);
Person s2=new Person(15,"李四", 81);
Person s3=new Person(14,"王五", 82);
Person s4=new Person(13,"赵六", 83);
Person s5=new Person(12,"张三", 80);
Person s6=new Person(11,"刘德华", 80);
tree.add(s1);
tree.add(s2);
tree.add(s3);
tree.add(s4);
tree.add(s5);
tree.add(s6);
System.out.println(tree);
}
}
class Person implements Comparable<Person>{
@Override
public String toString() {
return "学生[学号"+id+"
姓名"+name+"
成绩"+score+"]";
}
@Override
public int compareTo(Person s) {
//Student s=(Student)o;
int num=this.score-s.score;
int num2=num==0?this.name.compareTo(s.name):num;
return num2;
}
int id;
String name;
int score;
public Person(int id, String name, int score) {
super();
this.id = id;
this.name = name;
this.score = score;
}
}
class IdComparator implements Comparator<Person>{
@Override
public int compare(Person o1, Person o2) {
return o1.id-o2.id;
}
}

5、Map集合

1、Map概述

  Map是双列集合的根接口，存储了Ket和Value，组成了键值对的集合。

Map集合的子类

            Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。JDK1.0，效率低。

            HashMap：底层是哈希表数据结构。允许使用null键null值，该集合是不同步的。JDK1.2，效率高。

            TreeMap：底层是二叉树数据结构。线程不同步。可以用于给Map集合中的键进行排序。

           Map和Set很像。其实Set底层就是使用了Map集合，只不过Set只操作了Map中方法的键，不去管值。

2、Map的使用

主要掌握Map集合的3种遍历方式。

package it.heima.map;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
public class MapDemo {
public static void main(String[] args) {
HashMap<Student, String> hashMap=new HashMap<>();
Student s1=new Student("张三", 10);
Student s2=new Student("李四", 11);
Student s3=new Student("张三", 10);
Student s4=new Student("李四", 10);
hashMap.put(s1, "一班");
hashMap.put(s2, "一班");
hashMap.put(s3, "一班");
hashMap.put(s4, "二班");
//Map的三种遍历方式
//第一种keySet()
/*Set<Student> key=hashMap.keySet();
for(Student s:key){
System.out.println(s+hashMap.get(s));
}*/
//第二种values()
/*Collection<String> value=hashMap.values();
Iterator<String> it=
value.iterator();
while(it.hasNext()){
System.out.println(it.next());
}*/
//第三种EntrySet
Set<Entry<Student, String>> entry=hashMap.entrySet();
for(Entry<Student, String> s:entry){
System.out.println(s.getKey()+s.getValue());
}
}
}
class Student{
@Override
public int hashCode() {
return this.name.hashCode()+this.id*12;
}
@Override
public boolean equals(Object obj) {
Student s=(Student)obj;
return this.name.equals(s.name)&&this.id==s.id;
}
String name;
int id;
@Override
public String toString() {
return "Student [name=" + name + ", id=" + id + "]";
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(String name, int id) {
super();
this.name = name;
this.id = id;
}
}