package com.atguigu.java;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
import org.junit.Test;
/*
* Collection接口
* |------List接口：存储有序的，可以重复的元素
* |------ArrayList(主要的实现类)
|------LinkedList(频繁的插入、删除操作)
|------Vector(古老的实现类、线程安全的)
* |------Set接口：存储无序的，不可重复的元素
* |------HashSet
|------LinkedHashSet
|------TreeSet
*/
public class TestSet {
/*
* TreeSet的定制排序：
* 见下面的步骤。
* 一般使用了Comparator()方法了，就不要再用Comparable接口了
* >compareTo()与hashCode()以及equals()三者保持一致。
*/
@Test
public void testTreeSet3(){//这样也可以，一个是有com名的，这个是匿名的。
//2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(new Comparator(){
@Override
public int compare(Object o1, Object o2) {
if (o1 instanceof Customer && o2 instanceof Customer) {
Customer c1 = (Customer)o1;
Customer c2 = (Customer)o2;
//return c1.getName().compareTo(c2.getName());同样存在该属性相同则无法添加情况
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}else {
return i;
}
}
return 0;
}
});
//3.向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 testTreeSet2(){
//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;
//return c1.getName().compareTo(c2.getName());同样存在该属性相同则无法添加情况
int i = c1.getId().compareTo(c2.getId());
if (i == 0) {
return c1.getName().compareTo(c2.getName());
}else {
return i;
}
}
return 0;
}
};
//2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(com);
//3.向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);
}
}
/*
* TreeSet:
* 1.向TreeSet中添加的元素必须是同一个类的。否则就会报错。
* 2.可以按照添加进集合中的元素的指定的顺序遍历。像String， 包装类等默认按照从小到大的顺序遍历。
* 3.当向TreeSet中添加自定义类的对象时，有两种排序方法：①自然排序②定制排序
* 4.自然排序：要求自定义类实现java.lang.Comparable接口，并重写compareTo(Object obj)
* 在此方法中，指明按照自定义类的哪个属性进行排序。
*
* 5.向TreeSet中添加元素时，首先按照compareTo()进行比较，一旦返回0，虽然仅是两个对象的此属性值相同，
* 但是程序会认为这两个对象是相同的，进而后一个对象就不能添加进来。
*
* >compareTo()与hashCode()以及equals()三者保持一致。
*/
@Test
public void testTreeSet1(){
Set set = new TreeSet();
// //情况一：添加的都是String字符串
// set.add(new String("AA"));//Object类型
// set.add(new String("AA"));
// set.add("AA");//不可重复性,与是否写成new没有关系
// set.add("BB");
// set.add("JJ");
// set.add("GG");
//当Person类没有实现Comparable接口时，应当想TreeSet中添加Person对象时，报ClassCastException错误
//上面的字符串没有报出这个错误，是因为String本身已经重写了这个方法
set.add(new Person("AA",33));
set.add(new Person("BB",37));
set.add(new Person("FF",42));
set.add(new Person("JJ",14));
set.add(new Person("DD",28));//在Person中添加以后按名字的大小排列
set.add(new Person("DD",30));//若判断的第一个属性相同，则只会输出一个，所以需要根据第二个属性进行判断
//set.add("GG");//属性不一致会出错，但是并不会在编译的时候出错，只会在运行的时候才报出来。
for(Object str:set){
System.out.println(str);
}
}
/*
* LinkedHashSet:使用链表维护了一个添加进集合中的顺序。
* 导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的。(在底层的位置还是无序的)
*
* LinkedHashSet插入性能略低于HashSet，但在迭代访问Set里的全部元素时，有很好的性能。
*/
@Test
public void testLinkedHashSet(){
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add(new String("AA"));
set.add(new String("AA"));
set.add("AA");//不可重复性,与是否写成new没有关系
set.add("BB");
set.add(null);
Iterator iterator = set.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}//123 456 AA BB null
}
/*
* Set:存储的元素是无序的，不可重复的！
* 1.无序性：无序性 ！= 随机性。真正的无序性，指的是元素在底层的位置是无序的。
* 2.不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去
*
* 说明：要求添加进Set中的元素所在的类，一定要重写equals()和hashCode()方法。
* 进而保证Set中元素的不可重复性！
*
* Set中的元素是如何存储的呢？使用了哈希算法。
* 当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值
* 决定了此对象在Set中的存储位置。若此位置之前没有对象存储，则这个对象直接存储到此位置。
* 若此位置已有对象存储，再通过equals()方法比较这两个对象是否相同。如果相同，后一个对象就不能再添加进来。
* 万一返回false呢，都存储。(不建议如此)
* >要求：hashCode()方法要与equals()方法一致。
*/
@Test
public void testHashSet(){
Set set = new HashSet();
set.add(123);
set.add(456);
set.add(new String("AA"));
set.add(new String("AA"));//只显示一遍
set.add("AA");//不可重复性,与是否写成new没有关系
set.add("BB");
set.add(null);
Person p1 = new Person("GG",21);
Person p2 = new Person("GG",21);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
set.add(p1);
set.add(p2);
System.out.println(set.size());
System.out.println(set);
}
}
package com.atguigu.java;
public class Person implements Comparable{
private String name;
private Integer age;
public Person() {
super();
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
@Override
public int hashCode() {//建议使用此迭代方法
final int prime = 31;
int result = 1;
result = prime * result + ((age == null) ? 0 : age.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;
Person other = (Person) obj;
if (age == null) {
if (other.age != null)
return false;
} else if (!age.equals(other.age))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
//当向TreeSet中添加Person类的对象时，依据此方法，确定按照哪个属性排序
@Override
public int compareTo(Object o) {
if (o instanceof Person) {
Person p = (Person)o;
//return this.name.compareTo(p.name);
//return -this.age.compareTo(p.age);一旦出现要判断的属性相同时，只会输出第一个，而后面相同的则
//不会输出，所以要先进行一下判断,若相同，可以根据第二个属性进行判断
int i = this.name.compareTo(p.name);
if (i == 0) {
return this.age.compareTo(p.age);
}else {
return i;
}
}
return 0;
}
}
package com.atguigu.java;
public 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, int 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;
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 != other.id)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
