JAVA-集合
概述
- 集合只能存放对象。比如你存一个 int 型数据 1放入集合中，其实它是自动转换成 Integer 类后存入的(装箱操作)，Java中每一种基本类型都有对应的引用类型。
- 集合存放的是多个对象的引用，对象本身还是放在堆内存中。
- 集合可以存放不同类型，不限数量的数据类型。定义集合变量时如果不指定数据类型，则默认数据类型为Object。
数组和集合的比较
针对Java中的数组定长，Java提出了集合框架，实现了一种变长存储数据的容器—集合【容积和当前元素个数】
数组不是面向对象的，存在明显的缺陷，集合弥补了数组的缺点，比数组更灵活更实用，而且不同的集合框架类可适用不同场合。如下：
- 数组能存放基本数据类型和对象，而集合类存放的都是对象的引用，而非对象本身
- 数组容量固定无法动态改变，集合类容量动态改变
- 数组无法判断其中实际存有多少元素，length只告诉了数组的容量，而集合的size()可以确切知道元素的个数
- 集合有多种实现方式和不同适用场合，不像数组仅采用顺序表方式
- 集合以类的形式存在，具有封装、继承、多态等类的特性，通过简单的方法和属性即可实现各种复杂操作，大大提高了软件的开发效率
集合框架中的接口
**
Collection接口
- 顶级接口，继承Iterable接口
- 无序、允许重复
常见方法
- size():int获取元素个数
- contains(Object):boolean 判断集合中是否有指定对象
- 使用的是equals方法进行判断，不是==
- toArray():Object[] 将集合中的所有元素以数组方式进行返回
- add(Object):boolean 向集合中添加元素
- remove(Object):boolean 从集合中删除指定的元素
- 使用的是equals方法进行判断，不是==
- clear():void 删除集合中的所有元素，清空集合
- isEmpty():boolean 判断元素个数是否为0，不判断null
- list.size()<1
迭代器
用于遍历集合中的所有元素
- Collection接口继承于Iterable接口，所以所有的Collection接口的实现类都可以进行遍历访问
- Iterator it=list.iterator();
- while(it.hasNext()){ //判断是否还有没有遍历访问的元素
- Object tmp=it.next(); //指针后移，同时获取一个元素
- }
如何获取迭代器
list.iterator():Iterator 具体的迭代器一般是由实现类提供具体的实现
###List接口
List接口是Collection接口的子接口
有序、允许重复
注意：凡是使用下标参数的，要求下标必须在[0,list.size())
-
E get(int index);按照下标获取指定位置上的元素，index就是下标值，要求index的值不能超过[0,list.size())，否则IndexOutOfBoundsException
-
E set(int index, E element) 修改指定位置index上的元素为新元素element，并返回原始位置上的元素 修改操作
-
void add(int index, E element) 在指定位置index上添加新元素element
-
E remove(int index)删除指定下标index位置上的元素，并返回删除的元素
-
int indexOf(Object o) 从前向后查找o在集合中的第一个下标位置，如果查找不到则返回-1
-
int lastIndexOf(Object o);
-
default void sort(Comparator<? super E> c) 使用自定义的比较器对象对数据元素进行排序，按照升序进行排序
###Set接口
Set接口是Collection接口的子接口
无序、不允许重复[重复元素的添加会产生覆盖]
没有新方法
boolean add(E e);向集合中追加元素e对象，如果出现重复则后盖前
问题：如何判断两个元素相等
- 首先比较两个对象的hashcode值是否相等，如果hashcode值不相等则不会调用equals，认为两个对象不相等
- 如果hashcode值相等才调用equals进行比较，否则不相等
潜规则【不是语法】：SUN要求当两个对象的equals为true时，hashcode值应该相等
常见的List接口的实现类
- ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
- LinkedList：双向链表实现，增删快，查询慢 (线程不安全)
- Vector：数组实现，重量级 (线程安全、使用少)
ArrayList实现类
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
内部实现
transient Object[] elementData; 用于存储数据，体现ArrayList采用的是数组的方式提供实现
构造器
//new ArrayList(1000);
public ArrayList(int initialCapacity) { //参数是初始化容积
if (initialCapacity > 0) { 如果容积初始值大于0则创建对应的对象
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) { 如果容积值位0则创建一个空数组
this.elementData = EMPTY_ELEMENTDATA;
} else { 如果小于0则抛出一个运行时异常
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
}
}
//new ArrayList();
public ArrayList() { 没有初始化参数值，则自动创建一个0个长的空数组
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
add方法的实现
//向存储数据的elementData添加新元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); //确保内部容量,处理数组elementData的长度，确保可以存放数据，如果当前数组长度不足，则需要增加数组长度。参数的含义是满足条件的最小容积
elementData[size++] = e;
return true; //如果添加过程中不出异常，则返回一定是true
}
ensureCapacityInternal方法
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++; //修改次数加1
if (minCapacity - elementData.length > 0) 如果所需要的最小容积大于实际存储数据的数组长度，则需要进行扩容处理
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length; 获取实际数组的长度
//符号>>表示二进制向右移位计算，>>1表示除以2,>>2表示除以4(2的平方).如果<<表示乘以2的多少次方
int newCapacity = oldCapacity + (oldCapacity >> 1); //新的容积值=旧有容器*1.5
if (newCapacity - minCapacity < 0) 新容器如果小于所需要的最小容积，则新容积为最小容积值
newCapacity = minCapacity;
//int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
if (newCapacity - MAX_ARRAY_SIZE > 0) 如果新容积值大于所允许的最大容积值
newCapacity = hugeCapacity(minCapacity); 获取满足最小容积需求的合法的容积值
//从elementData拷贝所有的数组元素，Arrays是工具类，提供了常见的针对数组的操作方法
elementData = Arrays.copyOf(elementData, newCapacity);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) 如果最小容积值小于0则抛出错误，表示OOM内存溢出
throw new OutOfMemoryError();
//例如获取的最小容积值为Integer.MAX_VALUE-7
return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
+
add方法用于向集合中添加元素，如果ArrayList中真正存放数据的数组长度不足，则新建一个数组，新数组的长度为原始长度1.5倍，并拷贝原始数组中的数据到新数组中，最后再追加新元素
Vector
Vector类定义：属于老版本提供的，从1.0，而ArrayList比较新，从1.2。属于线程安全的类，大部分方法上都有synchronized，一般用于要求线程安全的属性定义。
protected Object[] elementData; // 采用也是数组的方式存储数据
构造器方法：
public Vector() {
this(10); //表示调用当前类的其它构造器，初始化容积为10，增长的步长值为0 }
public Vector(int initialCapacity) {
this(initialCapacity, 0);
}
public Vector(int initialCapacity, int capacityIncrement) { //参数1是初始化容积，参数2是容积增长的步长值
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
this.elementData = new Object[initialCapacity]；//按照初始化容积值构建对应的数组
this.capacityIncrement = capacityIncrement; }
add方法-新增元素的实现：
public synchronized boolean add(E e) {//线程安全的方法
modCount++; //修改次数+1
ensureCapacityHelper(elementCount + 1); //处理容积
elementData[elementCount++] = e; //在数组中存储元素
return true;
}
private void ensureCapacityHelper(int minCapacity) {
// overflow-conscious code
if (minCapacity - elementData.length > 0) //需要储存的数据超出数组可以存放的数据格式，则需要进行增长
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length; //当前数组的长度，也就是可以存放的元素 个数
int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement :oldCapacity); //新长度为原始长度的2倍或者原始长度+步长值
if (newCapacity - minCapacity < 0) //如果新长度不满足最小长度要求，则新长度为最小要求的长度
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0) //如果新长度大于最大数组长度进行长度处理
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity); //将原始数组中的数据拷贝到新数组中,并替换原始数组
}
private static int hugeCapacity(int minCapacity) { //和ArrayList处理一致
if (minCapacity < 0) //OOM 内存溢出
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
remove方法–删除元素
public boolean remove(Object o) {
return removeElement(o);
}
public synchronized boolean removeElement(Object obj) {
modCount++;
int i = indexOf(obj); //查找元素的索引值
if (i >= 0) {
removeElementAt(i); //按照索引删除指定元素
return true;
}
return false;
}
public synchronized void removeElementAt(int index) {
modCount++;
//针对index索引值进行合法性验证
if (index >= elementCount) {
throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);
} else if (index < 0) {
throw new ArrayIndexOutOfBoundsException(index);
}
int j = elementCount - index - 1; //获取需要移动的元素个数
if (j > 0) { //通过拷贝的方式将数据的后续移动元素向前移动一位
System.arraycopy(elementData, index + 1, elementData, index, j);
}
elementCount--; //元素个数-1
elementData[elementCount] = null; //将数组末尾的元素值赋null
}
LinkedList
类定义：
public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>,Cloneable, java.io.Serializable
//Deque是队列接口，提供一个双端队列的访问方法实现
底层实现是双向链表
private static class Node<E> { //节点定义
E item; //具体存储的数据
Node<E> next; //向后的指针
Node<E> prev; //向前的指针
}
LinkedList
transient Node<E> first; //头指针,指向链表的第一个元素
transient Node<E> last； //尾指针,指向链表的最后一个元素
对应的构造器
public LinkedList() { //没有初始化容积
}
LinkedList中的 add方法：
1、创建Node对象，其中包含需要添加的元素值
2、Node对象的next为null
3、prev指向last
4、last对象的next为新建对象Node
5、last指向新建的Node对象
List 总结：
修改同时并发迭代访问的问题
需求：一个线程使用Iterator迭代访问集合中的元素，另外一个线程修改集合中的元素。临界资源为集合
public class T4 {
public static void main(String[] args)throws Exception {
List list = new ArrayList();
for(int i=0;i<5;i++)
list.add(i);
new Thread(()->{
System.out.println(Thread.currentThread().getName()+",begin....");
Iterator it=list.iterator();
while(it.hasNext()) {
Object tmp=it.next();
System.out.println(tmp);
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(Thread.currentThread().getName()+",end....");
}).start();
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+",begin modify....");
list.remove(0);
System.out.println(Thread.currentThread().getName()+",end modify....");
} }
对象的克隆与复制
对象赋值 Date now2=now；
两个变量now2和now中存放是同一个对象的地址，不管操作那个变量两个都受影响，因为now2和now是同一个对象。
如果希望两个变量相互不影响，则只能通过克隆实现。Java中的克隆可以分为深克隆和浅克隆。
如果需要支持克隆操作要求必须实现Cloneable接口，Object类中提供了clone()方法，这个方法是一个本地方法，是由虚拟机提供实现的
protected native Object clone() throws CloneNotSupportedException;
Cloneable接口属于标志性接口，没有具体的实现，具体实现实际上是Object类中提供的
1、自定义类上要求实现Cloneable接口
2、自定义类中要求实现clone方法，这个方法只需要调用父类的clone方法即可，一般不需要额外的处理。
浅克隆
public class Colone1 {
public static void main(String[] args) throws Exception {
stu s1 = new stu();
s1.setId(12L);
s1.setBirth(new Date());
stu s2 = (stu)s1.clone();
s2.getBirth().setYear(200);
System.out.println(s1);
System.out.println(s2);
}
}
class stu implements Cloneable{
private Long id;
private Date birth;
public Object clone() throws CloneNotSupportedException{
return super.clone();
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "stu [id=" + id + ", birth=" + birth + "]";
}
}
深克隆(一般采用对象流实现。自定义类要求实现Serializable接口)
public class clone2 {
public static void main(String[] args) {
student11 ss1 = new student11();
ss1.setId(20L);
ss1.setBirth(new Date());
student11 ss2 = (student11)ss1.deepClone();
ss1.getBirth().setYear(330);
System.out.println(ss1);
System.out.println(ss2);
}
}
class student11 implements Serializable{
private Long id;
private Date birth;
public student11 deepClone() {
student11 res= null;
try {
ByteArrayOutputStream baos =new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(this);
ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(baos.toByteArray()));
res = (student11)ois.readObject();
oos.close();
ois.close();
} catch (Exception e) {
e.printStackTrace();
}
return res;
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getBirth() {
return birth;
}
public void setBirth(Date birth) {
this.birth = birth;
}
@Override
public String toString() {
return "student11 [id=" + id + ", birth=" + birth + "]";
}
}
泛型
当将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，改对象的编译类型变成了Object类型，但其运行时类型任然为其本身类型。
List<String> list=new ArrayList<>(); //<String>用于声明list中只能存放String类型的数据，如果类型不匹配则会编译失败
//list.add(new Random()) 语法报错，编译失败
list.add("abc");
String ss=list.get(0); //语法正确，不需要进行强制类型转换(窄化操作)
什么是泛型
泛型是jdk5引入的类型机制，就是将类型参数化，它是早在1999年就制定的JSR14的实现。泛型作为一种安全机制而产生。
所谓类型参数化，是指用来声明数据的类型本身，也是可以改变的，它由实际参数来决定。在一般情况下，实际参数决定了形式参数的值。而类型参数化，则是实际参数的类型决定了形式参数的类型。
public void pp(String str){} //str实际上是形参
public void pp(Integer str){}
//调用时按照位置对应传入实际数据，实际数据叫做实参
pp("dddd")
定义方式：
public interface List<E> extends Collection<E>// 这里的<>中的内容就是类型参数，一般建议使用T或者
E之类的全大写
{
E get(int index);// 获取的元素类型就是定义时指定的类型
void add(E element);
}
List<String> list=new ArrayList<String>();
//list.add(new Random()) 编译失败，语法报错，因为E现在是String类型，不是Random
list.add("ddd");
//就是将String传递给E，用于替代定义中的E
String str=list.get(0); 不需要进行类型转换
List<Date> list=new ArrayList<>();//这里使用菱形语法，支持泛型推导
list.add("abc");//语法报错，编译时就会进行类型检查
list.add(123);//语法报错
list.add(new Date());
for(int i=0;i<list.size();i++){
Date temp=list.get(i); //获取数据不需要类型转换
System.out.println(temp.getYear()+1900);
}
泛型的好处：
1、可读性，从字面上就可以判断集合中的内容类型；
2 、类型检查，避免插入非法类型。
3 、获取数据时不在需要强制类型转换。
泛型类
定义：所谓泛型类generic class就是具有一个或多个类型参数的类
public class Generic<T>{
private T name;// 将T当做类型直接使用
}
public class 类型名<泛型名称列表>{
}
声明一个泛型类Generic，使用泛型的语法为<名称>，在类中就可以通过名称直接使用这个类型
public class Generic<T> {
private T name;
public T getName(){
return this.name;
}
public void setName(T name){
this.name=name;
}
}
如果编程中不使用泛型，使用集合会比较复杂：
ist list=new ArrayList();
list.add(123); //自动向上转型 int-->Integer-->Object
//获取数据还需要窄化操作
int kk=(Integer)list.get(0); //不进行类型判断，有可能出现ClassCastException
使用泛型，可以将运行时的类型检查搬到编译期实现；同时获取数据时不需要再编码进行类型转换
List<Integer> list=new ArrayList<>(); //从JDK1.7+支持泛型推导
list.add(123);
list.add(new Random());//编译报错
int kk=list.get(0); //不需要进行强制类型转换
泛型的例子：
public class Student<ID> {
private ID id;
public ID getId() {
return this.id;
}
public void setId(ID id) {
this.id=id;
}
}
//测试：
Student<String> s1=new Student<>();
// s1.setId(123); 编译报错，因为123不是String类型
s1.setId("123");
Student<Integer> s2=new Student<>();
// s2.setId("123");编译报错，因为"123"不是Integer类型
s2.setId(123);
声明一个泛型类Generic，使用泛型的语法规则为<名称>，在类中就可以通过名称直接使用这个类型
1 . 如果定义了泛型类，但是引用时不声明泛型值系统则识别泛型为Object类型
2.最后还需要注意：声明一个泛型实例时，传递给形参的实参必须是类类型，而不能使用int或char之类的简单类型。如果不传递类型，则系统默认类型为Object
带两个类型参数的泛型类
如果引用多个类型，可以使用逗号分隔：<S, D>;;类型参数名可以使用任意字符串，建议使用有代表意义的单个字符，以便于和普通类型名区分，如：T代表type，有源数据和目的数据就用S/D，子元素类型用E等。
泛型中的类型参数严格说明集合中装载的数据类型是什么和可以加入什么类型的数据
Collection 和 Collection 是两个没有转换关系的参数化的类型
集合类中定义泛型
泛型只能使用引用类型，而不能使用基本类型，即：List是错误的
public class Test {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
//list.add(123); 编译报错 ，123 不是String类型
list.add("123"); //“123”属于字符串
}
}
有界类型
public class Test<T extends Number> { //表示 ：允许传入T 的类型可以是Number或者Number的子类
public static void main(String[] args) {
Test<Integer> t1 = new Test<>(); //正确
Test<String> t2 = new Test<>(); //编译报错，因为String不是Number的子类
Test<Double> t3 = new Test<>(); //正确
}
}
声明泛型可以给泛型添加约束
Java提供了有界类型bounded types。在指定一个类型参数时，可以指定一个上界，声明所有的实际类型都必须是这个超类的直接或间接子类。
class 类名<T extends superclass（上界）>
例子：
public class Oper<T extends Number> {
//不确定个数的参数，进行加减操作。所以参与计算的必须是Number类型
public double add(T...params) {
double res=0;
if(params!=null && params.length>0) {
for(T tmp:params)
res+=tmp.doubleValue();
}
return res;
}
public double sub(T...params) {
double res=0;
if(params!=null && params.length>0) {
for(T tmp:params)
res-=tmp.doubleValue();
}
return res;
}
}
调用泛型类
public class Test1 {
public static void main(String[] args) {
Oper<Float> op=new Oper<>();
double res=op.add(1f,2f,3f,4f,5f,6f,7f);
System.out.println(res);
Oper<Long> op2=new Oper<>();
res=op2.sub(1L,2L,3L,4L,5L,6L,7L);
System.out.println(res);
}
}
1、接口和类都可以用来做上界。
2、类充当上界public class Oper< T extends Number>。
3、接口充当上界class Stats< T extends Comparable>这里需要注意：针对上界接口使用的关键字仍然是extends而非implements。
例子：
//要求传入T的类型必须实现了Comparable接口
public class Oper<T extends Comparable<T>> {
public void sort(List<T> list) {
if(list!=null && list.size()>1) {
for(int i=1;i<list.size()-1;i++) {
for(int k=0;k<list.size()-i;k++) {
T c1=list.get(k);
T c2=list.get(k+1);
if(c1.compareTo(c2)>0) { //因为要求T必须实现了Comparable接口，所以T中就有Comparable接口中的方法实现
list.set(k, c2);
list.set(k+1, c1);
}
}
}
}
}
}
测试类
public class Test {
public static void main(String[] args) {
Oper<Integer> op = new Oper<>();
List<Integer> list = new ArrayList<>();
Random r=new Random();
for(int i=0;i<10;i++)
list.add(r.nextInt(100));
op.sort(list);
list.forEach(System.out::println);
}
}
一个类型参数可以有多个限界，如class Stats<T extends Comparable & Serializable>。限界类型用&分隔，因为逗号用来分隔类型参数。在多个限界中，可以有多个接口，但最多只能有一个类。如果用一个类作为限界，它必须是限界列表中的第一个。
通配参数符
public class B<T>{
public void pp(List<? extends T> list){} //表示list中元素的类型必须是T类型或者T类型的子类或者T接口的实现类
public void cc(List<T> list){} //要求list中的元素必须是T类型的，假设有实参ArrayList<T子类>传入这个方法则语法报错
}
Set接口
特点：无序、不允许重复，是Collection接口的子接口
没有定义新方法，所有的方法都是Collection接口中所定义的方法
实现类：
1、HashSet存储采用哈希表的方式进行存储，HashSet采用HashCode算法来存取集合中的元素，因此具有比较好的读取和查找性能
2、 LinkedHashSet是在HashSet的基础上添加一个额外的链表结构可以记录存储数据的顺序
3、TreeSet采用的是树状结构进行数据存储
HashSet
底层实现方法：存储到Set中的所有数据最终都存储在一个HashMap中，其中存储的数据采用key的方式进行存储，值为PRESENT常量.
常用方法：
boolean add(E e)向集合Set中添加元素，注意不保证顺序
同一个内容的对象，为什么没有出现覆盖的效果？
- 设置hashCode和equals方法的调用
比对两个对象相等，调用流程为：
1、调用对象的hashcode方法，如果hashCode不相等则返回，认为两个对象不相等。
2、如果hash值相等则调用equals判断
潜规则要求：定义类时需要定义对应的hashCode和equals方法，要求：当equals为true时，hash值必须相等；当hash值相等时不一定equals为true
boolean remove(Object o) 删除指定对象，同样需要hashCode和equals方法
void clear()清空集合中的所有元素
boolean contains(Object o)判断集合中是否有指定的对象，同样需要hashCode和equals方法
int size()获取集合中的元素个数
Iterator iterator()用于遍历所存储的数据。
HashSet的特征
无序：不仅不能保证元素插入的顺序（如果需要顺序则可以使用LinkedHashSet），而且在元素在以后的顺序中也可能变化（这是由HashSet按HashCode存储对象（元素）决定的，对象变化则可能导致HashCode变化）如果需要访问的顺序和插入的顺序一致，可以使用HashSet的子类LinkedHashSet不允许重复 [equals和hashcode]。
结论：当HashSet判定对象重复时，首先调用的是对象的hashCode方法，如果两个对象的hashCode值相同时，才调用equals进行判定。如果hashCode值不相等则不会调用equals判断。如果 hashcode相等而且equals为true，则后盖前HashSet是线程非安全的，方法上没有同步约束HashSet元素值可以为NULL。
LinkedHashSet
没有什么新方法，仅仅只是在HashSet的基础上添加了一个链表结构记录存取的顺序
LinkedHashSet是HashSet的一个子类，LinkedHashSet也根据HashCode的值来决定元素的存储位置，但同时它还用一个链表来维护元素的插入顺序，插入的时候即要计算hashCode又要维护链表，而遍历的时候只需要按链表来访问元素。
TreeSet
TreeSet实现了SortedSet接口，顾名思义这是一种排序的Set集合
在map中以key为需要存放的数据，以PERSENT常量为值存放数据内部实现。
底层是用TreeMap实现的，本质上是一个红黑树原理。正因为它是排序了的，所以相对HashSet来说，TreeSet提供了一些额外的按排序位置访问元素的方法，例如first(), last(), lower(), higher(), subSet(), headSet(), tailSet()。
Set<Integer> set = new TreeSet<Integer>();
Random r = new Random();
for (int i = 0; i < 10; i++)
set.add(r.nextInt(100));
set.forEach(System.out::println);
TreeSet的排序分两种类型，一种是自然排序，另一种是定制排序。
243
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
