package com.btp.t4;
import java.util.HashSet;
import java.util.Set;
import java.util.*;
import org.junit.Test;
/*
* Collection接口
* |--------List接口：存储有序的，可以重复的元素
* |--------ArrayList(主要的实现类)
* |--------LinkedList(适合频繁的插入，删除操作)
* |--------Vector(古老的，线程安全的，但效率要低于ArrayList)
* |--------Set接口：存储无序的，不可重复的元素.Set中常用的方法都是Collection下定义的
* |--------HashSet(主要实现类)
* |--------LinkedHashSet
* |--------TreeSet
*
*
* Set：存储的元素是无序的，不可重复的
* 1.无序性：无序性 ！= 随机性。真正的无序性指的是元素在底层存储的位置是无序的
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去
*
* 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。进而保证Set元素的不可重复性
*
* Set中的元素存储方法：使用了哈希算法
* 当向Set中添加对象时，首先调用此对象中所在类的hashCode()方法，计算此对象的哈希值，此哈希值决定了此对象在
* Set中的存储位置。若此位置之前没有存储对象，则这个对象直接存储到此位置，若此位置已有对象存储，再通过equals
* 方法比较这两个对象是否相同。如果相同，则后一个对象就不能再添加进来。一般不会出现hashCode相同而equals返回false
* >要求：hashCode方法和equals方法一致
*
* LinkedHashSet：
* 1.LinkedHashSet:使用链表维护了一个添加进集合的顺序，导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的
* 2.LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时有很好的性能
*
* TreeSet
* 1.向TerrSet中添加的元素必须是同一类的
* 2.可以按照添加进集合中的元素的指定的顺序遍历。像String，包装类等默认按照从小到大的顺序遍历（因为它们都重写了Comparable接口中的方法）
* 3.当自定义类没有实现Comparable接口时，当向TreeSet集合中添加自定义类的对象时，报错
* 4.当向TreeSet中添加自定义类的对象时，有两种排序方法①自然排序②定制排序
* 5.自然排序：要求自定义类实现java.lang.Comparable接口并重写其中的comparaTo(Object o)方法.在此方法中，指明按照自定义类的哪个属性进行排序
* 6.向TreeSet中添加对象的时候，首先按照comparaTo()方法进行比较，一旦返回0，虽然仅是两个对象的此属性值相同，但是程序会认为这两个对象是相同的，
* 进而后一个对象不能添加进来
* >comparaTo(),hashCode()和equals()方法保持一致
*/
public class TestSet {
@Test
public void testHashSet(){
Set set=new HashSet();
set.add(123);
set.add(456);
set.add(new String("AA"));
set.add(new String("BB"));
set.add(null);
Person1 p1=new Person1("GG",12);
Person1 p2=new Person1("GG",12);
set.add(p1);
set.add(p2);//如果没有重写Person1的equals方法和HashCode方法，那么就算Person1的两个对象属性都相同，也是可以都加到set中
//所以还是需要同时重写加进去的对象的equals方法和HashCode方法，才能实现不可重复性
System.out.println(set.size());
System.out.println(set);//无序：但是不是随机的
}
@Test
public void LinkedHashSet(){
Set set=new LinkedHashSet();
set.add(new String("AA"));
set.add(123);
set.add(456);
set.add(new String("BB"));
set.add(null);
Iterator iterator=set.iterator();
while(iterator.hasNext()){
System.out.println(iterator.next());
}
}
@Test
public void TreeSet1(){
Set set=new TreeSet();
set.add(new String("AA"));
set.add(new String("BB"));
set.add("JJ");
set.add("JJ");
set.add("MM");
for(Object str:set)
{
System.out.println(str);
}
}
@Test
public void TreeSet2(){
Set set=new TreeSet();
set.add(new Person1("MM",16));
set.add(new Person1("AA",13));
set.add(new Person1("CC",21));
set.add(new Person1("ZZ",199));
set.add(new Person1("BB",99));
set.add(new Person1("XX",99));
for(Object str:set)
{
System.out.println(str);
}
}
@Test
public void TreeSet3(){
//定制排序1
//1.创建一个实现了Comparator接口的类对象
Comparator com=new Comparator(){
//向TreeSet中添加Customer类的对象，在此compare()方法中，指明是按照Customer的哪个对象排序的
@Override
public int compare(Object o1, Object o2) {
if(o1 instanceof Customer && o2 instanceof Customer){
Customer c1=(Customer)o1;
Customer c2=(Customer)o2;
int i=c1.getId().compareTo(c2.getId());
if(i==0){
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
};
//将此对象作为形参传递给TreeSet的构造器中
TreeSet set=new TreeSet(com);
//向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
set.add(new Customer("AA",1003));
set.add(new Customer("BB",1002));
set.add(new Customer("GG",1004));
set.add(new Customer("CC",1001));
set.add(new Customer("DD",1001));
for(Object str:set){
System.out.println(str);
}
}
@Test
public void TreeSet4(){
//定制排序2
TreeSet set=new TreeSet(new Comparator(){
public int compare(Object o1, Object o2) {
if(o1 instanceof Customer && o2 instanceof Customer){
Customer c1=(Customer)o1;
Customer c2=(Customer)o2;
int i=c1.getId().compareTo(c2.getId());
if(i==0){
return c1.getName().compareTo(c2.getName());
}
return i;
}
return 0;
}
});
//向TreeSet中添加Comparator接口中的compare方法中涉及的类的对象
set.add(new Customer("AA",1003));
set.add(new Customer("BB",1002));
set.add(new Customer("GG",1004));
set.add(new Customer("CC",1001));
set.add(new Customer("DD",1001));
for(Object str:set){
System.out.println(str);
}
}
}
class Customer{
private String name;
private Integer id;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Customer(String name,Integer id)
{
super();
this.name=name;
this.id=id;
}
public Customer()
{
super();
}
@Override
public String toString() {
return "Customer [name=" + name + ", id=" + id + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((id == null) ? 0 : id.hashCode());
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Customer other = (Customer) obj;
if (id == null) {
if (other.id != null)
return false;
} else if (!id.equals(other.id))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
class Person1 implements Comparable{
String name;
Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Person1(String name,int age) {
super();
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Person1 [name=" + name + ", age=" + age + "]";
}
@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;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person1 other = (Person1) 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;
}
//当向TreeSet中添加Person1类对象时，依据此方法，确定按照哪个属性排列
@Override
public int compareTo(Object o) {
if(o instanceof Person1){
Person1 p=(Person1)o;
int i=this.age.compareTo(p.age);
if(i==0){
return this.name.compareTo(p.name);
}else{
return i;
}
}
return 0;
}
}
