20151118 Set集合+HashSet类+TreeSet类

最新推荐文章于 2019-01-28 18:56:28 发布
最新推荐文章于 2019-01-28 18:56:28 发布
阅读量449 收藏
点赞数
分类专栏： java实用教程 文章标签： java使用教程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongguobaobao43/article/details/49913137
版权

Set集合为集类型，集是最简单的一种集合，存放于集合中的对象不按特定方式排序，只是简单的把对象加入集合中，类似于向口袋里放东西。

1. HashSet类
  • 由HashSet类实现的Set集合的优点是能够快速定位集合中的元素。
  • 由HashSet类实现的Set集合中的对象必须是唯一的，所以需要添加到由HashSet类实现的Set集合中的对象，需要重新实现equals()方法。

  • 由HashSet类实现的Set集合按照哈希码排序，根据对象的哈希码确定对象的存储位置，所有需要添加到由HashSet类实现的Set集合中的对象，还需要重新实现hashCode()方法。从而保证插入集合中的对象能够合理分布在集合中，以便于快速定位集合中的对象。
    【例】使用HashSet类。创建一个Person类，该类需要重新实现equals(Object obj)方法和hashCode()方法，以保证对象标识的唯一性和存储分布的合理性。
    代码如下：

    import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;

public class testHashSet {
    public static void main(String[] args){
        Set<Person> hashSet = new HashSet<Person>();
        Person person1 = new Person("马先生", 220181);
        Person person2 = new Person("李先生", 220186);
        Person person3 = new Person("王小姐", 220193);
        hashSet.add(person1);
        hashSet.add(person2);
        hashSet.add(person3);

        Iterator<Person> it = hashSet.iterator();
        while(it.hasNext()){
        Person person = it.next();
        System.out.println(person.getName() + "   " + person.getId_card());
        }
    }
}

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 String getName(){
        return this.name;
    }
    public long getId_card(){
        return this.id_card;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setId_card(long id_card){
        this.id_card = id_card;
    }

    public int hashCode(){
        final int PRIME = 31;
        int result = 1;
        result = result * PRIME + (int)(this.id_card ^ (this.id_card >>> 32));
        result = result * PRIME + (int)((this.name == null) ? 0 : name.hashCode());
        return result;
    }

    public boolean equals(Object obj){
        if(this == obj)
            return true;
        if(null == obj)
            return false;
        if(this.getClass() != obj.getClass())
            return false;
        final Person other = (Person)obj;
        if(this.id_card != other.id_card)
            return false;
        if(null == this.name){
            if(null != other.name)
                return false;
        }else if(!this.name.equals(other.name)){
            return false;
        }
        return true;
    }
}

    运行截图如下：
    运行截图

如果既想保留HashSet类快速定位集合中对象的优点，又想让集合中的对象按插入的顺序保存，可以通过HashSet类的子类LinkedHashSet实现Set集合。即将Person类中的如下代码：

Set< Person > hashSet = new HashSet< Person >();

替换为如下代码：

Set< Person > hashSet = new LinkedHashSet< Person >();
2. TreeSet类

TreeSet类不仅实现了Set接口，还实现了java.util.SortedSet接口，从而保证了在遍历集合时按照递增的顺序获得对象。

  • 如果遍历对象时按照自然顺序递增排列，则由TreeSet类实现的Set集合存入的对象必须实现Comparable接口。
  • 如果遍历对象时按照指定比较器递增排列，则由TreeSet类实现的Set集合存入的对象必须实现自定义比较器类。

TreeSet类通过实现java.util.SortedSet接口增加的方法如下：

  • comparator()：获得对该集合采用的比较器，返回值为comparator类型，如果未采用任何比较器则返回null。
  • first()：返回在集合中的排序位于第一的对象。
  • last()：返回在集合中的排序位于最后的对象。
  • headSet(E toElement)：截取在toElement（不包含）之前的所有对象，重新生成一个Set集合并返回。
  • subSet(E fromElement, E toElement)：截取在fromElement（包含）之后，toElement（不包含）之前- 的所有对象，重新生成一个Set集合并返回。
  • tail(E fromElement)：截取在fromElement（包含）之后的所有对象，重新生成一个Set集合并返回。
