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;
		}
		
		
	}
	
}

                                                    
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

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

文章来源：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;
    }
     
}