JAVA第七章-集合（三）

Set接口

(Set中常用的方法都是Collection下定义的。

|…..HashSet（主要实现类）

|…..LinkedHashSet

|…..TreeSet

Set:存储的元素是无序的，不可重复的

1.无序性， 无序性！=随机性 真正的无序性指的是元素在底层存储的位置是无序的。

2. 不可重复性：当向Set中添加进相同的元素的时候，后面的这个不能添加进去

3.说明，要求添加进Set中的元素所在的类，一定要重写equals()和hashCode（）方法进而保证Set中元素的不可重复性

Set中元素的如何存储的？使用了哈希算法

当向Set中添加对象时，首先调用此对象所在类的hashCode()方法，计算此对象的哈希值，此哈希值决定了此对象在Set中的存储位置，若此位置之前没有对象存储，则这个对象直接存储到此位置，若此位置已有对象存储，再通过equals()比较这俩个对象是否相同，如果相同，后一个对象就不能添加进来，万一返回false呢，都存储（不建议如此）

要求，hashCode（）方法便于equals()方法一致。

HashSet

```
public void testHashSet(){
Set set=new HashSet();
set.add(123);
set.add(null);//set可以添加null
CollectionPerson p1=new  CollectionPerson("AA",22);
CollectionPerson p2=new  CollectionPerson("AA",22);
System.out.println(p1.hashCode());
System.out.println(p2.hashCode());
System.out.println(p1.equals(p2));
java.util.Iterator ii=set.iterator();
while(ii.hasNext()){
System.out.println(ii.next());
}

public class CollectionPerson {
private String name;
private int id;
public CollectionPerson(String name, int id) {
super();
this.name = name;
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "CollectionPerson [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;
CollectionPerson other = (CollectionPerson) 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;
}

}

运行结果

723

3723

true

null

123

*inkedHashSet:

*使用链表去维护了一个添加进的集合的顺序，导致当我们遍历LinkedHashSet集合元素时，是按照添加进去的顺序遍历的。

LinkedHashSet插入性能低于HashSet,但是迭代访问Set 里的全部元素时有很好的性能。

public void testLinkedHashSet(){
Set set=new LinkedHashSet();
set.add(123);
set.add(456);
set.add(null);
set.add(new CollectionPerson("AA",22 ));
set.add(new CollectionPerson("GG",32));
Iterator ii=set.iterator();
for(Object i:set){
System.out.println(i);
}
System.out.println(set); //打印是按顺序打印但是存储是按照随机存储。

运行结果

3723
3723
true
null
123
123
456
null
CollectionPerson [name=AA, id=22]
CollectionPerson [name=GG, id=32]
[123, 456, null, CollectionPerson [name=AA, id=22], CollectionPerson [name=GG, id=32]]

TreeSet

1.向TreeSet中添加的元素必须是同一个类的。

2.可以按照添加进去集合的元素的指定的顺序遍历，向String包装类，等默认按照从小到大的顺序遍历

3.当向TreeSet中添加自定义类的对象时，有俩种方法①自然排序②定制排序

4向TreeSet中添加元素时。首先按照compareTo()进行比较，一旦返回0，虽然仅是俩个对象的此属性相同，但是程序会认为这俩个对象是相同的，进而后一个对象就不能被添加进来。

*compareaTo 与hashCode（）以及equals()三者一致。

自然排序

要求自定义类要实现java.lang.Comparable接口并重写其compareTo(Object obj）的抽象方法，在此方法中指明按照自定义的那个属性进行排序。

package Collection;

public class Person implements Comparable {
private String name;
private Integer id;

public Person() {
super();
}
public Person(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 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;
Person other = (Person) 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;
}
@Override
public String toString() {
return "Person [name=" + name + ", id=" + id + "]";
}
//在重写方法时 TreeSet中进行添加对象时，依据此方法，确定按照的属性排序
@Override
public int compareTo(Object o) {
if(o instanceof Person){
Person p=(Person)o;
int i=this.id.compareTo(p.id);
if(i==0){
return this.name.compareTo(p.name);
}else{
return i;
}
}
return 0;
}

}
//主方法
package Collection;

import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;
//当person类没有实现Comperable接口时：当向TreeSet中添加Person对象时。报ClassCastExcetpion
public class testTreeSet {
@Test
public void testOne(){
Set set=new TreeSet();
set.add(new Person("AA",123));
set.add(new Person("EE",124));
set.add(new Person("DD",126));
set.add(new Person("FF",124));
set.add(new Person("QQ",127));
set.add(new Person("ZZ",130));
for(Object str:set){
System.out.println(str);
}
}
}
//运行结果
Person [name=AA, id=123]
Person [name=EE, id=124]
Person [name=FF, id=124]
Person [name=DD, id=126]
Person [name=QQ, id=127]
Person [name=ZZ, id=130]

定制排序

package Collection;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

import org.junit.Test;

public class testTreeSet {
@Test
public void testTwo(){
//①创建一个实现Comparator接口的类对象。
Comparator com=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;
int i=c1.getId().compareTo(c2.getId());
if(i==0){
return c1.getName().compareTo(c2.getName());
}else{
return i;
}
}
return 0;
}

};
//②将此对象作为形参传递给TreeSet的构造器中。
Set set=new TreeSet(com);
//③向TreeSet中添加comparator接口中的compare方法中涉及的类的对象。
//向TreeSet中添加Customer类的对象，在此comparartor()方法中，指明是按照Customer的那个属性排序。
set.add( new Customer("AA",124));
set.add( new Customer("SS",123));
set.add( new Customer("GG",126));
set.add( new Customer("mm",125));
set.add( new Customer("ss",123));
for(Object str:set){
System.out.println(str);
}
}
}

或者采用

Set 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;
int i=c1.getId().compareTo(c2.getId());
if(i==0){
return c1.getName().compareTo(c2.getName());
}else{
return i;
}
}
return 0;
}

});

set.add( new Customer("AA",124));
set.add( new Customer("SS",123));
set.add( new Customer("GG",126));
set.add( new Customer("mm",125));
set.add( new Customer("ss",123));
for(Object str:set){
System.out.println(str);
}
}
}
//运行结果
Customer [name=SS, id=123]
Customer [name=ss, id=123]
Customer [name=AA, id=124]
Customer [name=mm, id=125]
Customer [name=GG, id=126]