精华内容
下载资源
问答
  • 跟汤老师学Java笔记:TreeSet如何对元素排序的依据是什么? 完成:第一遍 ...当添加的两个元素的compareTo()的返回值为0时,则认为是相同元素,Set集合不可重复元素,会舍弃重复的元素 package season13;

    4.TreeSet如何对元素排序的依据是什么?

    学习:第7遍


    1.TreeSet如何对元素排序的依据是什么?

    (1).元素本身具有的自然顺序:比如数值、字符(ASCII码值)

    (2).如果是自定义类,方法一:让该类实现Comparable接口,实现其中的compareTo(T o)方法
    让对象自身具有可比较性

    (3).如果是自定义类,方法二:提供一个比较器,根据比较器进行排序
    定义一个比较器,实现Comparator接口的类,实现compare(T o1,T o2)方法,有两个参数:一个是要比较的对象,一个是跟谁比较
    在创建TreeSet时要传入比较器

    TreeSet<User> treeSet = new TreeSet<User>(new UserComparator())

    (4).如果比较器和自然顺序冲突,会按照指定的比较器排序规则排序

    2.TreeSet判断重复的依据是什么?

    当添加的两个元素的compareTo()的返回值为0时,则认为是相同元素,Set集合不可重复元素,会舍弃重复的元素


    
    package season13;
    
    import java.util.TreeSet;
    
    
    public class TestTreeSet{
         public static void main(String[] args) {
    		
        	 //创建
        	 TreeSet<User> treeSet = new TreeSet<User>();
        	 
        	 //添加:自定义类无法比较:User cannot be cast to java.lang.Comparable
        	 //需要定义比较法则
        	 //实现接口:class User implements Comparable<User>{}
        	 //重写方法:public int compareTo(User user){}
        	 
        	 treeSet.add(new User("aaa",25,90));
        	 treeSet.add(new User("bbb",21,92));
        	 treeSet.add(new User("ccc",25,98));
        	 treeSet.add(new User("ddd",28,91));
    
        	 //treeSet元素不能重复,结果有排序效果
        	 System.out.println(treeSet);
        	 
        	 
    	}
    }
    
    class User implements Comparable<User>{
    	private String name;
    	private int age;
    	private int score;
    	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;
    	}
    	public int getScore() {
    		return score;
    	}
    	public void setScore(int score) {
    		this.score = score;
    	}
    	public User(String name, int age, int score) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.score = score;
    	}
    	public User() {
    		super();
    	}
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", age=" + age + ", score=" + score + "]\n";
    	}
       //比较重写compareTo(User o)方法:指定比较规则
    	//如果升序:  大于则返回正整数   等于则返回0,小于则返回负整数
    	@Override
    	public int compareTo(User user) {
    		//根据年龄比较:
    		if(this.age>user.getAge()){
    			return 1;
    		}else if(this.age==user.getAge()){
    			//如果年龄相同则比较成绩,按降序比较,成绩大的在前面
    			if(this.score>user.getScore()){
    				return -1;
    			}else if(this.score<user.getScore()){
    				return 1;
    			}else{
    				//如果分数相同,则按姓名比较,调用String方法中的compareTo()
    				int ret = this.name.compareTo(user.getName());
    				return ret;
    			}
    			
    		}else{
    			return -1;
    		}
    	}
    }
    

    比较器比较:

    
    package season13;
    
    import java.util.Comparator;
    import java.util.TreeSet;
    
    
    public class TreeSetTest {
    
    	public static void main(String[] args) {
    		
    		 //创建并同时传入比较器new UserComparator() 
    		//按比较器中的int compare(User user1, User user2)方法排序
       	 TreeSet<User> treeSet = new TreeSet<User>(new UserComparator());
       	 
    
       	 
       	 treeSet.add(new User("aaa",25,90));
       	 treeSet.add(new User("bbb",21,92));
       	 treeSet.add(new User("ccc",25,98));
       	 treeSet.add(new User("ddd",28,91));
    
       	 //treeSet元素不能重复,结果有排序效果
       	 System.out.println(treeSet);
    
    	}
    
    }
    
    class User {
    	private String name;
    	private int age;
    	private int score;
    	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;
    	}
    	public int getScore() {
    		return score;
    	}
    	public void setScore(int score) {
    		this.score = score;
    	}
    	public User(String name, int age, int score) {
    		super();
    		this.name = name;
    		this.age = age;
    		this.score = score;
    	}
    	public User() {
    		super();
    	}
    	@Override
    	public String toString() {
    		return "User [name=" + name + ", age=" + age + ", score=" + score + "]\n";
    	}
    }
    //我们自定义的比较器:用来比较User对象
    class UserComparator implements Comparator<User>{
    
    
    	@Override
    	public int compare(User user1, User user2) {
    		//根据分数进行比较,按照降序
    		if(user1.getScore()>user2.getScore()){
    			return -1;
    		}else if(user1.getScore()<user2.getScore()){
    			return 1;
    		}else{
    			return 0;
    		}
    		
    		
    	}
    	
    }
    
    展开全文
  • Set集合如何判断重复元素

    千次阅读 2019-04-20 15:06:00
    1.TreeSet子类是利用Comparable接口来实现重复元素的判断,但是Set集合的整体特征就是不允许保存重复元素。 2.HashSet判断元素重复是利用Object类中的方法实现的: -|对象编码:public int hashCode(); -|对象....

    1.TreeSet子类是利用Comparable接口来实现重复元素的判断,但是Set集合的整体特征就是不允许保存重复元素。

    2.HashSet判断元素重复是利用Object类中的方法实现的:

           -|对象编码:public int hashCode();

           -|对象比较:public boolean equals(Object obj);

    3.在进行重复元素判断的时候首先利用hashCode()进行编码匹配,如果该编码不存在表示数据不存在,证明没有重复,如果该编码存在了,则进一步进行对象的比较处理,如果发现重复了,则此数据是不能保存的。

    4.java程序中真正的重复元素的判断处理利用的就是hashCode()equals()两个方法共同作用完成的。

    5.只有在排序要求的情况下(TreeSet)才会利用Comparable接口实现。

    转载于:https://my.oschina.net/u/4107179/blog/3039690

    展开全文
  • Set为无序集合(无序是指存入元素的先后顺序与输出元素的先后顺序不一致),不允许添加重复元素。Set是个接口,不能直接实例化对象,即 Set s=new Set()是错误的 。 Set的实现类常用的有:HashSet和TreeSet。 1....

    java学习——Set使用方法以及HashSet和TreeSet的区别

    Set为无序集合(无序是指存入元素的先后顺序与输出元素的先后顺序不一致),不允许添加重复元素。Set是个接口,不能直接实例化对象,即Set s=new Set()是错误的

    Set的实现类常用的有:HashSet和TreeSet。

    1.HashSet和TreeSet的区别:

    (1)HashSet是用哈希表(散列表结构)实现的。
    HashSet会调用该对象的hashCode()方法来得到该对象的hashCode值,根据该值来找到对象的存储位置。然后和该位置上所有的元素进行equals比较,如果该位置没有其他元素或者比较的结果都为false就存进去,否则就不存。即元素是按照哈希值来找存储位置,所有无序,而且可以保证无重复元素
    注意:若向HashSet中存储自定义对象时,需要重写hashCode()和equals()方法(不重写的话不会报错,但运行结果和想象不一样,见下面代码)。

    深入理解HashSet集合对象如何判断数据元素是否重复:
    判断待存对象hashCode值是否与集合中已有元素对象hashCode值相同,如果hashCode不同则表示不重复,不用执行equals()方法; 如果相同则再调用equals方法进行检查,equals返回false表示不重复,否则表示重复。
    注意:Java中的hashCode值是由对象的地址所确定的,每一个地址对应一个值。Object类中的equals方法中比较的也是对象的地址值。

    (2)TreeSet是用二叉树实现的。
    TreeSet可以对Set集合中的元素进行排序,TreeSet中数据是自动排好序的。
    TreeSet支持两种排序方式,自然排序和定制排序,其中自然排序为默认的排序方式。
    若元素自身不具备比较功能,则需要实现Comparator接口,并覆盖其compare方法。

    2.Set示例代码(使用HashSet实现)

    下面代码中,集合中存放的不是自定义的存储对象,所以不需要重写HashCode()和equals()。

    package demo;
    
    import java.util.Date;
    import java.util.HashSet;
    import java.util.Set;
    
    public class SetTest {
    
    	public static void main(String[] args) {
    		
    		//声明一个Set集合对象sd,里面存放的全是Date类型的对象,
    		Set<Date> sd;
    		sd=new HashSet<Date>();
    		
    		//输出当前的时间,运行结果为1565836065039
    		System.out.println(new Date().getTime());
    		
    		//创建几个时间对象
    		Date a=new Date(1565836065039L);
    		Date b=new Date(1565835065039L);
    		Date c=new Date(1565834065039L);
    		
    		//向集合中添加元素,add()方法返回值为boolean类型,若添加成功,返回true;否则为false
    		sd.add(a);
    		sd.add(b);
    		sd.add(c);
    		
    		//Set中元素不能重复,从下面b1的值以及遍历的输出结果中可以看出。
    		
    		boolean b1=sd.add(a);
    		System.out.println(b1);  //输出false,所以判断Set集合中是否存在某个元素时,可以通过add方法的返回值判断。而对于List集合,则不能通过此方法。
    		 
    		//遍历输出集合中的对象,输出3次。 也可以利用Interator进行遍历
    		for(Date dt:sd) {		
    			System.out.println(dt);
    		}			
    	}
    }
    
    

    3.使用HashSet完成自定义类型存储

    下面代码中SetStudent类为自定义存储类型,需要重写HashCode()和equals()方法。
    若不重写重写HashCode()和equals()方法,不会报错,但结果和想象中不太一样。如下代码所示
    (注意下面代码中,用迭代器遍历自定义类型时,取值的使用方法)

    package demo;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class SetStudent {
    	
    	public String name;    //姓名
    	public String xuehao;  //学号
    	public int age;        //年龄
    	
    	public SetStudent(String name,String xuehao,int age) {
    		this.name=name;
    		this.xuehao=xuehao;
    		this.age=age;
    	}	
    	
    	public static void main(String[] args) {
    		
    		Set<SetStudent> s=new HashSet();
    		SetStudent s1=new SetStudent("王","B15",18);
    		SetStudent s2=new SetStudent("李","B16",19);
    		SetStudent s3=new SetStudent("王","B17",18);
    		SetStudent s4=new SetStudent("王","B17",18);
    		SetStudent s5=new SetStudent("王","B15",18);
    		SetStudent s6=new SetStudent("张","B15",20);
    		s.add(s1);
    		s.add(s2);
    		s.add(s3);
    		s.add(s4);
    		s.add(s5);	
    		s.add(s6);
    		Iterator it=s.iterator();
    		while(it.hasNext()) {
    			SetStudent st=(SetStudent)it.next();
    			System.out.println(st.name+"、"+st.xuehao+"、"+st.age);
    		}
    	}
    
    }
    
    

    运行结果为:

    王、B17、18
    张、B15、20
    王、B15、18
    王、B15、18
    李、B16、19
    王、B17、18

    从上面的运行结果可以看出,s4,s5,s6 也存入了集合中,而实际应该是学号是唯一的,s4,s5,s6不应该被存入集合中。
    重写HashCode()和equals()方法后代码示例如下:
    注意:两个方法都要重写。若SetStudent不重写equals()方法,则会调用父类Objcet中的equals()方法,而Object类中的equals方法中比较的是对象的地址值。

    package demo;
    
    import java.util.HashSet;
    import java.util.Iterator;
    import java.util.Set;
    
    public class SetStudent {
    	
    	public String name;    //姓名
    	public String xuehao;  //学号
    	public int age;        //年龄
    	
    	public SetStudent(String name,String xuehao,int age) {
    		this.name=name;
    		this.xuehao=xuehao;
    		this.age=age;
    	}
    	
    	//重写HashCode()方法
    	@Override
    	public int hashCode() {
    		
    			return xuehao.hashCode();
    	}
    	
    	//重写equals方法
    	@Override
    	public boolean equals(Object obj) {
    	
    			SetStudent s=(SetStudent)obj;
    			return this.xuehao.equals(s.xuehao);
    	}	
    	
    	public static void main(String[] args) {
    		
    		Set<SetStudent> s=new HashSet();
    		SetStudent s1=new SetStudent("王","B15",18);
    		SetStudent s2=new SetStudent("李","B16",19);
    		SetStudent s3=new SetStudent("王","B17",18);
    		SetStudent s4=new SetStudent("王","B17",18);
    		SetStudent s5=new SetStudent("王","B15",18);
    		SetStudent s6=new SetStudent("张","B15",20);
    		s.add(s1);
    		s.add(s2);
    		s.add(s3);
    		s.add(s4);
    		s.add(s5);	
    		s.add(s6);
    		Iterator it=s.iterator();
    		while(it.hasNext()) {
    			SetStudent st=(SetStudent)it.next();
    			System.out.println(st.name+"、"+st.xuehao+"、"+st.age);
    			//注意System.out.println(((SetStudent)it.next()).name);也行,但(SetStudent)it.next().name会报错
    		}
    	}
    }
    

    运行结果为:

    王、B15、18
    李、B16、19
    王、B17、18

    3.Set示例代码(使用TreeSet实现)

    package demo;
    
    import java.util.Set;
    import java.util.TreeSet;
    
    public class TreeSetTest {
    
    	public static void main(String[] args) {
    		
    		Set<Integer> s=new TreeSet(); //注意此处Integer不能换成int
    		s.add(2);
    		s.add(4);
    		s.add(3);
    		s.add(1);
    		s.add(2);  //插入失败,由运行结果也可看出
    		
    		//使用for-each语句进行遍历
    		for(int i:s) {
    			System.out.println(i);
    		}		
    	}
    }
    

    运行结果:

    1
    2
    3
    4

    展开全文
  • 文章来源:...Set里的元素是不能重复的,那么用iterator()方法来区分重复与否 public static boolean isSetEqual(Set set1, Set set2) { if (set1 == null && set2 == null) { retu

    文章来源:http://blog.csdn.net/lxqluo/article/details/31394393

    Set里的元素是不能重复的,那么用iterator()方法来区分重复与否
    
    public static boolean isSetEqual(Set set1, Set set2) {
      
      if (set1 == null && set2 == null) {
       return true; // Both are null
      }
    
      if (set1 == null || set2 == null || set1.size() != set2.size()
        || set1.size() == 0 || set2.size() == 0) {
       return false;
      }
      
      Iterator ite1 = set1.iterator();
      Iterator ite2 = set2.iterator();
      
      boolean isFullEqual = true;
      
     <span style="color:#ff9966;"> while (ite2.hasNext()) {
       if (!set1.contains(ite2.next())) {
        isFullEqual = false;
       }
      }</span>
      
      return isFullEqual;
     }

    java treeset和hashset如何判断元素是否相同

    问:
    在使用treeset和hashset重复添加元素时,发现二者在比较自定义对象元素上不一样,如下例
    假设record对象包含两个信息,一个为int age,一个为String name
    
    Set<record> t0= new TreeSet<record>();
    		t0.add(new record(1,"lAn"));
    		t0.add(new record(1,"lAn"));
    		t0.add(new record(1,"lAn"));
    System.out.println(t0);
    treeset的输出为[1 lAn]
    
    将相同元素添加到hashset中
    Set<record> t1= new HashSet<record>();
    t1.add(new record(1,"lAn"));
    t1.add(new record(1,"lAn"));
    t1.add(new record(1,"lAn"));
    System.out.println(t0);
    输出为[1 lAn,1 lAn,1 lAn]
    
    为什么会有这种情况呢? hashset和treeset是怎么比较元素相等的?
    答:

    我想看下你得record类,问题可能出在你得record类里面,你是不是重写了hashcode方法?


    刚才看了一下,问题出在你得record类应该,你没有生成一个hashcode()方法,所以你得hashcode方法继承自object类

    object类的hashcode算法hashcode算出来的结果就是该对象在内存中的地址的十进制表示,你每次都是new出来的record,所以他们的内存地址一定是不一样,那么这就说明他们的hashcode不一样,而hashset对于相同对象的比较是使用hashcode的,他们的hashcode不同,那么自然被hashset认为是不一样的对象了,所以有了你的结果,建议record类里面写一个hashcode方法,可以利用Eclipse或MyEclipse的生成的那个hashcode算法


    然后说说treeset

    boss来了,等下给你补上


    好了,boss走了,吓死我了

    对于你的treeset,他是用compareTo方法判断是否相同,treeset要求你必须给record类实现comparable接口,你应该写了,但是这个接口有个方法compareTo你实现的时候可能是用了默认的吧,默认的compareTo方法只有一句,就是return 0;所以对于任何两个对象来说他们compareTo都是相同的,那么treeset就会认为这些record都是一样的,没区别,所以就只有一条

    ,建议可以利用下Eclipse或MyEclipse的equals算法生成,然后在compareTo方法里调用equals方法比较


    综上所述

    hashset用hashcode方法来实现比较是否相同

    而treeset用comparable接口的compareTo方法比较


    有问题可以追问,

    打了这么多字给分吧~~

    希望能帮助你


    我人还是太好了,附带着还是把record的代码发给你吧,免得你迷糊


    public class record implements Comparable{
        private int age;
        private String name;
         
        public record(int age,String name){
            // TODO Auto-generated constructor stub
            this.age=age;
            this.name=name;
        }
     
        @Override
        public int compareTo(Object o) {
            // TODO Auto-generated method stub
             
            if(equals(o)){
                return 0;
            }else {
                return -1;
            }
        }
     
        @Override
        public String toString() {
            return "record [age=" + age + ", name=" + name + "]";
        }
     
        @Override
        public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result + age;
            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;
            record other = (record) obj;
            if (age != other.age)
                return false;
            if (name == null) {
                if (other.name != null)
                    return false;
            } else if (!name.equals(other.name))
                return false;
            return true;
        }
         
    }



    展开全文
  • HashSet区分重复元素: 先使用hashcode方法判断已经存在HashSet中元素的hashcode值和...TreeSet区分重复元素TreeSet中的元素对象如果实现Comparable接口,使用compareTo方法区分元素是否重复,如果没实现Comparable
  • 先使用hashcode方法判断已经存在HashSet中元素的hashcode值和将要加入元素hashcode值是否相同。如果不同,直接添加;如果相同,再调用equals方法判断,如果返回true表示HashSet中已经添加该对象了,不需要再次添加...
  • 1,set是如何实现没有重复元素 A、如果想使用Element的equals方法来判断元素是否相同,那么可以使用CopyOnWriteArraySet来构造类的实体。 B、如果Element实现了Comparable接口,而且想使用compareTo方法来判断元素...
  • Set接口有两个实现类HashSet和TreeSet。Set是集合的意思,这个接口实现...HashSet和TreeSet的不同就在于如何判断两个数是否相同的方法上。TreeSet判断两个对象是否相同的方法是Comparable接口中的compareTo()方法(publ
  • 关于Set,它的显著性特征就是,无法记录数据存储的先后顺序,无法存储重复元素进入数据集合; 接下来介绍下HashSet与TreeSet 一、关于HashSet 1.hashset的存储特点? 无序性、单元性 2. HashSet是如何做到不去记录...
  • Set:无序,不可以重复。 Set集合集合中的方法和Collection是一致的。它的取出方式只有一种。迭代器。 ... |-HashSet:底层数据结构是哈希表,该集合是线程不同步... 如果hashCode值相同,再继续判断元素的equal...
  • import java.util.*; /* |--Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。、 |--HashSet:底层数据结构是哈希表。... 如果元素的HashCode值相同,才会判断equals是否为true。 如果元
  • android培训、java培训、期待与您交流 import java.util.*; ...|--Set:元素是无序(存入和取出的顺序不一定一致),元素不可以重复。...HashSet是如何保证元素唯一性的呢?...如果元素的HashCode值相同,才会判断equa
  • Set:元素是无序的(存入和取出的顺序不一定一致),元素不可以重复。 |--HashSet:底层数据结构是哈希表(存放哈希值的表) |--TreeSet:可以对Set集合中的...如果元素的hashCode相同,则用equals判断;如果hashCode不
  • /* TreeSet,二叉树原理,比较器,泛型,自定义泛型 */ /* |--Set:元素是无序的(存入和取出的顺序不一致),元素不可重复 ... 判断是通过元素的两个方法,先判断hashCode,如果相同,再判断equals来完成 如果元素
  • 1. HashSet集合是如何约束集合中对象不重复的 通过重写实体类的hashCode() 方法和equals(Object obj) 方法 当两个实体对象hashCode()相同时,自动调用equals(Object obj) 判断是否相同。若两次判断都相等,则add...
  • /* |---Set:元素是无序的(存入和取出的顺序不一定一致),元素不可以重复。 |---HashSet:底层数据... 如果元素的hashCode值相同,才会判断equals是否为true。 如果元素的hashCode值不同,才会调用equals。
  • Set 不保存重复元素如何判断元素相同呢?)。如果你试图将相同对象的多个实例添加到Set中,那么它就会阻止这种重复现象。 Set中最常被使用的是测试归属性,你可以很容易地询问某个对象是否在某个Set中。 正因...
  • 实际上Set就是Collection,只是行为不同(Set不允许包含重复元素) set集合不允许包含相同的元素,如果试图把两个相同元素加入同一个Set集合中,则添加操作失败,add方法返回false,且新元素不会被加入。 问1...
  • Map和Set不可存在重复元素 1对于 HashMap HashSet的实现是: 维护了一张 HashTable 。容器中的元素全部存储在Hashtable 中,每次添加元素都会先判断是否有重复的元素,hashcode()方法进行比较,若一样再equals()...
  • 对于集合set的定义

    千次阅读 2019-05-22 00:37:10
    集合set对于集合set的定义一,set集合中的HashSet1.HashSet哈希表存储2.HashSet是如何保证元素唯一性的3.List与Set判断重复对象的区别二,集合框架TreeSet1.自然排序2.比较器排序三,Hashset 和 treeset 的区别 对于...
  • Java集合:Set集合

    2020-09-04 16:09:39
    一个不包含重复元素的collection。更确切地讲,Set不包含满足e1.equals(e2)的元素对 e1和e2,并且最多包含一个null元素。 Set集合由Set接口和Set接口的实现类组成,Set接口继承了Collection接口,因此包含了...
  • 第九周技术博客

    2016-04-21 23:36:00
     HashSet 学会了写hashCode()来方便HashSet对于重复元素的判断  ArrayList 学会了使用方法 顺便学了Iterator迭代器的使用  TreeSet 如何使用Comparable和Comparator接口来完成自动排序 学习了泛型类,泛型...
  • 14**JavaHashSet

    2021-01-30 15:21:50
    如果元素的HashCode值相同,才会判断equals是否为true。 如果元素的hashcode值不同,不会调用equals。 注意,对于判断元素是否存在,以及删除等操作,依赖的方法是元素的hashcode和equals方法。 |--TreeSet: S

空空如也

空空如也

1 2
收藏数 40
精华内容 16
关键字:

treeset如何判断重复元素的