2.1 按照自然顺序递增排列

【例】使用TreeSet类。创建一个Person类，由TreeSet类实现的Set集合中的对象要求必须实现java.lang.Comparable接口，这里实现的排序方式为按编号升序排列。
代码如下：

import java.util.Set;
import java.util.TreeSet;
import java.util.Iterator;
import java.util.SortedSet;

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 this.name;
    }
    public long getId_card(){
        return this.id_card;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setId_card(long id_card){
        this.id_card = id_card;
    }

    public int compareTo(Object obj){
        Person person = (Person)obj;
        int result = (this.id_card > person.id_card) ? 1 : (this.id_card == person.id_card ? 0 : -1);
        return result;
    }
}

public class testTreeSet {
    public static void main(String[] args){
        TreeSet<Person> treeSet = new TreeSet<Person>();
        Person person1 = new Person("马先生", 220181);
        Person person2 = new Person("李先生", 220186);
        Person person3 = new Person("王小姐", 220193);
        Person person4 = new Person("尹先生", 220196);
        Person person5 = new Person("王先生", 220175);
        treeSet.add(person1);
        treeSet.add(person2);
        treeSet.add(person3);
        treeSet.add(person4);
        treeSet.add(person5);

        System.out.println("初始化的集合：");
        Iterator<Person> it = treeSet.iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------ " + person.getName() + "  " + person.getId_card());
        }

        System.out.println("截取前面部分得到的集合：");
        //it = treeSet.headSet(person1).iterator();
        SortedSet<Person> treeSet1 = treeSet.headSet(person1);
        it = treeSet1.iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------ " + person.getName() + " " + person.getId_card());
        }

        System.out.println("截图中间部分得到的集合：");
        it = treeSet.subSet(person1, person3).iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------ " + person.getName() + " " + person.getId_card());
        }

        System.out.println("截取最后部分得到的集合：");
        it = treeSet.tailSet(person3).iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------ " + person.getName() + " " + person.getId_card());
        }           
    }
}

运行截图如下：
运行截图

2.2 按照指定比较器递增排列

【例】自定义比较器。在使用由TreeSet类实现的Set集合时，通过单独的比较器对集合中的对象进行排序，比较器类既可以作为一个单独的类，也可以作为对应类的内部类，这里以单独类为例。

代码如下：

import java.util.Comparator;
import java.util.Iterator;
import java.util.TreeSet;

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 this.name;
    }
    public long getId_card(){
        return this.id_card;
    }
    public void setName(String name){
        this.name = name;
    }
    public void setId_card(long id_card){
        this.id_card = id_card;
    }

    public int compareTo(Object obj){
        Person person = (Person)obj;
        int result = (this.id_card > person.id_card) ? 1 : (this.id_card == person.id_card ? 0 : -1);
        return result;
    }
}

//user_defined comparator
class PersonComparator implements Comparator{
    public static final int NAME = 1;
    public static final int ID_CARD = 2;
    private int orderByColumn = 1; //default sort by name 
    public static final boolean ASC = true;
    public static final boolean DESC = false;
    private boolean orderByMode = true; //default sort by ASC
    @Override
    public int compare(Object obj1, Object obj2) {
        // TODO Auto-generated method stub
        int result = 0;
        Person person1 = (Person)obj1;
        Person person2 = (Person)obj2;
        switch(orderByColumn){
        case 2:
            if(orderByMode)
                result = (int)(person1.getId_card() - person2.getId_card());
            else
                result = (int)(person2.getId_card() - person1.getId_card());
            break;
        default:
            String s1 = person1.getName();
            String s2 = person2.getName();
            if(orderByMode)
                result = s1.compareTo(s2);
            else
                result = s2.compareTo(s1);
        }
        return result;
    }
    public void orderByColumn(int orderByColumn){
        this.orderByColumn = orderByColumn;
    }
    public void orderByMode(boolean orderByMode){
        this.orderByMode = orderByMode;
    }

}

