第一:set接口:set接口里面的元素不能重复,因此null也只能有一个。
第二:treeset实现类:需要排序(有序)
1.间接实现了set接口(Treeset继承了AstractSet这个类,AstractSet类实现了set接口)。
2.对保存的元素进行排序(默认情况下调用comparable接口中的comperTo(比较的)方法,也就是默认排序,继承之后就能实现添加了),在我们排序的时候需要指定排序的规则,(而这个规则定义在comparable接口中,因此Treeset集合里的对象要实现这个接口), (例如:我指定的规则是比较学生对象里的年龄,则只需要两个对象的年龄一样,就认为这两个对象是痛一个对象(认为他们的内容一样)。这里是为了排序,按照年龄排序。)(list接口是重写equals方法,因此要求全部内容一样才算一样。set接口重写的是comperTo方法, 只需两个对象的年龄一样就会认为是痛一个对象(认为他们的内容一样))。排序的结果是放进去的顺序跟取出来的顺序不一样
3.comparable这个接口是排序的意思,这个接口里面有比较大小的方法compareTo,当实现类实现这个接口的时候也就是重写了这个比较的方法。
4.TreeSet是线程不同步,不安全的。
5.iterator迭代器,这也是个接口。 set需要借助迭代器来遍历,遍历的时候不知道循环次数,所以用while(在list接口的时候,是因为知道元素下标,因此能用for循环,set不知道容器里面元素的具体位置,因此要借助迭代器)
6.TreeSet的底层是个二叉树(右节点比跟节点要大,左节点比跟节点要小)
7.代码解释:
public class Student implements Comparable{
private int age;
private double hight;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public double getHight() {
return hight;
}
public void setHight(double hight) {
this.hight = hight;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Student() {
super();
// TODO Auto-generated constructor stub
}
public Student(int age, double hight, String name) {
super();
this.age = age;
this.hight = hight;
this.name = name;
}
//这里的tostring本来是没有什么用处的,在这里重写tostring是为了在控制台查看运行结果
@Override
public String toString() {
return "Student [age=" + age + ", hight=" + hight + ", name=" + name
+ "]";
}
//比较Treeset集合中的元素。如果两个对象的age和hight都相等我们就认为这俩个对象是同一个元素。这是通过age进行比较,如果两个对象只有age相等,则会按添加顺序排列所有年龄相等的对象。如果age不相等就直接按照age进行排序了
//比较的方法1:这个方法相当于把equals方法和比较的方法写在了一起
/* @Override
public int compareTo(Object o) {
Student stu=(Student)o;
if(this.age==stu.age&&this.hight==stu.hight&&this.name.compareTo(stu.name)==0){
return 0;
}else
if(this.age>stu.age){
return 1;
}else{
return -1;
}
}
*/
//方法2:这个是把compareTo方法与equals方法分开写。注意要保证两个方法中属性(个数)的一致性
public int compareTo(Object o) {
Student stu=(Student)o;
if(this.age>stu.age){
return 1;
}else
if(this.age<stu.age){
return -1;
}
if(this.hight>stu.hight){
return 1;
}else
if(this.hight<stu.hight){
return -1;
}
if(this.name.compareTo(stu.name)>0){
return 1;
}else
if(this.name.compareTo(stu.name)<0){
return -1;
}
return 0;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Student))
return false;
Student other = (Student) obj;
if (age != other.age)
return false;
if (Double.doubleToLongBits(hight) != Double
.doubleToLongBits(other.hight))
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
}
public class TreeSetTest {
/**
*
* @方法的作用:使用TreeSet 保存学生,使学生按照年龄和身高排序,并遍历集合,使用两种方式 实现学生排序功能
*/
public static void main(String[] args) {
Student stu1=new Student(13,16,"张三");
Student stu2=new Student(16,16,"liss");
Student stu3=new Student(19,14.6,"李四");
Student stu4=new Student(13,16.8,"王五");
Student stu5=new Student(32,19,"主流");
Student stu6=new Student(32,19,"主流");
Student stu7=new Student(32,10,"haha");
TreeSet ts=new TreeSet();
ts.add(stu1);//在add的时候默认调用compareTo方法
ts.add(stu2);
ts.add(stu3);
ts.add(stu4);
ts.add(stu5);
ts.add(stu6);
ts.add(stu7);
Iterator it=ts.iterator();
while(it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
}
第三:hashset实现类:不排序
1.底层是个哈希表(跟内存地址有关,每次运行的顺序可能会不一样,也就是产生这个对象的时候不一定每次都是这个内存地址)也就是Hashmap的实例。
2.也只能有一个null,因为他们都实现了set接口。
3.在new的时候,地址不一定总是同一个,因此在对内存中给Hashset分配好多桶,到时候添加元素的时候,是添加到某一个桶内。在查找的时候只需要找到这个桶,这样提高了效率,
4.构造函数,空构造调用了map的空构造默认初始容量是16,也就是16个桶,加载因子是0.75倍。
5.在add方法中,如果集合中已经有这个元素了(有这个内容了),就不在添加了,就添加不进去了。
6.解决set:不允许重复的问题:但是我们在添加重复元素的时候能够添加重复元素,是以为我们没有重写equals方法,没重写的情况下是不比较内容的,因此写两个内容一样的对象也能添加成功。现在我们重写equals方法,但是重写之后发现内容一样的对象仍然能够添加成功。
7.重写equals方法的之前还要重写hashcode方法,hashcode方法在不重写的时候表示内存地址,重写之后表示一个常量和一个变量经过运算后得到到整数值。重写hashcode是运算(hashcode方法里面是对对象的属性值进行运算比较)对象的每个属性。当两个对象的某个属性是相同的值(这两个对象的的hashcode相等)的时候才会调用equals方法进行判断。如果这两个对象相等就不添加了,如果不相等就放入一个桶中。hashcope方法决定对象在哪个桶中保存,如果两个对象的hashcope值一样(对象A的hashcope方法里面的属性值和对象B对应的hashcope方法的属性值一样),就把他们放入同一个桶中。
8.当重写hashcode方法的时候如果所有属性都用上了,这时候hashcode相等就等于equals方法,否则hashcode的范围小于equals。(两个对象的hashcope值一样,就是说明在hashcope方法的属性中,这两个对象的参与的属性是一样的。但是因为自己重写hashcope方法是时候未必把对象的每个属性都写进hashcope方法中,因此当对象的hashcope值一样的时候未必就是同一个对象)
9.删除和包含的方法现在不是只跟equals方法有关了,而是与hashcode和equals这两个有关
10:代码解释
public class Emp {
private double salar;
private String name;
private int age;
public double getSalar() {
return salar;
}
public void setSalar(double salar) {
this.salar = salar;
}
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 Emp() {
super();
// TODO Auto-generated constructor stub
}
public Emp(double salar, String name, int age) {
super();
this.salar = salar;
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Emp [salar=" + salar + ", name=" + name + ", age=" + age + "]";
}
//迭代的时候先进入hashCode方法,看看每个对象放入哪个桶中(属性相同的对象会放入一个桶中),这个方法里面放的属性是salar
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
/*result = prime * result + age;
result = prime * result + ((name == null) ? 0 : name.hashCode());*/
long temp;
temp = Double.doubleToLongBits(salar);
result = prime * result + (int) (temp ^ (temp >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (!(obj instanceof Emp))
return false;
Emp other = (Emp) obj;
if (age != other.age)
return false;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
if (Double.doubleToLongBits(salar) != Double
.doubleToLongBits(other.salar))
return false;
return true;
}
}
public class HashSetTest {
/**
* @方法的作用:使用HashSet 保存员工信息,使员工工资一样的存入一个桶中,并遍历集合
*/
public static void main(String[] args) {
HashSet hs=new HashSet();
hs.add(new Emp(5550,"张三",30));
hs.add(new Emp(1000,"lisi",30));
hs.add(new Emp(5550,"李四",25));
hs.add(new Emp(4800,"王五",37));
hs.add(new Emp(3000,"hh",56));
hs.add(new Emp(3000,"王八",56));
hs.add(new Emp(3000,"王八",56));
Iterator it=hs.iterator();
while(it.hasNext()){
Object obj=it.next();
System.out.println(obj);
}
}
}
相关推荐
Set是java中一个不包含重复元素的collection。更正式地说,set 不包含满足e1....HashSet与TreeSet都是基于Set接口的实现类。其中TreeSet是Set的子接口SortedSet的实现类。Set接口及其子接口、实现类的结构如下所示。
Set接口的实现类包括HashSet、LinkedHashSet和TreeSet。 HashSet是基于哈希表实现的Set集合,它不保证集合中元素的顺序。由于哈希表的实现机制,HashSet的添加、删除和查找操作都具有很好的性能,时间复杂度为O(1)。...
Java数据结构--13.Java8数据结构TreeSet 前⾔ ,上⼀篇中对 Set 接⼝最终实现类 HashSet 与 LinkedHashSet 做了介绍与分析,本篇将对另⼀种 Set 接⼝的最终实现类 TreeSet 进⾏ 介绍与分析。 先来看下 TreeSet 完整...
如果是不能存放重复的元素,用Set接口下的实现类 HashSet:如果没有任何排序要求,用HashSet,因为效率高 TreeSet: 如果有排序要求用TreeSet, 如果是自然排序,需要元素实现Comparable接口,重写compareTo方法 ...
2. 两个实现类HashSet(LinkHashSet)和TreeSet,TreeSet有排序功能(Set set=new TreeSet();set.add(new Integer(8)); set.add(new Integer(4)); set.add(new Integer(7));)输出后的结果是:4 7 8 Eg: package test...
这篇集合总结一共包括十二节,介绍了一些接口和实现类的底层源码以及基本的增加、删除元素等的操作(包括List、Map、Set接口、ArrayList、Vector、LinkedList、HashSet、TreeSet、HashMap、TreeMap等实现类)。...
实现类:红色Collection|_____Set(HashSet)| |_____SortedSet(TreeSet)|_____List(LinkedList,ArrayList) Collection:集合层次中的根接口,JDK没有提供这个接口的实现类。Set:不能包含重复的元素,子接口SortedSet是...
Map接口有哪些实现类? 描述一下Map put的过程 如何得到一个线程安全的Map? HashMap有什么特点? ConcurrentHashMap是怎么分段分组的? ConcurrentHashMap是怎么分段分组的? 介绍LinkedHashMap的底层原理 请介绍...
Java标准库中提供了多种实现Collection接口的类,如ArrayList、LinkedList(List的实现)、HashSet、TreeSet(Set的实现)、PriorityQueue等。 Map: Map用于存储键值对(Key-Value Pair)的数据,它的实现类有...
Collections 类集合实现类特征图 泛形 泛型的使用 用泛型表示类 用泛型表示接口泛型方法 泛型通配符 反射 Class 类Field 类Method 类ClassLoader 类 枚举 枚举特性 枚举和普通类-样枚举神秘之处 枚举类 I/O File...
本次实验掌握了集合的概念、体系结构、分类及使用场景,了解了Set接口及主要实现类(HashSet、TreeSet),了解了解List接口及主要实现类(ArrayList、LinkedList、Vector),掌握ArrayList的使用及其与Vector的区别,...
java集合在日常开发中经常用到,对基础的掌握尤其重要,其中List,Set,Map的作用以及使用的场景和分类描述,其中Arraylist 与 LinkedList 区别,HashSet与TreeSet与LinkedHashSet对⽐,LinkedHashMap和HashMap,...
- 常见实现类有HashSet、TreeSet和LinkedHashSet等。 3. Queue(队列): - 以队列的方式存储元素,遵循先进先出(FIFO)的原则。 - 可以在队列的两端进行操作,即添加元素到队尾或移除队首元素。 - 常见实现类有...
2)了解Set接口及主要实现类(HashSet、TreeSet) 3)了解List接口及主要实现类(ArrayList、LinkedList、Vector) 4)了解Map接口及主要实现类(HashMap、TreeMap、HashTable) 二、实验内容及步骤 1、编写程序...
我们主要来学习Set的三个实现类。 HashSet TreeSet LinkedHashSet 同样,它们之间的相同点有: 都是Set的实现类 存入的元素不能重复 都是无序的(不能通过下标来查询) 他们也有不同点: HashSet的底层结构是哈希表...
11.2.3 实现类TreeSet272 11.3 List接口实现类277 11.3.1 实现类ArrayList277 11.3.2 实现类LinkedList279 11.3.3 实现类Vector281 11.4 Map接口283 11.4.1 实现类HashMap284 11.4.2 实现类LinkedHashMap285 11.4.3 ...
7.7 HashSet和HashMap的性能选项 282 7.8 操作集合的工具类:Collections 283 7.8.1 排序操作 283 7.8.2 查找,替换操作 287 7.8.3 同步控制 288 7.8.4 设置不可变集合 288 7.9 烦琐的接口:Enumeration 289 ...
文章目录Collection源码剖析(一)简介(二)源码分析 Collection源码剖析 ...JDK不提供此接口的任何直接实现:它提供了更具体的子接口(如Set和List)的实现。 (2)Collection的继承体系 关于Ite
集合比较 一种。 使用Java的HashSet时,数据结构的初始容量必须小于条目总数/ Load Factor。... 其次,当在TreeSet中实现set接口时,将实现TreeMap的接口。 我们可以说TreeSet是由TreeMap实例实现的。 testrun.tx
interface Map<Key> TreeMap<K> HashMap<K> LinkedHashMap<K> Hashtable<K> extends Dictionary<K> - JDK 1.0 接口 Set TreeSet HashSet 树特里================== 问题: 如何使用两个堆栈实现队列? 答案:...