Collection接口：单列集合，用来存储一个一个的对象
* (不常用)子接口Set：存储无序的、不可重复的数据
* HashSet:作为Set接口的主要实现类；线程不安全的；可以存储null值
* LinkedHashSet:作为HashSet的子类，遍历期内部数据时，可以按照添加的顺序遍历
* TreeSet:可以按照添加对象的指定属性，进行排序
Set接口
* 无序性:不等于随机性，无序性相当于List而言，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
* 不可重复性：保证添加的元素按照equals（）判断时，不能返回true。即：相同元素只能添加一个；（类需要重写equals和hashCode）
*
* 1.Set接口中没有额外定义的新的方法，使用的都是Collection中声明的方法。
*
* 2.添加元素的过程
* 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode（）方法，计算a的哈希值，
* 此哈希值接着通过某种算法计算出在HashSet底层数组中存放的位置（即为：索引位置），判断
* 此数组此位置上是否有元素。
* 如果此位置上没有其他对象元素，则元素a添加成功；//情况一
* 如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
* 如果hash值不同，则元素a添加成功。--->情况二
* 如果hash值相同，进而调用元素a所在类的equals（）方法:
* equals()返回true，元素a添加失败。---->情况三
* equals()返回false，元素a添加成功。---->情况四
* 对于添加成功的情况二、四而言，元素a与已经存在指定索引位置上的数据以链表的形式存储。
* jdk 7：元素a放到数组中，指向原来的元素
* jdk 8：原来的元素放到数组中，指向元素a
* 总结：七上八下
*
* HashSet底层：数组+链表的结构
import org.junit.Test;
import java.util.*;
/**
*
* Collection接口：单列集合，用来存储一个一个的对象
* (不常用)子接口Set：存储无序的、不可重复的数据
* HashSet:作为Set接口的主要实现类；线程不安全的；可以存储null值
* LinkedHashSet:作为HashSet的子类，遍历期内部数据时，可以按照添加的顺序遍历
* TreeSet:可以按照添加对象的指定属性，进行排序
* @author orz
*/
public class SetTest {
/**
*Set接口
* 无序性:不等于随机性，无序性相当于List而言，存储的数据在底层数组中并非按照数组索引的顺序添加，而是根据数据的哈希值决定的
* 不可重复性：保证添加的元素按照equals（）判断时，不能返回true。即：相同元素只能添加一个；（类需要重写equals和hashCode）
*
* 1.Set接口中没有额外定义的新的方法，使用的都是Collection中声明的方法。
*
* 2.添加元素的过程
* 我们向HashSet中添加元素a，首先调用元素a所在类的hashCode（）方法，计算a的哈希值，
* 此哈希值接着通过某种算法计算出在HashSet底层数组中存放的位置（即为：索引位置），判断
* 此数组此位置上是否有元素。
* 如果此位置上没有其他对象元素，则元素a添加成功；//情况一
* 如果此位置上有其他元素b（或以链表形式存在的多个元素），则比较元素a与元素b的hash值：
* 如果hash值不同，则元素a添加成功。--->情况二
* 如果hash值相同，进而调用元素a所在类的equals（）方法:
* equals()返回true，元素a添加失败。---->情况三
* equals()返回false，元素a添加成功。---->情况四
* 对于添加成功的情况二、四而言，元素a与已经存在指定索引位置上的数据以链表的形式存储。
* jdk 7：元素a放到数组中，指向原来的元素
* jdk 8：原来的元素放到数组中，指向元素a
* 总结：七上八下
*
* HashSet底层：数组+链表的结构
*
*/
@Test
public void test1()
{
HashSet hashSet = new HashSet();
hashSet.add("AA");
hashSet.add("BB");
hashSet.add("CC");
hashSet.add("CC");
hashSet.add("CC");
Iterator iterator = hashSet.iterator();
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
}
/**
* LinkedHashSet:可以按照添加的顺序遍历
* LinkedHashSet:作为HashSet的子类，再添加数据的同时，每个数据还维护了两个引用，记录此数据前一个数据和后一个数据
* 优点：对于频繁的遍历操作，效率高于HashSet
*
*/
@Test
public void test2()
{
HashSet hashSet2 = new HashSet();
hashSet2.add(123);
hashSet2.add(234);
hashSet2.add("AA");
hashSet2.add("BB");
hashSet2.add("CC");
Iterator iterator2 = hashSet2.iterator();
while (iterator2.hasNext())
{
System.out.println(iterator2.next());
}
System.out.println();
//可以按照添加的顺序遍历
HashSet hashSet = new LinkedHashSet();
hashSet.add(123);
hashSet.add(234);
hashSet.add("AA");
hashSet.add("BB");
hashSet.add("CC");
Iterator iterator = hashSet.iterator();
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
}
/**TreeSet和TreeMap采用红黑树的存储结构
* TreeSet:
* 1.向TreeSet中添加的数据，要求是相同的对象
* 2.两种排序方式：
* 自然排序（实现Comparable接口）：比较两个对象是否相同的标准为：compareTo()返回0，不再是equals();
*
* 定制排序（Comparator）:比较两个对象是否相同的标准为：compare()返回0，不再是equals();
*/
@Test
public void test3()
{
TreeSet treeSet = new TreeSet();
//错误，不能添加不同类的对象
// treeSet.add(123);
// treeSet.add(456);
// treeSet.add("AA");
treeSet.add(new Person(21,"Tom"));
treeSet.add(new Person(23,"Jack"));
treeSet.add(new Person(25,"Jack"));
treeSet.add(new Person(43,"Cat"));
treeSet.add(new Person(12,"Dog"));
Iterator iterator = treeSet.iterator();
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
}
@Test
public void test4()
{
Comparator com=new Comparator() {
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Person && o2 instanceof Person)
{
Person person=(Person)o1;
Person person1=(Person)o2;
return Integer.compare(person.getAge(),person1.getAge());
}
else
{
throw new RuntimeException("输入的数据类型不匹配");
}
}
};
TreeSet treeSet = new TreeSet(com);
treeSet.add(new Person(21,"Tom"));
treeSet.add(new Person(23,"Jack"));
treeSet.add(new Person(25,"Jack"));
treeSet.add(new Person(43,"Cat"));
treeSet.add(new Person(12,"Dog"));
Iterator iterator = treeSet.iterator();
while (iterator.hasNext())
{
System.out.println(iterator.next());
}
}
}
import java.util.Objects;
public class Person implements Comparable{
private int age;
private String name;
public Person() {
}
public Person(int age, String name) {
this.age = age;
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person person = (Person) o;
return age == person.age &&
Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(age, name);
}
//按照姓名从小到大排序,年龄从小到大
@Override
public int compareTo(Object o)
{
if(o instanceof Person)
{
Person person=(Person)o;
// return this.name.compareTo(person.name);
int compare=this.name.compareTo(person.name);
if(compare!=0)
{
return compare;
}
else
{
return Integer.compare(this.age,person.age);
}
}
else
{
throw new RuntimeException("输入的类型不匹配");
}
}
}