public class UserDefinedCompraratorTS {
    public static void main(String[] args){
        Person p1 = new Person("Mr ma", 220181);
        Person p2 = new Person("Mr li", 220186);
        Person p3 = new Person("Miss wang", 220193);
        TreeSet<Person> treeSet = new TreeSet<Person>();
        treeSet.add(p1);
        treeSet.add(p2);
        treeSet.add(p3);
        System.out.println("客户化排序前，默认按编号升序排序：");
        TreeSet<Person> treeSet2 = new TreeSet<Person>(treeSet);
        Iterator<Person> it = treeSet2.iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------" + person.getId_card() + " " + person.getName());
        }
        System.out.println("客户化排序后，按编号降序排序：");
        PersonComparator pc3 = new PersonComparator();
        pc3.orderByColumn(PersonComparator.ID_CARD);
        pc3.orderByMode(PersonComparator.DESC);
        TreeSet<Person> treeSet3 = new TreeSet<Person>(pc3);
        treeSet3.addAll(treeSet);
        it = treeSet3.iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------" + person.getId_card() + " " + person.getName());
        }
        System.out.println("客户化排序后，按姓名升序排序：");
        PersonComparator pc4 = new PersonComparator();
        pc4.orderByColumn(PersonComparator.NAME);
        TreeSet<Person> treeSet4 = new TreeSet<Person>(pc4);
        treeSet4.addAll(treeSet);
        it = treeSet4.iterator();
        while(it.hasNext()){
            Person person = it.next();
            System.out.println("------" + person.getId_card() + " " + person.getName());
        }
    }
}

运行截图如下：
运行截图

Evelyn_hf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java中的几种泛型类——HashSet、HashMap、TreeSet、TreeMap，遍历map，排序，HashTable比较
木羊的专栏
05-08 2766
HashSet HashSet泛型类在数据组织上类似于数学上的集合，可以进行“交”、“并”、“差”等运算。 HashSet泛型类创建的对象称为集合，如：     HashSet set =  HashSet();     那么set就是一个可以存储string类型数据的集合，set可以调用add(String s)方法将string类型的数据添加到集合中。添加到集合中的数据称为
Collections的排序总结
fan煮鸡蛋的博客
12-07 3531
数组也有Arrays.sort()方法 但是这里讲的是Collections.sort()方法.        格式一： public static &lt;T extends Comparable&lt;? super T&gt;&gt; void sort(List&lt;T&gt; list) 说明：该方法中的泛型&lt;T&gt;都是Comparable接口的子类，即只有是Co...
集合类（三）：Set集合
千里之行，始于足下
09-16 157
4、Set集合 Set集合为集类型，集是最简单的一种集合，存放于集中的对象不按特定方式排序，只是简单地把对象加入集合中，类似于向口袋里放东西。对集中存在的对象的访问和操作是通过对象的引用进行的，因此在集中不能存放重复对象。Set集合包括Set接口以及Set接口的所有实现类。因为Set接口继承了Collection接口，所以Set接口拥有Collection接口提供的所有常用方法。 [b]（1）...
Java 基础学习之Set集合
那些年我们一起学JAVA
05-22 3661
一 Set 的特点无序(没有下标)不重复.主要的分类有HashSet 和 TreeSet1.HashSet 特点：         （1）底层使用数据结构的hash算法实现的，因此具有很好的存取，查找的性能。        （2）hashSet是线程不安全，所以它相对于线程安全的更快一些。         （3）hashSet值可以为null。        （4） 不存在顺序1.去重实例publ...
Set集合
weixin_30760895的博客
03-30 55
Set集合为集类型，集是最简单的一种集合，存放于集中的对象不按特定方式排序，只是简单地把对象加入集合中，类似于向口袋里放东西。对集中存在的对象的访问和操作是通过对象的引用进行的，因此在集中不能存放重复对象。Set集合包括Set接口以及Set接口的所有实现类。因为Set接口继承了Collection接口，所以Set接口拥有Collection接口提供的所有常用方法。 （1）使用HashSet类 由H...
Java集合排序（面试必考点之一）
weixin_41797098的博客
01-28 285
集合是Java面试必考知识点，而集合的排序也是非常重要的，工作中经常用到，那么这个知识点也是必须要掌握的，下面是我曾经面试时被面试官问的问题：根据API可知，Java集合...
Java—Set集合详解（HashSet/LinkedHashSet/TreeSet/EnumSet）
12-21
  Set集合类似于一个容器，程序把很多对象保存到Set集合中，Set集合对添加顺序不记录，当有重复的对象保存到Set集合时，不会新增后加的重复对象。 Set集合的特点 Set集合无重复元素，add()方法添加相同元素时，...
Java期末复习-类集框架
08-06
List接口、ArrayList类、Vector类、栈操作类Stack、链表操作类LinkList、队列操作接口Queue、Set接口、HashSet类、TreeSet类、SortedSet接口 双值操作接口Map(key->value)及其子接口、子类： SortedMap接口、HashMap...
浅谈java集合类以及示例
12-20
聊一聊java 的集合类 概述 Java中集合分为两种类型 第一种：以单个元素存储。其超级父接口是：java.util....Set下常用的有HashSet、TreeSet Queue又有Deque、Stack、LinkedList SET ​ 无序不可重复,没有下标。规定S
java HashSet 集合排序
10-30
java HashSet 集合排序,需要通过利用TreeSet集合排序。2013-10-30。
java集合类学习与实例
11-21
实现类：红色Collection|_____Set(HashSet)| |_____SortedSet(TreeSet)|_____List(LinkedList,ArrayList) Collection:集合层次中的根接口，JDK没有提供这个接口的实现类。Set:不能包含重复的元素，子接口SortedSet是...
java中的TreeMap类使用实例解析
web开发自学
11-29 112
使用TreeMap类 TreeMap类不仅实现了Map接口，还实现了Map接口的子接口java.util.SortedMap。由TreeMap类实现的Map集合，不允许键对象为null，因为集合中的映射关系是根据键对象按照一定顺序排列的，TreeMap类通过实现SortedMap接口得到的方法如表1所示。 表1 TreeMap类通过实现java.util.SortedMap接口得到...
Java集合类TreeMap细节解析
StudyForDream2015的博客
04-21 337
TreeMap 简介 TreeMap 是一个有序的key-value集合，它是通过红黑树实现的。 TreeMap 继承于AbstractMap，所以它是一个Map，即一个key-value集合。 TreeMap 实现了NavigableMap接口，意味着它支持一系列的导航方法。比如返回有序的key集合。 TreeMap 实现了Cloneable接口，意味着它能被克隆。 TreeMap
集合类（二）：List集合
千里之行，始于足下
09-16 298
3、List集合 List集合为列表类型，列表的主要特征是存放其中的对象以线性方式存储，没有特定的顺序，只有一个开头和结尾，当然，它与根本没有顺序的集类型时不同的。 [b]（1）List集合的用法[/b] List集合包括List接口以及List接口的所有实现类。因为List接口继承了Collection接口，所以List接口拥有Collection接口提供的所有常用方法，又因为List是列...
Java——集合
Flora_SM的博客
12-19 193
1.集合中主要接口的概述 List接口、 Set接口、 Map接口、 Collection接口主要特征： ①Collection接口是List接口和Set接口的父接口，通常情况下不被直接使用 ②List接口实现了Collection接口，List接口允许存放重复的对象，按照对象的插入顺序排列 ③Set接口实现了Collection接口，Set接口不允许存放重复的对象，按照自身内部的排序规则...
java集合类之set的treeset
最新发布
04-06
TreeSet是Java集合框架中的一个实现类，它继承了AbstractSet类并且实现了NavigableSet接口。与HashSet不同的是，TreeSet中的元素是有序的且不允许出现重复元素。TreeSet的内部通过红黑树（一种自平衡二叉搜索树）来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值