精华内容
下载资源
问答
  • TreeSet和treemap

    2021-01-28 10:11:55
    treemap相当于在treeset的基础上增加了key到value的映射。 treeset会对元素进行排序,有排序就可以获得第一个比X元素大或者最后一个比X元素小的元素。

    treemap相当于在treeset的基础上增加了key到value的映射。
    treeset会对元素进行排序,有排序就可以获得第一个比X元素大或者最后一个比X元素小的元素。

    展开全文
  • 首先简单介绍下TreeSet和TreeMap的两种排序:自然排序通过comparator排序private static void compareWithCpmparator(){TreeSet treeSet =new TreeSet<>();List list =new ArrayList<>();list.add("a");...

    首先简单介绍下TreeSet和TreeMap的两种排序:

    自然排序

    通过comparator排序

    private static void compareWithCpmparator(){

    TreeSet treeSet =new TreeSet<>();

    List list =new ArrayList<>();

    list.add("a");

    list.add("d");

    list.add("b");

    treeSet.addAll(list);

    Iterator iterator =treeSet.iterator();

    while (iterator.hasNext()){

    System.out.println(iterator.next());

    }

    Comparator comparator1 = (Comparator) treeSet.comparator();

    if (comparator1 == null){

    System.out.println("comparator1是空");

    }else {

    System.out.println("comparator1不是空");

    }

    }

    public static void main(String[] args) {

    compareWithCpmparator();

    }

    运行之后的结果如下:

    a

    b

    d

    comparator1是空

    这段代码里面获取的comparator是空的,Debug一遍,发现这个方法其实调用的是NavigableMap里面的comparator

    public Comparator super E> comparator() {

    return m.comparator();

    }

    查看官网上对其的介绍:

    Comparator super K> comparator()

    Returns the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys.

    Returns:

    the comparator used to order the keys in this map, or null if this map uses the natural ordering of its keys

    在调用这个方法的时候若是自然排序,那么会返回一个null。若是通过comparator进行排序的话当前集合采用的comparator。

    查看官网对reeSet的无参构造器的解释:

    /**

    * Constructs a new, empty tree set, sorted according to the

    * natural ordering of its elements. All elements inserted into

    * the set must implement the {@link Comparable} interface.

    * Furthermore, all such elements must be mutually

    * comparable: {@code e1.compareTo(e2)} must not throw a

    * {@code ClassCastException} for any elements {@code e1} and

    * {@code e2} in the set. If the user attempts to add an element

    * to the set that violates this constraint (for example, the user

    * attempts to add a string element to a set whose elements are

    * integers), the {@code add} call will throw a

    * {@code ClassCastException}.

    在使用TreeSet的时候,插入的元素需要实现Comparable这个接口,而刚刚的元素是String,查看String的代码发现:

    public final class String implements java.io.Serializable, Comparable, CharSequence {

    确实实现了,再测试一个没有实现的元素:

    public class PojoTest {

    private int id;

    private String name;

    public PojoTest() {

    }

    public int getId() {

    return id;

    }

    public void setId(int id) {

    this.id = id;

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public PojoTest(int id, String name) {

    this.id = id;

    this.name = name;

    }

    }

    private static void com(){

    TreeSet treeSet =new TreeSet<>();

    treeSet.add(new PojoTest(1,"a"));

    treeSet.add(new PojoTest(2,"b"));

    treeSet.add(new PojoTest(3,"c"));

    Iterator iterator =treeSet.iterator();

    while (iterator.hasNext()){

    System.out.println(iterator.next().getName());

    }

    }

    运行结果如下:

    Exception in thread "main" java.lang.ClassCastException: SetAndMap.TreeSetAndTreeMap.PojoTest cannot be cast to java.lang.Comparable

    at java.util.TreeMap.compare(TreeMap.java:1294)

    at java.util.TreeMap.put(TreeMap.java:538)

    at java.util.TreeSet.add(TreeSet.java:255)

    at SetAndMap.TreeSetAndTreeMap.TestTreeSet.com(TestTreeSet.java:77)

    at SetAndMap.TreeSetAndTreeMap.TestTreeSet.main(TestTreeSet.java:88)

    很明显,所以放在TreeSet里面的元素要么是实现Comparable了的自然排序,要么是通过comparator来进行排序的。

    最后附上一个标准的使用Comparator的方法:

    private static void construct(){

    Comparator comparator =new Comparator() {

    @Override

    public int compare(String o1, String o2) {

    if(o1.toCharArray()[0] >o2.toCharArray()[0]){

    return -1;

    }else if(o1.toCharArray()[0] == o2.toCharArray()[0]){

    return 0;

    }else{

    return 1;

    }

    }

    };

    TreeSet treeSet =new TreeSet<>(comparator);

    List list =new ArrayList<>();

    list.add("a");

    list.add("d");

    list.add("b");

    treeSet.addAll(list);

    Iterator iterator =treeSet.iterator();

    while (iterator.hasNext()){

    System.out.println(iterator.next());

    }

    Comparator comparator1 = (Comparator) treeSet.comparator();

    TreeSet treeSet1 =new TreeSet<>(comparator1);

    treeSet1.add("c");

    treeSet1.add("g");

    treeSet1.add("a");

    Iterator iterator1 =treeSet1.iterator();

    while (iterator1.hasNext()){

    System.out.println(iterator1.next());

    }

    自然排序:

    是实现Comparable接口并且重写了compareTo方法的

    另一个comparator

    则是通过comparator并且重写compare方法

    展开全文
  • TreeSet和TreeMap

    2017-09-21 10:46:13
    TreeSet对于TreeSet类不仅实现了Set接口,还实现了java.util.SortedSet接口(注意Collection位于java.lang.Object包),因此,TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序,也可以按照指定比较比较器...

    TreeSet

    对于TreeSet类不仅实现了Set接口,还实现了java.util.SortedSet接口(注意Collection位于java.lang.Object包),因此,TreeSet类实现的Set集合在遍历集合时按照自然顺序递增排序,也可以按照指定比较比较器递增排序,即可以通过比较器对用TreeSet类实现的Set集合中的对象进行排序。

    • 按照自然顺序排序,java.lang.Comparable,调用new TreSet()空构造器方法
    • 按照业务类排序,java.util.Comparator,调用new TreeSet(Comparator
    public class person {
        private String name;
        private int hansome;
    
        public person() {
        }
        public person(String name, int hansome) {
            super();
            this.name = name;
            this.hansome = hansome;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getHansome() {
            return hansome;
        }
        public void setHansome(int hansome) {
            this.hansome = hansome;
        }
    
        @Override
        public String toString() {
            return this.name+"--"+this.hansome;
        }
    }
    
    import java.util.Comparator;
    import java.util.Set;
    import java.util.TreeSet;
    
    
    public class TestTreeSet {
        public static void main(String[] args) {
            Set<person> list = new TreeSet<>(new Comparator<person>(){
                @Override
                public int compare(person o1, person o2) {
                    return o1.getHansome()-o2.getHansome();
                }  //如果使用业务规则排序,需要使用带参构造
            });
            person p1 = new person("我", 100);
            person p2 = new person("你", 80);
            person p3 = new person("他", 10);
            person p4 = new person("她", 90);
            list.add(p1);
            //注意,TreeSet是在添加数据的自动排序,不像Collections需要调用排序方法
            //在谈价p2的时候就和p1作比较
            list.add(p2);
            list.add(p3);
            list.add(p4);
    
            System.out.println(list);
            System.out.println("--------注意,就算改变数据,顺序还是不会变,所以最好不要修改数据--------");
            p4.setHansome(10);    //想要数据不被修改,就吧不应该被改的数据改成final修饰就行
            System.out.println(list);
        }
    }
    输出结果为:[他--10, 你--80, 她--90, 我--100]
    --------注意,就算改变数据,顺序还是不会变,所以最好不要修改数据--------
              [他--10, 你--80, 她--10, 我--100]
    

    当然,也可以使用Comparable按照自然排序

    public class worker implements Comparable<worker>{
        private String type;
        private double salary;
    
        public worker() {
        }
    
        public worker(String type, double salary) {
            super();
            this.type = type;
            this.salary = salary;
        }
    
        public String getType() {
            return type;
        }
    
        public void setType(String type) {
            this.type = type;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        @Override
        public int compareTo(worker o) {
            return (int) (this.salary-o.salary);
        }
        @Override
        public String toString() {
            return this.type+"--"+this.salary;
        }
    
    }
    
    import java.util.Set;
    import java.util.TreeSet;
    
    public class TestTree_1 {
        public static void main(String[] args) {
            worker w1 = new worker("农民", 2000);
            worker w4 = new worker("我", 20000);
            worker w3 = new worker("白领", 5000);
            worker w2 = new worker("工民", 3000);
            Set<worker> set = new TreeSet<worker>();
            set.add(w1);
            set.add(w2);
            set.add(w3);
            set.add(w4);
            System.out.println(set);
        }
    }
    输出结果:[农民--2000.0, 工民--3000.0, 白领--5000.0, 我--20000.0]
    
    展开全文
  • TreeSet TreeMap 排序

    2020-09-13 21:25:09
    TreeSet TreeMap 默认排序均为按照字典顺序升序排序,TreeMap排序依据为key值 以下为TreeSet TreeMap 自定义倒序排序样例: new TreeSet<Integer>(new Comparator<Integer>() { @Override ...

    TreeSet 和 TreeMap 默认排序均为按照字典顺序升序排序,TreeMap排序依据为key值

    以下为 TreeSet 和 TreeMap 自定义倒序排序样例:

    new TreeSet<Integer>(new Comparator<Integer>() {
    	@Override
    	public int compare(Integer o1, Integer o2) {
    		return o2 - o1;
    	}
    });
    
    new TreeMap<Integer, Integer>(new Comparator<Integer>() {
    	@Override
    	public int compare(Integer o1, Integer o2) {
    		return o2 - o1;
    	}
    });

     

    展开全文
  • TreeSet TreeMap集合

    2020-08-11 23:32:49
    一、TreeSet TreeMap 的概述 ① TreeSet TreeMap 的继承结构 ② 简述 TreeSet集合类实现了SortedSet接口,SortedSet接口继承了Set接口,Set接口继承了Collection接口。TreeSet集合中的元素无序不可重复...
  • 有序的TreeSet和TreeMap

    2020-08-23 17:16:54
    有序的TreeSet和TreeMap package myTest; import java.util.Comparator; import java.util.Map.Entry; import java.util.TreeMap; import java.util.TreeSet; public class Test15_有序的TreeSet和TreeMap { ...
  • TreeSet和TreeMap区别

    2021-04-12 10:19:32
    最主要的区别就是TreeSet和TreeMap分别实现Set和Map接口 TreeSet只存储一个对象,而TreeMap存储两个对象Key和Value(仅仅key对象有序) TreeSet中不能有重复对象,而TreeMap中可以存在 TreeMap的底层采用红黑树的...
  • TreeSet1、TreeSet集合底层实际上是一个TreeMap2、TreeMap集合底层是一个二叉树。3、放到TreeSet集合中的元素,等同于放到TreeMap集合key部分了。4、TreeSet集合中的元素:无序不可重复,但是可以按照元素的大小顺序...
  • 首先简单介绍下TreeSet和TreeMap的两种排序: 自然排序 通过comparator排序 private static void compareWithCpmparator(){ TreeSet<String> treeSet =new TreeSet<>(); List...
  • TreeSet和TreeMap内外部比较器 TreeSet TreeSet是Set集合,当你向其中插入数据时,会对插入的数据跟已有的数据进行比较,会按照比较的顺序进行存储. 原理图 内部比较器 实体类对象需要...
  • TreeSet和TreeMap的输出

    2016-12-06 22:46:00
    如果加入TreeSet和TreeMap的元素没有实现comprable中的compareTo()方法,那么会报错“treeset cannot be cast to java.lang.Comparable”. 要解决这个问题有两种方法: (1)让元素自身具有比较性;可以实现...
  • TreeMap 的实现就是红黑树数据结构,也就说是一棵自平衡的排序二叉树...为了让大家了解 TreeMap TreeSet 之间的关系,下面先看 TreeSet 类的部分源代码: public class TreeSet extends AbstractSet implements
  • TreeSet和TreeMap:TreeSet是collection下set下的实现类,而TreeMap是map下的一个实现类,TreeSet底层是由TreeMap实现的数据结构:TreeSet和TreeMap都是:二叉树源码分析:TreeSet: 创建对象时,不管你是调用的是它...
  • 关于TreeSet和TreeMap排序问题 1.默认的自然排序 对于字符的排序是a-z,大写字母优于小写字母 对于数字默认是从小到大 如果TreeSet中既放入字符,又放入数字,会报错,即无法进行比较排序的错误 java.lang....
  • TreeSet和TreeMap调用compareTo的简单测试重写equals和compareTo源代码输出结果结论 重写equals和compareTo 源代码 import java.util.*; class A implements Comparable<Object> { String str; int count; ...
  • 本文转载自:红黑树讲解TreeSet and TreeMap总体介绍之所以把TreeSet和TreeMap放在一起讲解,是因为二者在Java里有着相同的实现,前者仅仅是对后者做了一层包装,也就是说TreeSet里面有一个TreeMap(适配器模式)**...
  • TreeSet和TreeMap 因为Tree是排序的,排序就要用到被排序元素的排序方法(compareTo())而这个方法是comparable接口的抽象方法,因此使用TreeSet加入当中的元素必须实现该接口,然后实现compareTo方法。 TreeSet...
  • TreeSetTreeMap实现Comparator实现排序 TreeSetTreeMap实现Comparable实现排序 TreeSetTreeMap实现Comparator实现排序 &gt; (1).TreeSet: 数据元素可以排序(且不需要自己排序,只要自己实现...
  • 1、二者默认按照升序排序...2、要想自定义TreeSet和TreeMap中元素的排序,可以在其初始化时,指定比较器即可。 3、测试code: package sourcecode.analysis; import java.util.*; public class testCode { pub
  • Java – 排序03(TreeSet TreeMap)一.TreeSet 1.特性:数据元素可以排序,但不可重复 2.对比:与HashSet相比,TreeSet不用重写Hashcodeequals 3.去重:比较等于0即重复 4.排序:与上一章中提到的一样,要么用...
  • TreeSet和TreeMap问题:cannot be cast to java.lang.Comparable; 在使用TreeSet或者TreeMap来保存自定义对象时,必须让自定义对象的类实现Comparable接口,并重写其compareTo()方法,否则会报cannot be cast to ...
  • Java TreeSet和TreeMap

    2019-03-07 10:44:13
    TreeSet 元素不可以重复,元素可以排序,添加数据时自动进行排序,TreeSet存储数据尽量不要修改 实例代码(用到了匿名内部类): 案例一(Comparator): 实体类: import java.util.ArrayList; import java....
  • 重写TreeSet和TreeMap

    2020-03-02 10:06:25
     TreeMap代码: public class TreeMap < K , V > implements Map < K , V > { private Comparator < K > comparator ; private static final int RED = 1 ; private ...
  • TreeSet和TreeMap排序

    千次阅读 2016-08-29 23:11:48
    Set接口:HashSet HashMap元素必须重写equalshashcode方法 去重:比较==0即重复 TreeMap:要求key可以排序或提供key比较器 public TreeMap(Comparator comparator) TreeSet:确保元素实体可以排序或提供比较...
  • TreeMap TreeSet 是 Java Collection Framework 的两个重要成员,其中 TreeMap 是 Map 接口的常用实现类,而 TreeSet 是 Set 接口的常用实现类。虽然TreeMap和TreeSet实现的接口规范不同,但 TreeSet 底层是通过 ...
  • TreeSet和TreeMap的排序

    2018-04-06 13:44:03
    对于TreeSe和TreeMap都是在添加数据时进行排序的。所以要对其设置比较器,例如: package treeset; import java.util.Comparator; import java.util.TreeSet; public class TreeMapText { publi...
  • TreeSet 和TreeMap 排序

    2017-01-16 11:03:00
    TreeSet 有两种排序方式 1. Java.lang.Comparble+compareTo new TreeSet() 用这种方法必须要求实体类实现Comparable接口,也就是说要求添加到TreeSet中的元素是可排序的 2. java.util.Comparator +compare ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,694
精华内容 677
关键字:

treeset和treemap