set的子实现类TreeSet和HashSet

一.HashSet

Set集合和List集合的区别:
Set集合:不允许元素重复,唯一的(元素可以为null) ,不能保证迭代的顺序恒久不变(底层哈希表和hascode)
无序(存储和取出不一致)

List:允许元素重复,并且存储特点:有序性(存储和取出一致)

import java.util.HashSet;(student以重写equal方法和HashCode方法)
import java.util.Set;
//如果student类中不重写equal方法和HashCode方法,则会出现重复对象
//因为add方法的底层代码(去重)依附于这两个方法,没有这两个方法则会重复
//去重可以分为对象去重和添加元素去重 
public class Set2 {
public static void main(String[] args) {
	//创建Set对象,用HashSet实现对象
	Set<student> s = new HashSet<>();
	student s1 = new student("张三", 27) ;
	student s2 = new student("李四", 28) ;
	student s3 = new student("王五", 30) ;
	student s4 = new student("张三", 39) ;
	student s5 = new student("张三", 27) ;
	s.add(s1);
	s.add(s2);
	s.add(s3);
	s.add(s4);
	s.add(s5);
	for(student ss:s) {
		System.out.println(ss.getName()+ss.getAge());
	}
}

2.LinkedHashSet

import java.util.LinkedHashSet;
//set集合实现排序:
//1.LinkedHashSet  按插入顺序排序
//2.自然排序(tree)
//3.比较器排序(tree)
public class LinkedHashSet1 {
public static void main(String[] args) {
	LinkedHashSet<String> ls=new LinkedHashSet<>();
	ls.add("1") ;  
	ls.add("3") ;
	ls.add("2") ;
	ls.add("1") ;  //重复删除
	ls.add("4") ;
	ls.add("2") ;  //重复删除
	for(String s:ls) {
		System.out.println(s);
	}
}
}
//输出结果:
//1
//3
//2
//4
//按照插入顺序遍历输出

3.TreeSet

import java.util.TreeSet;
//1.可以保证元素唯一并且元素排序(Integer类型的元素自然升序)
public class TreeSet1 {
public static void main(String[] args) {
	TreeSet<Integer> ts = new TreeSet<>() ;
	ts.add(1);
	ts.add(2);
	ts.add(4);
	ts.add(3);
	ts.add(6);
	ts.add(1);
	ts.add(2);
	ts.add(3);
	ts.add(4);
	for(Integer i:ts) {
		System.out.println(i);
	}
}

import java.util.TreeSet;
//2.自然排序方法
//报错:java.lang.ClassCastException: org.westos_03.Student
//cannot be cast to java.lang.Comparable
//Student中没有Comparable可比的方法,
//因为是对象,所以要自定义比较方法,且插入Comparable接口
//此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo方法被称为它的自然比较方法。
public class TreeSet2 {
public static void main(String[] args) {
	TreeSet<student> ts  = new TreeSet<student>() ;//无参构造的方式自然排序
	
	//创建学生对象
	student s1 = new student("a",1) ;	
	student s2 = new student("b",2) ;
	student s3 = new student("c",3) ;
	student s4 = new student("d",4) ;
	//添加干扰元素
	student s5 = new student("a",1) ;  //相同元素
	student s6 = new student("b",4) ;  //String相同
	student s7 = new student("c",3) ;  //integer相同
	ts.add(s1) ;
	ts.add(s2) ;
	ts.add(s3) ;
	ts.add(s4) ;
	ts.add(s5) ;
	ts.add(s6) ;
	ts.add(s7) ;
	//遍历
	for(student s:ts) {
		System.out.println(s.getName()+"---"+s.getAge());
	}
}
}
//输出结果
//a---1
//b---2
//c---3
//b---4
//d---4

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

//比较器排序方法
//两种形式:因为对象student要实现Comparator接口:
//但是接口必须要实例化,则有两种方式实例化:
//1.自己建立该接口的实例化
//2.用匿名对象书写排序方法
public class TreeSet3 {
public static void main(String[] args) {
	//第一种方法自己建立Comparator的实例化
	//匿名Comparator接口实现类
	TreeSet<student2> ts=new TreeSet<>(new getComparator());
	//第二种方法直接用匿名对象书写排序方法
	//匿名后记得导入import java.util.Comparator;  
	TreeSet<student2> ts2=new TreeSet<>(new Comparator<student2>() {
		//书写Comparator方法(接口方法声明必须实现)
		public int compare(student2 s1, student2 s2) {
			int m1=s1.getAge()-s2.getAge();
			int m2= m1==0? s1.getName().compareTo(s2.getName()):m1;
			return m2;
		}
	});
	student2 s1 = new student2("a",1) ;	
	student2 s2 = new student2("b",2) ;
	student2 s3 = new student2("c",3) ;
	student2 s4 = new student2("d",4) ;
	//添加干扰元素
	student2 s5 = new student2("a",1) ;  //相同元素
	student2 s6 = new student2("b",4) ;  //String相同
	student2 s7 = new student2("c",3) ;  //integer相同
	ts.add(s1) ;
	ts.add(s2) ;
	ts.add(s3) ;
	ts.add(s4) ;
	ts.add(s5) ;
	ts.add(s6) ;
	ts.add(s7) ;
	//遍历
		for(student2 s:ts) {
			System.out.println(s.getName()+"---"+s.getAge());
		}
	
}
}

自己建立该接口的实例化

import java.util.Comparator;

public class getComparator implements Comparator<student2> {

	@Override
	public int compare(student2 s1, student2 s2) {
		int m1=s1.getAge()-s2.getAge();
		int m2= m1==0? s1.getName().compareTo(s2.getName()):m1;
		return m2;
	}

}

set的子实现类TreeSet和HashSet

猜你喜欢