Collection集合（单列集合）
是一个单列集合，有以下关系。
List ：有序(存储顺序和取出顺序一致)，可重复
ArrayList：线程不安全，底层使用数组实现，查询快，增删慢，效率高。
LinkedList ： 线程不安全，底层使用链表实现，查询慢，增删快，效率高。
Vector ：线程安全，底层使用数组实现，查询快，增删慢，效率低。每次容量不足时，默认自增长度的一倍（如果不指定增量的话）
Set :元素唯一一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。
HashSet :底层是由HashMap实现的，通过对象的hashCode方法与equals方法来保证插入元素的唯一性，无序(存储顺序和取出顺序不一致)，。
LinkedHashSet: 底层数据结构由哈希表和链表组成。哈希表保证元素的唯一性，链表保证元素有序。(存储和取出是一致)
TreeSet :基于 TreeMap 的 NavigableSet 实现。使用元素的自然顺序对元素进行排序，或者根据创建 set 时提供的 Comparator 进行排序，具体取决于使用的构造方法。 元素唯一。
Collection接口的常用方法：
1)add:添加单个元素
2) remove:删除指定元素
3)contains:查找元素是否存在
4)size:获取元素个数
5)isEmpty:判断是否为空
6) clear:清空
7)addAll:添加多个元素
8)containsAll:查找多个元素是否都存在
9)removeAll:删除多个元素
package com.test;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Collection;
public class MyTest {
@Test
public void test1(){
Collection col= new ArrayList();
col.add("hello");
col.add(2);
col.add(2);
col.remove(2);
col.addAll(col);//添加多个的参数为Collection类型的值，自身也可以
System.out.println("大小: "+col.size());
if (col.contains(2)){
System.out.println("含有2");
}
if (col.containsAll(col)){//参数为Collection类型的值，自身也可以
System.out.println("含有col");
}
if (!col.isEmpty()){
for (Object o1:col) {
System.out.println(o1);
}
}
col.removeAll(col);//删除多个
col.clear();//清空
}
}
遍历方式：
- 迭代器Interator
import java.util.ArrayList;
import java.util.Iterator;
public class Mitrator {
public static void main(String[] args) {
//使用Iterator迭代器对Collection下的类内容进行遍历
//快捷键: itit
Collection al=new ArrayList();
al.add(new Book("三国",22,"罗贯中"));
al.add(new Book("水浒",23,"施耐庵"));
al.add(new Book("红楼梦",24,"曹雪芹"));
//1.获取对象的Iterator迭代器
Iterator iterator= al.iterator();
//2.遍历内容
while (iterator.hasNext()) {
Object obj = iterator.next();
System.out.println("内容"+obj.toString());
}
}
}
//book实体类
class Book{
String name;
int price;
String author;
Book(){}
Book(String name,int price,String author){
this.author=author;
this.name=name;
this.price=price;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", price=" + price +
", author='" + author + '\'' +
'}';
}
}
- foreach(增强for循环）
for (Book book : a1) {
System.out.println("book=" + book)
}
List
List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。List中可以有相同的元素，可以有null值。
继承关系：
List:元素是有序的(怎么存的就怎么取出来，顺序不会乱)，元素可以重复（角标1上有个3，角标2上也可以有个3）因为该集合体系有索引，
ArrayList：底层的数据结构使用的是数组结构（数组长度是可变的百分之五十延长）（特点是查询很快，但增删较慢）线程不同步
LinkedList：底层的数据结构是链表结构（特点是查询较慢，增删较快）
Vector：底层是数组数据结构 线程同步（数组长度是可变的百分之百延长）（无论查询还是增删都很慢，被ArrayList替代了）
常用方法（除去从Collection继承的）：
list.addAll(2,list);//添加一个集合到指定位置后面的元素后移
list.indexOf("lwx");//获取第一次出现该值的索引
list.lastIndexOf("lwx");//获取最后一个该值的索引
list.remove(1);//移除指定位置元素
list.get(2);//根据索引得到值
list.set(0, "lx");//替换指定位置的元素的值
list=list.subList(0,2);//获取指定片段，前闭后开路径
list.toArray();//集合转为数组，顺序不变
list.clear();//清空集合
处理方式：
- 排序，使用java.util.Collections.sort
sort(list,new Comparator);//第二个参数为比较器，需要自己写
写一个比较器类，实现接口Comparator，重写compare(Object o1,Object o2)方法，比较o1和o2的大小：如果方法返回正整数，则表示o1大于o2；如果返回0，表示相等；返回负整数，表示o1小于o2。（按这种为正序，从小到大）
若比较o1,o2,和上面的写法相反，可以实现倒序排序。
eg:
//实体
package com.cn.pojo;
public class Student {
private int id;
private String name;
private int score;
public Student() {
}
public Student(int id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", score=" + score +
'}';
}
}
//比较器：
package com.cn.compare;
import com.cn.pojo.Student;
import java.util.Comparator;
public class Stu_Compare implements Comparator<Student>{
@Override
public int compare(Student s1, Student s2) {
if (s1.getScore()>s2.getScore()){
return 1;
}else if (s1.getScore()== s2.getScore()){
if (s1.getId()>s2.getId()){
return 1;
}else if (s1.getId()==s2.getId()){return 0;}
else {return -1;}
}else{
return -1;
}
}
}
//调用测试
package com.cn.test;
import com.cn.compare.Stu_Compare;
import com.cn.pojo.Student;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MyTest {
public static void main(String[] args) {
List<Student> list=new ArrayList<>();
list.add(new Student(1,"张三",77));
list.add(new Student(2,"李四",50));
list.add(new Student(3,"王五",99));
list.add(new Student(4,"赵六",22));
list.add(new Student(5,"田七",100));
Collections.sort(list,new Stu_Compare());
for (Student s:list) {
System.out.println(s);
}
}
}
输出结果：
2.排序方式二
通过实体类自身实现Comparable接口，重写compareTo方法，然后调用Collections的sort方法。
package com.cn.pojo;
public class Student implements Comparable<Student>{//实现接口，指定类型
private int id;
private String name;
private int score;
public Student() {
}
public Student(int id, String name, int score) {
this.id = id;
this.name = name;
this.score = score;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", score=" + score +
'}';
}
@Override
public int compareTo(Student s1) {//排序方式,返回大于0则this对应大于s1，小于零则this对应的小于s1对应的，等于零则相等
return s1.getScore()-this.getScore();
}
}
调用：
package com.cn.test;
import com.cn.compare.Stu_Compare;
import com.cn.pojo.Student;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MyTest {
public static void main(String[] args) {
List<Student> list=new ArrayList<>();
list.add(new Student(1,"张三",77));
list.add(new Student(2,"李四",50));
list.add(new Student(3,"王五",99));
list.add(new Student(4,"赵六",22));
list.add(new Student(5,"田七",100));
Collections.sort(list);//调用
for (Student s:list) {
System.out.println(s);
}
}
}
结果：
遍历方式：
相比Collection，List可以使用普通的for循环进行便利，使用get( i )方法获取值。
List转数组（强制转换）
package com.cn.test;
import java.util.ArrayList;
import java.util.List;
public class MyTest2 {
public static void main(String[] args) {
List<String> list=new ArrayList<String>();
list.add("111");
list.add("222");
final int size=list.size();
String[] strings=(String[]) list.toArray(new String[size]);
for (int i = 0; i < size; i++) {
System.out.println(strings[i]);
}
}
}
List去重
方式一：（有序）
新建一个List,遍历原list，使用contains()方法判断新List是否有原list的当前get()的值，如果有则跳过，如果没有则将当前值放入我们的新list中进行保存。
package com.cn.test;
import java.util.ArrayList;
import java.util.List;
public class MyTest3 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
List<Integer> list2=new ArrayList<Integer>();
for (int i = 0; i <list.size() ; i++) {
if (!list2.contains(list.get(i))){
list2.add(list.get(i));//不含有则加入新的list中，含有跳过
}
}
for (Object o : list2) { //输出检验
System.out.println(o);
}
}
}
方式二：(无序)
使用Iterator迭代器和indexOf()lastIndexOf()获取前后的下标值，比较前后的下标值
package com.cn.test;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test4 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
// 获取循环的值
Object item = iterator.next();
// 如果存在两个相同的值,则从前后获取的前后下标不同
if (list.indexOf(item) != list.lastIndexOf(item)) {
// 移除最后那个相同的值
iterator.remove();
}
}
System.out.println("去重集合:" + list);
}
方式三：(无序)
list转set去重。
package com.cn.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
public class Test4 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
Test4.method_3(list);
}
public static void method_3(List<Integer> list){
HashSet<Integer> set=new HashSet<>(list);
System.out.println("去重set："+set);
}
}
方式四： LinkedHashSet转换（有序）
package com.cn.test;
import java.util.*;
public class Test4 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
Test4.method_4(list);
}
public static void method_4(List<Integer> list){
LinkedHashSet<Integer> set = new LinkedHashSet<>(list);
System.out.println("去重集合:" + set);
}
}
方式五：TreeSet去重（无序）
package com.cn.test;
import java.util.*;
public class Test4 {
public static void main(String[] args) {
List<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
Test4.method_5(list);
}
public static void method_5(List<Integer> list){
TreeSet<Integer> set = new TreeSet<>(list);
System.out.println("去重集合:" + set);
}
}
方式六：Stream去重(有序)
package com.cn.test;
import java.util.*;
import java.util.stream.Collectors;
public class Test4 {
public static void main(String[] args) {
List<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
Test4.method_6(list);
}
public static void method_6(List<Integer> list) {
list = list.stream().distinct().collect(Collectors.toList());
System.out.println("去重集合:" + list);
}
}
ArrayList
ArrayList底层是一个Object数组，对所有的底层操作就是基于数组实现的。且ArrayList是不同步的，性能上比Vector好一点，在多线程环境中需要自己管理线程同步问题。
构造方法：
ArrayList()
// 构造一个初始容量为 10 的空列表（每次递增容量为原来的1.5倍）
ArrayList(Collection<? extends E> c)
// 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的
ArrayList(int initialCapacity)
//构造一个具有指定初始容量的空列表
常用方法：（除去List中的方法）
void ensureCapacity(int minCapacity)
//如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。
void removeRange(int fromIndex, int toIndex)
//移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。
List中方法：链接(List)
ArrayLsit底层代码：
- ArrayList中维护了一个Object类型的数组
transient Object[] elementData;
transeent 表示瞬息的，短暂的，表示该属性不会被序列号
- 每创建ArrayList对象时，如果使用的事无参构造，则对应的elementData容量为0，第一次添加，则扩容为10，如果需要再次扩容，则扩容为原来的1.5倍大小
- 如果使用的是指定大小的构造器进行创建的ArrayList对象，则enementData为指定的大小，扩容时为原来的1.5倍
遍历方式：
Iterator迭代器遍历，for增强。
去重方式：
- 使用HashSet去重
package com.cn.test;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
public class MyTest3 { //新建List去重
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
HashSet<Integer> hashSet=new HashSet<Integer>(list);
ArrayList<Integer> arrayList=new ArrayList<Integer>(hashSet);
for (Object o : arrayList) {
System.out.println(o);
}
}
}
- 使用LinkedHashSet删除ArrayList中重复元素，
LinkedHashSet<Integer> linkedHashSet=new LinkedHashSet<Integer>(list);
ArrayList<Integer> arrayList=new ArrayList<Integer>(linkedHashSet);
删除特定不同元素：
- remove删除特定元素
package com.cn.test;
import java.util.ArrayList;
public class MyTest3 { //新建List去重
public static void main(String[] args) {
ArrayList<Integer> list=new ArrayList<Integer>();
list.add(1);
list.add(2);
list.add(1);
list.add(2);
list.add(3);
list.add(5);
list.add(5);
for (int i = 0; i < list.size(); i++) {
if (list.get(i)==5)
{
list.remove(i);
i--;
}
}
for (Object o : list) {
System.out.println(o);
}
}
}
结果：
- 使用Iterator迭代器和equals()比较删除
Iterator<String> sListIterator = list.iterator();
while(sListIterator.hasNext()){
String e = sListIterator.next();
if(e.equals("3")){
sListIterator.remove();
}
}
排序:
- 使用Collections.sort()对字符串类型排序
package com.cn.test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
public class MyTest3 { //新建List去重
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
list.add("apple");
list.add("banana");
list.add("orange");
list.add("watermelon");
System.out.println("正序:");
Collections.sort(list);//字母正序
Iterator<String> iterator= list.iterator();
while (iterator.hasNext()) {
String next = iterator.next();
System.out.println(next);
}
System.out.println("逆序:");
Collections.sort(list,Collections.reverseOrder());//字母逆序
Iterator iterator2= list.iterator();
while (iterator2.hasNext()) {
Object next = iterator2.next();
System.out.println(next);
}
}
}
- 使用Comparator排序,和List中的相同
- 使用Comparable排序,同List中的
合并ArrayList并去重:
-
使用remainAll(参数):保留参数和this调用的交集到调用this之中
removeAll(参数):移除this和参数的交集
addAll():添加参数内容到this里
package com.cn.test;
import java.lang.reflect.Array;
import java.util.ArrayList;
public class MyTest3 { //新建List去重
public static void main(String[] args) {
ArrayList<String> list=new ArrayList<String>();
ArrayList<String> list2=new ArrayList<String>();
list.add("apple");
list.add("banana");
list.add("orange");
list.add("watermelon");
list2.add("apple");
list2.add("peach");
ArrayList<String> temp=new ArrayList<String>(list);
temp.retainAll(list2);//仅仅保留list和list2的交集到temp
list.removeAll(temp);//去重
ArrayList<String> sumList=new ArrayList<String>();
sumList.addAll(list);
sumList.addAll(list2);
for (Object o:sumList) {
System.out.println(o);
}
}
}
结果:
- 使用set去重两个ArrayList的合集
- 遍历列表对比数据,去除一个list的数据在进行合并
LinkedList
LinkedList类是双向列表,列表中的每个节点都包含了前一个和后一个元素的引用,基于链表实现的.因此访问数据的效率不如ArrayList.LinkedList是双向链表每个结点包含前后结点的位置信息.头结点中不存放数据.
构造方法:
LinedList<类型> list=new LinkedList<类型>();
创建一个空链表
LinkedList<类型> list = new LinkedList(Collection<? extends E> c); 使用一个集合创建一个新的linkedList。
常用方法:
-
add(E e): 将指定元素添加到此列表的结尾。
-
add(int index, E element)：在此列表中指定的位置插入指定的元素。
-
addAll(Collection<? extends E> c)：添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。
-
addAll(int index, Collection<? extends E> c)：将指定 collection 中的所有元素从指定位置开始插入此列表。
-
AddFirst(E e): 将指定元素插入此列表的开头。
-
addLast(E e): 将指定元素添加到此列表的结尾。
-
clear()： 从此列表中移除所有元素。
-
poll() :检索并删除此链表的一个头部
-
pollFirst() :检索并删除此列表的第一个元素,如果为空则返回null
-
pollLast() :检索并删除此列表的最后一个元素,为空返回null
-
peek() :检索不删除此列表的头部
-
peekFirst() :检索不删除此列表的第一个元素,如果此列表为空则返回null
-
peekLast() :检索但不删除此列表的最后一个元素,如果此列表为空则返回null
-
remove()：获取并移除此列表的头（第一个元素）。
-
remove(int index)：移除此列表中指定位置处的元素。
-
remove(Objec o)：从此列表中移除首次出现的指定元素（如果存在）。
-
removeFirst()：移除并返回此列表的第一个元素。
-
removeFirstOccurrence(Object o)：从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。
-
removeLast()：移除并返回此列表的最后一个元素。
-
removeLastOccurrence(Object o)：从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。
-
get(int index)：返回此列表中指定位置处的元素。
-
getFirst()：返回此列表的第一个元素。
-
getLast()：返回此列表的最后一个元素。
-
indexOf(Object o)：返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
-
lastIndexOf(Object o)：返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
遍历方式:
-
普通for循环+get(index)方法(不推荐)
-
使用增强for循环(推荐)
-
使用Iterator迭代器(推荐)
前面三种的使用和List中一样,可以参考List中的遍历方式
- 使用pollFirst()遍历,遍历完后列表中数据也被清空了
package com.cn.test;
import java.util.LinkedList;
public class MyTest3 { //新建List去重
public static void main(String[] args) {
LinkedList<String> list=new LinkedList<String>();
list.add("apple");
list.add("banana");
list.add("orange");
list.add("watermelon");
String next=null;
while((next=list.pollFirst())!=null){
System.out.println(next);
}
}
}
-
使用pollLast()遍历,和上一个基本相同
-
用removeFirst()遍历
-
用removeLast()遍历
排序:
使用java.util.Collections.sort,和List中的排序类似需要自己写比较器类然后调用.
具体可以参考List文章中的使用方法
Set
set集合也是单列集合,但是不能存放重复的元素,即使是null.且里面元素的存放顺序是无序的
常用方法:
boolean add(Object o)：该方法用于向集合里添加一个元素,返回值为操作是否成功.
boolean addAll(Collection c)：该方法把集合c里的所有元素添加到指定集合里。返回值为操作是否成功.
void clear()：清除集合里的所有元素，将集合长度变为0。
boolean contains(Object o)：返回集合里是否包含指定元素。
boolean containsAll(Collection c)：返回集合里是否包含集合c里的所有元素。
boolean isEmpty()：返回集合是否为空。当集合长度为0时返回true，否则返回false。
Iterator iterator()：返回一个Iterator对象，用于遍历集合里的元素。
boolean remove(Object obj)：删除集合中的指定元素obj，当集合中包含了一个或多个元素obj时，这些元素将被删除，该方法将返回true。
boolean removeAll(Collection c)：将集合中删除集合c里包含的所有元素（相当于用调用该方法的集合减集合c），如果删除了一个或一个以上的元素，则该方法返回true。
boolean retainAll(Collection c)：将集合中删除集合c里不包含的元素（相当于把调用该方法的集合变成该集合的集合c的交集），如果该操作改变了调用该方法的集合，则该方法返回true。
int size()：该方法返回集合里元素的个数。
Object[] toArray()：该方法把集合转换成一个数组，所有的集合元素变成对应的数组元素。
遍历方式:
- for增强循环
- iterator迭代器
排序方式:
- Set转ArrayList然后调用Collections.sort(ArrayList list)进行排序
package com.cn.test;
import java.util.*;
public class MyTest3 { //新建List去重
public static void main(String[] args) {
Set<Integer> set=new HashSet<Integer>();
set.add(123);
set.add(234);
set.add(444);
set.add(156);
ArrayList<Integer> list=new ArrayList<Integer>(set);
Collections.sort(list,Collections.reverseOrder());
System.out.println(list);
}
}
HashSet
Hashset实现了Set接口,其背后是一个哈希表,实际是一个HashMap实例(存储在HashMap中:实际上，我们在HashSet中插入的值充当映射对象的键，java使用常量变量来表示它的值。因此，在键值对中，所有值都是相同的。HashMap中的键才是我们在HashSet中的存储值).
在HashSet中插入的对象不能保证其插入顺序,因为其根据哈希函数散列分布的.
HashSet还实现了Serializable和Cloneable接口,因此其可被序列化
负载因子:是指当前容量的大小乘于负载因子等于容量增长的极限值.例如:如果当前容量为16,负载因子为0.75,当存入数据量达到12时就是自动增加容量的大小.
在存储Object之前，HashSet会使用hashCode()和equals()方法检查是否存在现有的条目。如果两个列表具有相同顺序的相同元素，则认为它们是相等的。当你在两个列表上调用hashCode()方法时，它们都将给出相同的散列，因为它们是相等的。
HashSet不仅存储唯一的对象，而且还存储唯一的对象集合，如ArrayList， LinkedList， Vector等(其中的元素值和顺序均一致的算作为相同的集合).
构造函数:
HashSet<E> hs=new HashSet<E>();
HashSet<E> hs = new HashSet<E>(int initialCapacity);//指定初始空间大小的
HashSet<E> hs = new HashSet<E>(int initialCapacity, float loadFactor);//指定初始大小和负载因子
HashSet<E> hs = new HashSet<E>(Collection C); //指定集合内容放入HashSet之中
遍历方式:
- Iterator迭代器
- for增强循环
TreeSet
无序不可重复,但是根据元素的大小顺序自动排序.实现自定义类型的排序需要进行定义.
TreeSet集合底层实际上是一个TreeMap，而TreeMap集合底层是一个二叉树，也将TreeSet集合中的元素称为可排序组合
基于TreeMap实现的SortedSet , 基本数据类型的排序后按升序排列元素 ,非线程安全
构造方法:
TreeSet<E> ts=new TreeSet<E>();//构建一个空的set
TreeSet<E> ts=new TreeSet<E>(Collection<E> col); //构建一个包含Collection集合的TreeSet,按照自然顺序进行排序
TreeSet<E> ts=new TreeSet<E>(Comparator<E> com); //构建一个指定排序方式的TreeSet
TreeSet<E> ts=new TreeSet<E>(); //构建一个指定有序set具有相同映射关系和相同排序的TreeSet
常用方法:
E ceiling(E e)
// 返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。
E lower(E e)
//返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。
E higher(E e)
// 返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。
Comparator<? super E> comparator()
//返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。
NavigableSet<E> descendingSet()
//返回此 set 中所包含元素的逆序视图。
E first()
//返回此 set 中当前第一个（最低）元素。
E last()
//返回此 set 中当前最后一个（最高）元素。
E floor(E e)
// 返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。
SortedSet<E> headSet(E toElement)
//返回此 set 的部分视图，其元素严格小于 toElement。
NavigableSet<E> headSet(E toElement, boolean inclusive)
// 返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。
Iterator<E> iterator()
// 返回在此 set 中的元素上按升序进行迭代的迭代器。
Iterator<E> descendingIterator()
//返回在此 set 元素上按降序进行迭代的迭代器。
E pollFirst()
//获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。
E pollLast()
//获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。
NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
//返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。
SortedSet<E> subSet(E fromElement, E toElement)
//返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。
SortedSet<E> tailSet(E fromElement)
//返回此 set 的部分视图，其元素大于等于 fromElement。
NavigableSet<E> tailSet(E fromElement, boolean inclusive)
// 返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。
TreeSet保存自定义类型,需要传入比较器或者实体类实现Comaprable的CompareTo()方法,不然会报java.lang.ClassCastException异常.
在TreeSet中实现自定义类型的排序有两种方法:
- 自定义的类实现Comparable接口的compareTo()方法重写
//自定义类,通过age比较排序
package com.cn.pojo;
public class Person implements Comparable<Person>{
String name;
int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = 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;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Person o) {
return this.age-o.age; //传递比较结果正/负/零
//this值减参数值为升序,反之为降序
}
}
调用测试:
package com.cn.test;
import com.cn.pojo.Person;
import java.util.Iterator;
import java.util.TreeSet;
public class Test5 {
public static void main(String[] args) {
Person p1=new Person("张三",22);
Person p2=new Person("张4",21);
Person p3=new Person("张5",25);
Person p4=new Person("张6",24);
TreeSet<Person> ts=new TreeSet<Person>();
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
Iterator<Person> iterator= ts.iterator();
while (iterator.hasNext()) {
Person next = iterator.next();
System.out.println(next);
}
}
}
运行结果:
- 自定义比较器,在创建TreeSet时传入比较器
实体类依旧使用我们上面的Person类.
比较器:
package com.cn.compare;
import com.cn.pojo.Person;
import java.util.Comparator;
public class P_Compare implements Comparator<Person> {
@Override
public int compare(Person o1, Person o2) {
return o2.getAge()-o1.getAge();
//第一个参数减第二个为升序,反之为降序
}
}
调用测试:
package com.cn.test;
import com.cn.compare.P_Compare;
import com.cn.pojo.Person;
import java.util.Iterator;
import java.util.TreeSet;
public class Test5 {
public static void main(String[] args) {
Person p1=new Person("张三",22);
Person p2=new Person("张4",21);
Person p3=new Person("张5",25);
Person p4=new Person("张6",24);
TreeSet<Person> ts=new TreeSet<Person>(new P_Compare());
ts.add(p1);
ts.add(p2);
ts.add(p3);
ts.add(p4);
Iterator<Person> iterator= ts.iterator();
while (iterator.hasNext()) {
Person next = iterator.next();
System.out.println(next);
}
}
}
运行结果:
