Set类集合
Set接口：Collection接口的子接口，元素不可以重复，是无序。
Set接口中的方法和Collection接口的一致。
|--HashSet:内部数据结构是哈希表，是不同步的。
|--TreeSet:内部数据结构是二叉树，是不同步的。
1、HashSet类
哈希表确定元素是否相同
1、判断的是两个元素的哈希值是否相同。
如果相同，再判断两个对象的内容是否相同。
2、判断哈希值相同，其实判断的是对象的hashCode的方法。判断内容相同，用的是对象的equals方法。
注意：如果哈希值不同，是不需要判断equals方法的。
HashSet类对象调用add方法添加对象，实际上就是做了两个动作，一个是调用传入对象的hashCode方法和equals方法，一个是根据方法结果安排位置。
用hashCode算算算，没有相同的就放放放，遇到相同的就用这个调用equals方法和前面那个比较是不是一样的，具体比较什么是一样的，看你自定义的equals里写的是什么。
示例：
<span style="font-size:18px;">import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo_1 {
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add("xixi");
hs.add("xixi");
hs.add("hehehehe");
hs.add("lala");
hs.add("oooo");
System.out.println(hs);
Iterator it=hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
</span>
由于是根据哈希算法算出位置，所以元素的位置无序，即不是按顺序从角标0一个一个的存。
取出还是从角标0开始取，你存进去变成了什么顺序，你取出来就是什么顺序。
所以无序是因为算法算位置造成的
而元素不能重复是因为HashSet容器里面算到一样的hashCode值的时候（这种几率小，因为一般算出来的值都很大，不过也存在这种情况），
要进行equals方法的比较，看看这两个元素是不是相同元素造成的。
HashSet类自定义对象
HashSet集合数据结构是哈希表，所以存储元素的时候，
使用元素的hashCode方法来确定位置，如果位置相同，再通过元素的equals方法来确定是否相同。
这里演示的是用HashSet类存储自定义对象，这里注意当你创建自定义对象的时候要去覆盖Object类里面的hashCode方法和equals方法。因为哈希表主要就依靠这两个方法。
主代码：
import java.util.HashSet;
import java.util.Iterator;
import cn.bean.Person;
public class HashSetDemo_2 {
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add(new Person("李四1",21));
hs.add(new Person("李四1",21));
hs.add(new Person("李四2",22));
hs.add(new Person("李四3",23));
hs.add(new Person("李四4",24));
System.out.println(hs);
Iterator it=hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
package cn.bean;
public class Person {
private String name;
private int age;
<span style="color:#cc0000;">@Override
public int hashCode() {
return name.hashCode()+age*38;//这里年龄乘以38是为了减少哈希冲突，说白了就是减少算到一样数字的概率。
}
@Override
public boolean equals(Object obj) {
Person p=(Person)obj;
if(!(p instanceof Person)){
throw new ClassCastException("类型不符");//防止传入其他类别的对象
}
if(this==p){//如果传入同一个对象，直接返回true
return true;
}else{
return name.equals(p.name)&&age==p.age;
}
}</span>
@Override
public String toString() {
return name + " " + age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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;
}
}
2、LinkedHashSet类
LinkedHashSet类是HashSet类的子类
特点：有序，唯一
从这里可以看出，List类和Set类最大的区别就是元素是否具有唯一性。
示例：
import java.util.Iterator;
import java.util.LinkedHashSet;
public class LinkedHashSetDemo {
public static void main(String[] args) {
LinkedHashSet lhs=new LinkedHashSet();
lhs.add("abc1");
lhs.add("abc1");
lhs.add("abc2");
lhs.add("abc3");
lhs.add("abc4");
System.out.println(lhs);
Iterator it=lhs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
3、TreeSet类
|----TreeSet:可以对Set集合中的元素进行指定排序。是不同步的。
判断元素唯一性的方式：就是根据比较方法的返回结果是否是0，是0，就是相同元素，不存。
TreeSet对元素进行排序的方式一：
让元素自身具备比较功能，元素就需要实现Comparable接口，覆盖compareTo方法。
如果不要按照对象中具备的自然顺序进行排序，如果对象不具备自然顺序，怎么办？
可以使用TreeSet集合第二种排序方式二：
让集合自身具备比较功能，定义一个类实现Comparator接口，覆盖compare方法。
该类对象作为参数传递给TreeSet集合的构造函数。
示例：
import java.util.Iterator;
import java.util.TreeSet;
public class TreeSetDemo_1 {
public static void main(String[] args) {
TreeSet ts=new TreeSet();
ts.add("dnc");
ts.add("aac");
ts.add("wac");
ts.add("dnc");
ts.add("dbc");
ts.add("abc");
Iterator it=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}
通过代码的运行结果，我们可以看出，TreeSet集合是有特定顺序，并且元素唯一的集合。
TreeSet类有两种不同的排序方法，我们通过具体事例代码来分别体现着两种排序方法。
事例1、用TreeSet集合存储自定义对象Person，并按照年龄从小到大排序
这里我们选择排序方式1：使元素具有比较性。
让Person类实现了Comparable接口，覆盖compareTo方法，把按年龄比较的代码写入compareTo方法。方法里面涉及到了三元运算法则。
主代码：
import java.util.Iterator;
import java.util.TreeSet;
import cn.bean.Person;
public class TreeSetDemo_2{
public static void main(String[] args){
TreeSet ts=new TreeSet();
ts.add(new Person("wanger",22));
ts.add(new Person("lisi",26));
ts.add(new Person("zhangsan",20));
ts.add(new Person("zhouliu",20));
ts.add(new Person("xiaoer",28));
Iterator it=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}自定义的Person类：
package cn.bean;
public class Person <span style="color:#cc0000;">implements Comparable</span>{//实现Comparable接口
private String name;
private int age;
@Override
public String toString() {
return name + " " + age;
}
public Person(String name, int age) {
super();
this.name = name;
this.age = 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;
}
<span style="color:#cc0000;">@Override
public int compareTo(Object o) {//覆盖compareTo方法
// TODO Auto-generated method stub
Person p=(Person)o;
int temp=this.age-p.age;
return temp==0?this.name.compareTo(p.name):temp;
}</span>
}
事例2、用TreeSet集合存储自定义对象Person，并按照姓名自然顺序排序
这里我们使用排序方法2：建立一个比较器类，向TreeSet构造方法里传入比较器对象。
建立了一个类，实现了comparator接口，覆盖里面的compare方法，把比较姓名的代码写入compare方法，方法里面同样涉及三元运算法则
注意：这里用的Person类就是上面的Person类，已经实现了Comparable接口，并且覆盖了compareTo方法，把比较年龄的代码写入了compareTo方法，
也就是说，在元素自身拥有比较功能的同时，我们把比较器对象传入了TreeSet构造函数里面。根据运行结果可以知道，比较器具有优先权！
主代码：
import java.util.Iterator;
import java.util.TreeSet;
import cn.bean.Person;
public class TreeSetDemo_3{
public static void main(String[] args){
TreeSet ts=new TreeSet(new ComparatorByName());
ts.add(new Person("wanger",22));
ts.add(new Person("lisi",26));
ts.add(new Person("zhangsan",20));
ts.add(new Person("zhouliu",20));
ts.add(new Person("zhouliu",19));
ts.add(new Person("xiaoer",28));
Iterator it=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
}//创建的一个比较器类import java.util.Comparator;
import cn.bean.Person;
public class ComparatorByName <span style="color:#cc0000;">implements Comparator</span> {//实现Comparator接口
<span style="color:#cc0000;">public int compare(Object o1, Object o2) {//覆盖compare方法
Person p1=(Person)o1;
Person p2=(Person)o2;
int temp=p1.getName().compareTo(p2.getName());
return temp==0?p1.getAge()-p2.getAge():temp;
}</span>
}
扫一扫
1132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
