------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------
1、Set
Set的特点:
元素无序,唯一。
注意:这里的无序是指存储和取出顺序不一致。
2、HashSet
(1)HashSet:无序唯一。
HashSet底层数据结构是哈希表。
(2)用HashSet集合储存自定义对象时,并没有保证元素的唯一性,想要保证应该怎么办?
通过分析我们发现是add方法出问题了,并且跟以下这个判断有关
e.hash == hash && ((k = e.key) == key || key.equals(k))
它依赖两个方法:hashCode()和equals()
顺序:
首先,判断hashCode()值是否相同。
相同:
继续走equals()方法,根据其返回值:
true:说明元素重复,不添加到集合。
false:说明元素不重复,添加到集合。
不同:直接添加到集合。
(3)怎么重写hashCode()和equals()方法呢?
hashCode():
把对象的所有成员变量值相加即可。
如果是基本类型,就加值。如果是引用类型,就加哈希值。
equals():
A:this==obj
B:!(obj instanceof Student)
C:所有成员变量的值比较。基本类型用==,引用类型用equals()。
案例:
package com.set.hashset;
//学生类
public class Student {
private String name;
private int age;
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 Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student() {
super();
}
@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;
Student other = (Student) 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;
}
}
package com.set.hashset;
import java.util.HashSet;
/**
* HashSet储存自定义对象,并去除重复
*/
public class HashSetTest {
public static void main(String[] args) {
HashSet<Student> hs = new HashSet<Student>();
hs.add(new Student("liubei", 34));
hs.add(new Student("zhangfei", 28));
hs.add(new Student("zhangfei", 28));
hs.add(new Student("guanyu", 40));
hs.add(new Student("guanyu", 41));
hs.add(new Student("guanyu", 30));
hs.add(new Student("zhaoyun", 20));
for(Student s : hs){
System.out.println(s.getName()+"\t"+s.getAge());
}
}
}
3、TreeSet
(1)TreeSet的特点
可以对集合中的元素进行排序。
(2)TreeSet怎么保证元素排序?
排序:底层结构是二叉树。按照树节点进行存储和取出。
两种实现:
1、自然排序
让对象所属的类实现Comparable接口,并重写接口中的compareTo方法,无参构造
在自然排序中,如何保证排序和唯一性?
根据 compareTo 的返回值:
正数:说明元素大,往后放。
负数:说明元素小,往前放。
0 :元素就不添加到集合中,这就是保证唯一性的原理。
2、比较器接口排序(集合具备比较性)
TreeSet的带参构造,要求构造方法接收一个实现了Comparator接口的对象。
使用方式:
1、排序使用多次:创建一个类实现 Comparator 接口,并重写 compare 方法
将实现类的对象当做参数传给 TreeSet()
2、排序只使用一次:使用匿名内部类
唯一:根据 int compare(T o1,T o2) 方法的返回值是否为0,0不加入集合。
注意:
推荐使用比较器接口排序
原因:开发原则:对修改关闭,对扩展开放
Comparator 接口使用演示:
package com.comparator;
import java.util.Comparator;
import java.util.TreeSet;
public class ComparatorTest {
public static void main(String[] args) {
//排序并查重,使用匿名内部类
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
@Override
public int compare(Student s1, Student s2) {
int num = s1.getAge() - s2.getAge();
int num2 = (num == 0) ? (s1.getName().compareTo(s2.getName())) : num;
return num2;
}
});
Student s1 = new Student("asdff", 12);
Student s2 = new Student("bb", 23);
Student s3 = new Student("cc", 43);
Student s4 = new Student("cc", 43);
Student s5 = new Student("ddd", 33);
Student s7 = new Student("ddd", 23);
Student s6 = new Student("dddd", 43);
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());
}
}
}
(3)TreeSet存储Integer讲解唯一和排序
TreeSet 底层结构:二叉树形结构
那么,Treeset是如何存储数据的呢?
A:把第一个存储进去的数据作为根节点
B:把数据依次和根节点进行比较
大了,往右放
小了,向左放
相等,把后来的数据扔掉
从二叉树结构中取数据的内存规则
原则:从每个节点的左边开始,遵循原则 左 中 右
4、Collection体现的集合总结
(1) Collection
|--List (有序,元素可重复)
|--ArrayList
底层数据结构是数组,查询快,增删慢
线程不安全,效率高。
|--LinkedList
底层数据结构是链表,查询慢,增删快
线程不安全,效率高。
|--Vector
底层数据结构是数组,查询快,增删慢
线程安全,效率低。
|--Set (元素唯一)
|--HashSet
底层数据结构是哈希表。
如何保证元素唯一性呢?
依赖两个方法。hashCode()和equals()。
以后都自动生成。
|--TreeSet
底层数据结构是二叉树。
如何保证元素唯一性呢?如何保证元素排序呢?
根据返回值是否是0,判断元素是否重复。
排序有两种方案:
元素具备比较性 实现Comparable接口
集合具备比较性 实现Comparator接口
(2)在集合中的数据结构问题
ArrayXxx:底层数据结构是数组。查询快,增删慢。
LinkedXxx:底层数据结构是链表。查询慢,增删快。
HashXxx:底层数据结构是哈希表。跟两个有关。hashCode()和equals()
TreeXxx:底层数据结构是二叉树。两种排序方式。Comparable接口和Comparator接口
(3)什么时候,使用哪种Collection集合。
元素唯一吗?
唯一:
Set
需要排序吗?
需要:TreeSet
不需要:HashSet
不知道,用HashSet。
不唯一:
List
需要安全码?
需要:Vector
不需要:ArrayList和LinkedList
查询多:ArrayList
增删多;LinkedList
不知道,用ArrayList。
4、Collections工具类的使用
(1)面试题:Collection和Collections的区别?
A:Collection是Collection体系的顶层接口,里面定义了这个体系中的共性方法.
B:Collections是针对Collection集合操作的工具类 里面一定了一些对集合操作的方法 。比如 排序,查找,反转,最值,置换
使用演示:
package com.collection;
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsDemo {
public static void main(String[] args) {
// 创建集合对象
ArrayList<Integer> array = new ArrayList<Integer>();
// 添加元素
array.add(60);
array.add(25);
array.add(38);
array.add(213);
array.add(99);
array.add(22);
System.out.println("array:" + array);
// 排序
// public static void sort(List list)
Collections.sort(array);
System.out.println("array:" + array);
// 二分查找
// public static <T> int binarySearch(List list,T key)
// [22, 25, 38, 60, 99, 213]
int index = Collections.binarySearch(array, 60);
System.out.println("index:" + index);
// 反转
// public static void reverse(List list)
// [60, 25, 38, 213, 99, 22]
Collections.reverse(array);
System.out.println("array:" + array);
// 最大值
// public static T max(Collection coll)
Integer i = Collections.max(array);
System.out.println(i);
// 随机置换:public static void shuffle(List list)
Collections.shuffle(array);
System.out.println("array:" + array);
}
}
------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流! ----------