TestSet.java
package com.it.study;
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(古老的实现类、线程安全的,但效率要低于ArrayList)
* |------Set接口:存储无序的,不可重复的元素。---相当于高中的“集合”概念
>--Set使用的方法基本上都是Collection接口下定义的。
>--添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。
要求重写equals() 和 hashCode()方法保持一致。
>--1.无序性:无序性!= 随机性。真正的无序性,指的是元素在底层存储的位置是无序的。
>--2.不可重复性:当向Set中添加进相同的元素的时候,后面的这个不能添加进去。
* |------HashSet(主要的实现类)
|------LinkedHashSet(是HashSet的子类,当我们遍历集合元素时,是按照添加进去的顺序实现的;频繁的遍历,较少的添加、插入操作建议选择此)
|------TreeSet(可以按照添加进集合中的元素的指定属性进行排序)
>要求TreeSet添加进的元素必须是同一个类的!
*/
public class TestSet {
/*
* TreeSet的定制排序:
* >--compareTo()与hashCode()以及equals()三者保持一致!*/
@Test
public void testTreeSet2() {
//1.创建一个实现了Comparater接口的类对象
Comparator com = new Comparator() {
//向TreeSet中添加Customer类的对象,在此compare()方法中,指明是按照Customerde的哪一个属性排序的
@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;
}
};
//2.将此对象作为形参传递给TreeSet的构造器中
TreeSet set = new TreeSet(com);
//3.向TreeSet构造器中添加Comparator接口中的compare方法中涉及的类的对象
set.add(new Customer("AA",1003));
set.add(new Customer("GG",1013));
set.add(new Customer("BB",1007));
set.add(new Customer("HH",1001));
set.add(new Customer("FF",1005));
set.add(new Customer("PP",1005));
for(Object o : set) {
System.out.println(o);
}
}
/*
* TreeSet:
* 1.向TreeSet中添加的元素必须同类型
* 2.可以按照添加进集合中的元素指定的顺序遍历,默认从小到大
* 3.当向TreeSet中添加自定义类的对象时,有两种排序方法:
* |--①自然排序:要求自定义类实现java.lang.Comparble接口并重写其compareTo(Object obj)的抽象方法,
* 在此方法中指明按照自定义类中的哪一个属性排序
* |--②
* 4.向TreeSet中添加元素时,首先按照compareTo()进行比较,一旦返回0,虽然仅仅是两个对象的此属性值相同,
* 但是程序会认为这两个对象是相同的,导致后一个对象就不能添加进去
* >--compareTo()与hashCode()以及equals()三者保持一致!*/
@Test
public void testTreeSet1() {
Set set = new TreeSet();
// set.add(123);
// set.add(456);/String 与Int类型不能同时存在
// set.add("AA");
// set.add("AA");
// set.add("DD");
// set.add("BB");
// set.add("CC");
//当Person类没有实现Comparable接口时,当向TreeSet中添加Preson对象时,报ClassCastException错
set.add(new Person("CC",23));
set.add(new Person("AS",24));
set.add(new Person("AW",25));
set.add(new Person("CG",12));
set.add(new Person("FD",43));
set.add(new Person("WE",22));
set.add(new Person("TO",22));
for(Object o:set) {
System.out.println(o);
}
}
/* 1.LinkedHashSet:使用链表维护了一个添加进集合中的顺序。导致当我们遍历LinkedHasSet集合元素时,是按照添加进去的顺序遍历的
* 2.LinkedhashSet插入性能略低于HashSet,但在迭代访问Set里的全部元素时有很好的性能。
* */
@Test
public void testLinkedHashSet() {
Set set = new LinkedHashSet();
set.add(123);
set.add(456);
set.add("AA");
set.add("BB");
set.add("AA");
set.add(null);
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
}
/*Set:存储的元素是无序的,不可重复的
* 1.无序性 不等于 随机性!无序性是指元素在底层存储的位置是无序的
* 2.不可重复性:不能向set中添加相同的元素
* 3.添加进Set集合中的元素所在的类一定要重写equals() 和 hashCode()。 要求重写equals() 和 hashCode()方法保持一致。
* 4.Set中元素的存储用到的算法是————哈希算法
* 5.当向Set中添加对象时,首先调用此对象所在类的hashCoude()方法,计算此对象的哈希值,此哈希值决定了此对象在Set中的存储位置。
* 若此位置之前没有对象存储,则这个对象直接存储到此位置,若此位置已有对象存储,再通过equals()比较这两个对象是否相同。如果
* 相同,后一个对象就不能再添加进来。
* >--要求:hashCode()方法要与equals()方法值一致。
* */
@Test
public void testHashSet() {
Set set = new HashSet();
set.add(123);
set.add(456);
set.add("AA");
set.add("BB");
set.add("AA");
set.add(null);
Person p1 = new Person("GG",23);
Person p2 = new Person("MM",21);
Person p3 = new Person("MM",21);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p3.hashCode());
set.add(p1);
set.add(p2);
System.out.println(set.size());
System.out.println(set);
}
}
Person.java
package com.it.study;
public class Person implements Comparable{
private String name;
private Integer 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 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;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
public Person(String name, Integer age) {
super();
this.name = name;
this.age = age;
}
public Person() {
super();
}
//当向TreeSet中添加Person类对象时,依据此方法确定按照哪一个属性排列
@Override
public int compareTo(Object o) {
if(o instanceof Person) {
Person p = (Person)o;
//return this.age.compareTo(p.age);
int i = this.age.compareTo(p.age);
if(i == 0) {
return this.name.compareTo(p.name);
}else{
return 1;
}
}
return 0;
}
}
Customer.java
package com.it.study;
public class Customer {
private String name;
private Integer id;
public Customer() {
super();
}
public Customer(String name, Integer id) {
super();
this.name = name;
this.id = 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;
}
@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;
}
}