Java 7之集合类型第6篇 - Set集合的实现
来源:互联网 发布:php统计页面访问量 编辑:程序博客网 时间:2024/06/01 03:57
Set接口中定义了一些Set常见的操作,与Collection接口中定义的方法差不多。AbstractSet抽象类中只实现了equals()、hashCode()和removeAll()方法,非常简单,有兴趣的读者可以自己去查看。
1、HashSet
HashSet类的特点:能够快速定位集合中的元素、集合中的元素无序(这里所谓的无序并不是完全无序,只是不像List集合按对象的插入顺序保存对象)。
有了HashMap的实现,则HashSet的实现非常简单,只需要将Set中的元素做为Map中的key值来保存即可。
public class HashSet<E> extends AbstractSet<E> implements Set<E>, Cloneable, java.io.Serializable{ private transient HashMap<E,Object> map; // 使用map的key来保存Set元素 private static final Object PRESENT = new Object();// 值为一个Object对象 public HashSet() { map = new HashMap<>(); } /** * Constructs a new set containing the elements in the specified * collection. The HashMap is created with default load factor * (0.75) and an initial capacity sufficient to contain the elements in * the specified collection. */ public HashSet(Collection<? extends E> c) { map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16)); addAll(c); } // 省略其他构造函数}
public Iterator<E> iterator() { // 循环HashMap中的key值 return map.keySet().iterator(); } public boolean contains(Object o) { // 查找HashMap中的key值 return map.containsKey(o); } public boolean add(E e) { // key为Set中要添加的元素,值为一个空的Object对象 return map.put(e, PRESENT)==null; }
由HashSet类实现的Set集合中的对象必须是惟一的,因此需要添加到由HashSet类实现的Set集合中的对象,需要重新实现equals()方法,从而保证插入集合中对象的标识的惟一性。
由HashSet类实现的Set集合的排列方式为按照哈希码排序,根据对象的哈希码确定对象的存储位置,因此需要添加到由HashSet类实现的Set集合中的对象,还需要重新实现hashCode()方法,从而保证插入集合中的对象能够合理地分布在集合中,以便于快速定位集合中的对象。
public class Person{private String name;private long id_card;public Person(String name,long id_card){this.name = name;this.id_card = id_card;}public long getId_card(){return id_card;}public void setId_card(long id_card){this.id_card = id_card;}public String getName(){return name;}public void setName(String name){this.name = name;}public int hashCode(){//重新实现hashCode()方法final int PRIME = 31;int result = 1;result = PRIME*result+(int)(id_card^(id_card>>>32));result = PRIME*result+((name ==null)?0:name.hashCode());return result;}public boolean equals(Object obj){//重新实现equals()方法if(this == obj){return true;}if(obj == null){return false;}if(getClass()!=obj.getClass()){return false;}final Person other = (Person)obj;if(id_card!=other.id_card){return false;}if(name == null){if(other.name != null){return false;}}else if(!name.equals(other.name)){return false;}return true;}}编写测试程序:
public class TestSet{public static void main(String args[]){Set<Person> hashSet = new HashSet<Person>();hashSet.add(new Person("马先生",22015));hashSet.add(new Person("李小姐",22018));hashSet.add(new Person("李先生",22020));Iterator<Person> it = hashSet.iterator();while(it.hasNext()){Person person = it.next();System.out.println(person.getName()+""+person.getId_card());}}}程序的运行结果如下:
李小姐 22018
李先生 22020
马先生 22015
如果既想保留HashSet类快速定位集合中对象的优点,又想让集合中的对象按插入的顺序保存,可以通过HashSet类的子类LinkedHashSet实现Set集合。
2、LinkedHashSet
LinkedHashSet,顾名思义,就是在Hash的实现上添加了Linked的支持。对于LinkedHashSet,在每个节点上通过一个链表串联起来,这样,就可以保证确定的顺序。对于希望有常量复杂度的高效存取性能要求、同时又要求排序的情况下,可以直接使用LinkedHashSet。
它实现了Set接口。存入Set的每个元素必须是唯一的,因为Set不保存重复元素。但是Set接口不保证维护元素的次序。LinkedHashSet具有HashSet的查询速度,且内部使用链表维护元素的顺序(插入的顺序),于是在使用迭代器便利Set时,结果会按元素插入的次序显示。
在HashSet中有一个构造方法,如下:
HashSet(int initialCapacity, float loadFactor, boolean dummy) { map = new LinkedHashMap<>(initialCapacity, loadFactor); }这个构造函数是包访问权限,且底层使用LinkedHashMap来实现,所以LinkedHashSet是通过调用这个构造函数来获取实例而保持元素的插入顺序的,源代码如下:
public class LinkedHashSet<E> extends HashSet<E> implements Set<E>, Cloneable, java.io.Serializable { private static final long serialVersionUID = -2851667679971038690L; public LinkedHashSet(int initialCapacity, float loadFactor) { super(initialCapacity, loadFactor, true); } public LinkedHashSet(int initialCapacity) { super(initialCapacity, .75f, true); } public LinkedHashSet() { super(16, .75f, true); } public LinkedHashSet(Collection<? extends E> c) { super(Math.max(2*c.size(), 11), .75f, true); addAll(c); }}继续编写上一个测试程序,将
Set<Person> hashSet = new HashSet<Person>();改为
Set<Person> hashSet = new LinkedHashSet<Person>();后,输出结果发现,和插入的顺序一致。
3、TreeSet
TreeSet类不仅实现了Set接口,还实现了java.util.SortedSet接口,从而保证在遍历集合时按照递增的顺序获得对象。遍历对象时可能是按照自然顺序递增排列,因此存入用TreeSet类实现的Set集合的对象必须实现Comparable接口;也可能是按照指定比较器递增排序,即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。
下面先看 TreeSet 类的部分源代码:
public class TreeSet<E> extends AbstractSet<E> implements NavigableSet<E>, Cloneable, java.io.Serializable{// 使用 NavigableMap 的 key 来保存 Set 集合的元素 private transient NavigableMap<E,Object> m; // 使用一个 PRESENT 作为 Map 集合的所有 value private static final Object PRESENT = new Object(); //----------构造函数------------------------------- // 包访问权限的构造器,以指定的 NavigableMap 对象创建 Set 集合 TreeSet(NavigableMap<E,Object> m) { this.m = m; } // 以自然排序方式创建 public TreeSet() { this(new TreeMap<E,Object>()); } // 以指定的排序方式创建 public TreeSet(Comparator<? super E> comparator) { this(new TreeMap<>(comparator)); } public TreeSet(Collection<? extends E> c) { this(); // 调用无参的默认构造器 addAll(c); // 添加Collection中已有的元素 } // 以SortedSet为基础创建TreeSet public TreeSet(SortedSet<E> s) { this(s.comparator()); addAll(s); }}
提供了获取部分元素的方法如下:
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive,E toElement, boolean toInclusive) { return new TreeSet<>(m.subMap(fromElement, fromInclusive,toElement, toInclusive)); } public NavigableSet<E> headSet(E toElement, boolean inclusive) { return new TreeSet<>(m.headMap(toElement, inclusive)); } public NavigableSet<E> tailSet(E fromElement, boolean inclusive) { return new TreeSet<>(m.tailMap(fromElement, inclusive)); } public SortedSet<E> subSet(E fromElement, E toElement) { return subSet(fromElement, true, toElement, false); } public SortedSet<E> headSet(E toElement) { return headSet(toElement, false); } public SortedSet<E> tailSet(E fromElement) { return tailSet(fromElement, true); }
从如上的几个构造器可以看出,其实底层还是通过TreeMap来实现的。
public class Person implements Comparable{private String name;private long id_card;public Person(String name,long id_card){this.name = name;this.id_card = id_card;}public String getName(){return name;}public void setName(String name){this.name = name;}public long getId_card(){return id_card;}public void setId_card(long id_card){this.id_card = id_card;}public int compareTo(Object o){//默认按编号升序排序Person person = (Person)o;int result = id_card>person.id_card?1:(id_card==person.id_card?0:-1);return result;}}
public class TestSet{public static void main(String args[]){TreeSet<Person> treeSet = new TreeSet<Person>();Person p1 = new Person("马先生",22015);Person p2 = new Person("李先生",22016);Person p3 = new Person("王小姐",22018);Person p4 = new Person("尹先生",22020);Person p5 = new Person("王先生",22012);treeSet.add(p1);treeSet.add(p2);treeSet.add(p3);treeSet.add(p4);treeSet.add(p5);System.out.println("初始化的集合:");Iterator<Person> it = treeSet.iterator();while(it.hasNext()){Person p = it.next();System.out.println(p.getId_card()+""+p.getName());}System.out.println("截取前面部分得到的集合:");it = treeSet.headSet(p1).iterator();while(it.hasNext()){Person p = it.next();System.out.println(p.getId_card()+""+p.getName());}System.out.println("截取中间部分得到的集合:");it = treeSet.subSet(p1,p3).iterator();while(it.hasNext()){Person p = it.next();System.out.println(p.getId_card()+""+p.getName());}System.out.println("截取后面部分得到的集合:");it = treeSet.tailSet(p3).iterator();while(it.hasNext()){Person p = it.next();System.out.println(p.getId_card()+""+p.getName());}}}程序的运行结果如下:
初始化的集合:
22012 王先生
22015 马先生
22016 李先生
22018 王小姐
22020 尹先生
截取前面部分得到的集合:
22012 王先生
截取中间部分得到的集合:
22015 马先生
22016 李先生
截取后面部分得到的集合:
22018 王小姐
22020 尹先生
在使用由TreeSet类实现的Set集合时,也可以通过单独的比较器对集合中的对象进行排序。
比较器既可以作为一个单独的类,也可以作为对应类的内部类,本例中移内部类的形式实现比较器。
import java.util.Comparator;public class Person implements Comparable{private String name;private long id_card;public Person(String name,long id_card){this.name = name;this.id_card = id_card;}public String getName(){return name;}public void setName(String name){this.name = name;}public long getId_card(){return id_card;}public void setId_card(long id_card){this.id_card = id_card;}public int compareTo(Object o){//默认按编号升序排序Person person = (Person)o;int result = id_card>person.id_card?1:(id_card==person.id_card?0:-1);return result;}static class PersonComparator implements Comparator{public static final int NAME = 1;public static final int ID_CARD = 2;private int orderByColumn = 1;//默认为按姓名排序public static final boolean ASC = true;public static final boolean DESC = false;private boolean orderByMode = true;//默认为按升序排序public int compare(Object o1,Object o2){//实现Comparator接口的方法Person p1 = (Person)o1;Person p2 = (Person)o2;int result = 0;//默认的判断结果为两个对象相等switch(orderByColumn){//判断排序条件case 1:String s1 = CnToSpell.getFullSpell(p1.getName());String s2 = CnToSpell.getFullSpell(p2.getName()); if(orderByMode){//升序result = s1.compareTo(s2);}else{//降序result = s2.compareTo(s1);}break;case 2:if(orderByMode){//升序result = (int)(p1.getId_card()-p2.getId_card());}else{//降序result = (int)(p2.getId_card()-p1.getId_card());}break;}return result;}public void orderByColumn(int orderByColumn){//用来设置排序条件this.orderByColumn = orderByColumn;}public void orderByMode(boolean orderByMode){//用来设置排序方式this.orderByMode = orderByMode;}}}
import java.util.*;public class TestSet{public static void main(String args[]){TreeSet<Person> treeSet1 = new TreeSet<Person>();Person p1 = new Person("马先生",22015);Person p2 = new Person("李先生",22016);Person p3 = new Person("王小姐",22018);treeSet1.add(p1);treeSet1.add(p2);treeSet1.add(p3);System.out.println("客户化排序前,默认按编号升序排序:");//新创建一个Set集合,不进行客户化排序,默认按编号升序排序TreeSet<Person> treeSet2 = new TreeSet<Person>(treeSet1);//通过构造函数初始化集合Iterator<Person> it1 = treeSet2.iterator();while(it1.hasNext()){Person p = it1.next();System.out.println(p.getId_card()+""+p.getName());}System.out.println("客户化排序后,按编号降序排序:");//新创建一个Set集合,进行客户化排序,客户化排序方式为按编号降序排序Person.PersonComparator pc = new Person.PersonComparator();//创建比较器(内部类)的实例pc.orderByColumn(Person.PersonComparator.ID_CARD);//设置排序依据的属性pc.orderByMode(Person.PersonComparator.DESC);//设置排序方式TreeSet<Person> treeSet3 = new TreeSet<Person>(pc);//必须通过构造函数设置比较器treeSet3.addAll(treeSet1);//初始化集合Iterator<Person> it2 = treeSet3.iterator();while(it2.hasNext()){Person p = it2.next();System.out.println(p.getId_card()+""+p.getName());}}}程序的运行结果如下:
客户化排序前,默认按编号升序排序:
22015 马先生
22016 李先生
22018 王小姐
客户化排序后,按编号降序排序:
22018 王小姐
22016 李先生
22015 马先生
- Java 7之集合类型第6篇 - Set集合的实现
- Java 7之集合类型第6篇 - Set集合的实现
- Java 7之集合类型第1篇 - Java集合
- Java 7之集合类型第2篇 - List集合
- Java 7之集合类型第2篇 - List集合
- Java 7之集合类型第3篇 - LinkedList
- Java 7之集合类型第4篇 - HashMap
- Java 7之集合类型第5篇 - TreeMap
- Java 7之集合类型第4篇 - HashMap
- Java 7之集合类型第4篇
- Java集合之Set集合
- Java集合之Set集合
- Java集合之Map类型的集合
- JAVA集合之SET
- java集合之Set
- Java集合之set
- Java集合之Set
- Java集合之Set
- Springmvc,Spring MVC文件上传
- 如何解决不同的webApp的session 共享问题
- RSA加密的填充模式
- Linux 中的定时器 crontab
- 场景的信息保存成xml或json,并恢复场景
- Java 7之集合类型第6篇 - Set集合的实现
- hibernate实践之一 .
- Struts2从后台传递数据到前台的主要方法和流程
- “Invalid configuration file. File "I:/My Virtual Machines/Windows XP english Professional/Windows XP
- Javascript数组方法
- java串口环境配置
- Linux服务器性能评估与优化
- 在 vi 中使用 Buffer 和 标记位置
- 解决VM虚拟机导致硬盘灯常亮,很卡的问题