1.集合基础
1.集合结构体系
2.集合概念
集合提供一种存储空间可变的存储模型,存储的数据容量可以改变
- ArrayLis<>:
- 可调整大小的数组实现
- <>:是一种特殊的数据类型,泛型
- 可储存重复元素
3.集合和数组的区别
4.ArrayList
构造与添加方法:
方法名 | 说明 |
public Arraylist() | 创建一个空的集合对象 |
public boolean add(E e) | 将指定元素添加到此集合末尾 |
public void add(int index,E element) | 在此集合的指定位置插入指定元素 |
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> array = new ArrayList<>();
System.out.println(array); //[]
//添加到集合末尾
array.add("hello");
array.add("word");
array.add("java");
System.out.println(array); //[hello, word, java]
//指定位置,添加元素
array.add(1,"javase");
System.out.println(array); //[hello, javase, word, java]
array.add(4,"javaee");
System.out.println(array); //[hello, javase, word, java, javaee]
array.add(6,"javaweb");
System.out.println(array); //IndexOutOfBoundsException,不能中间跳一个位置
}
}
ArrayList 常用方法
方法名 | 说明 |
---|---|
public boolean remove(Object o) | 删除指定的元素,返回删除是否成功 |
public E remove(int index) | 删除指定索引处的元素,返回被删除的元素 |
public E set(int index,E element) | 修改指定索引处的元素,返回被修改的元素 |
public E get(int index) | 返回指定索引处的元素 |
public int size() | 返回集合中元素的个数 |
import java.util.ArrayList;
public class Demo {
public static void main(String[] args) {
//创建集合对象
ArrayList<String> array = new ArrayList<>();
System.out.println(array); //[]
//添加到集合末尾
array.add("hello");
array.add("word");
array.add("java");
System.out.println(array); //[hello, word, java]
//1,public boolean remove(Object o) 删除指定的元素,返回删除是否成功
// System.out.println(array.remove("hello")); //true; 集合变为[word, java]
// System.out.println(array.remove("javase")); //false; 集合变为[hello, word, java]
//2,public E remove(int index) 删除指定索引处的元素,返回被删除的元素
// System.out.println(array.remove(1)); //word,集合变为[hello, java]
//3,public E set(int index,E element) 修改指定索引处的元素,返回被修改的元素
// System.out.println(array.set(1,"javase")); //word;集合变为[hello, javase, java]
//4,public E get(int index) 返回指定索引处的元素
// System.out.println(array.get(0)); //hello
// System.out.println(array.get(1)); //word
// System.out.println(array.get(2)); //java
//5,public int size() 返回集合中元素的个数
System.out.println(array.size()); //3
}
}
2.Collection集合
— List 有序,可重复
- ArrayList
优点: 底层数据结构是数组,查询快,增删慢。
缺点: 线程不安全,效率高 - Vector
优点: 底层数据结构是数组,查询快,增删慢。
缺点: 线程安全,效率低 - LinkedList
优点: 底层数据结构是链表,查询慢,增删快。
缺点: 线程不安全,效率高
—Set 无序,唯一
-
HashSet
底层数据结构是哈希表。(无序,唯一)
如何来保证元素唯一性?
1.依赖两个方法:hashCode()和equals() -
LinkedHashSet
底层数据结构是链表和哈希表。(FIFO插入有序,唯一)
1.由链表保证元素有序
2.由哈希表保证元素唯一 -
TreeSet
底层数据结构是红黑树。(唯一,有序)
1. 如何保证元素排序的呢?
自然排序
比较器排序
2.如何保证元素唯一性的呢?
根据比较的返回值是否是0来决定
1.概述
是单列集合的顶层接口,它表示一组对象,这些对象也称Collection元素
JDK不提供此接口的直接实现,它提供更具体的子接口(Set 和 List)实现
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo01 {
public static void main(String[] args) {
//创建Collection集合的对象
Collection<String> c = new ArrayList<String>();
//添加元素:boolean add(E e)
c.add("hello");
c.add("world");
c.add("java");
//输出集合对象
System.out.println(c);
}
}
2.Collection集合的常用方法
方法名 | 说明 |
---|---|
public boolean add(E e) | 添加元素 |
public boolean remove(Object o) | 从集合中移除指定的元素 |
public void clear() | 清空集合中的元素 |
public boolean contains(Object o) | 判断集合中是否存在指定的元素 |
public boolean isEmpty() | 判断集合是否为空 |
public int size() | 集合的长度,也就是集合中元素的个数 |
public Object[] toArray( ) | 把集合中的元素,储存到数组中 |
import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo01 {
public static void main(String[] args) {
//创建Collection集合对象
Collection<String> c = new ArrayList<String>();
//1、public boolean add(E e) 把给定的元素添加到当前集合中
c.add("hello");
c.add("hello");
System.out.println(c); //[hello, hello] ;ArrayList可以存储重复元素
//2、public boolean remove(E e) 把给定的对象在当前集合中删除
/*System.out.println(c.remove("hello")); //true
System.out.println(c.remove("java")); //false
System.out.println(c); //[hello]*/
//3、public void clear() 清空集合中所有的元素
/*c.clear();
System.out.println(c); //[]*/
//4、public boolean contains(Object obj) 判断当前集合中是否存在指定的对象
/*System.out.println(c.contains("java")); //false
System.out.println(c.contains("hello")); //true*/
//5、public boolean isEmpty() 判断当前集合是否为空
// System.out.println(c.isEmpty()); //false
//6、public int size() 返回集合中元素的个数
// System.out.println(c.size()); //2
//7、public Object[] toArray( 把集合中的元素,储存到数组中
Object[] arr = c.toArray();
for(int i= 0;i< arr.length;i++) {
System.out.print(arr[i]+","); //hello,hello
}
}
}
3.Collection集合的遍历(应用)
Collection 集合遍历有三种方法:
- 迭代器
- foreach(增强for循环)
- DK 1.8 开始的新技术 Lambda 表达式
- 迭代器的介绍
- 迭代器,集合的专用遍历方式
- Iterator iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
- 迭代器是通过集合的iterator()方法得到的,所以我们说它是依赖于集合而存在的
方法名 | 说明 |
---|---|
Iterator<E> iterator() | 创建迭代器对象,默认指向当前集合的0索引 |
E next() | 获取迭代中的下一个元素 |
boolean hasNext() | 如果迭代具有更多元素,则返回true |
public class IteratorDemo {
public static void main(String[] args) {
//创建集合对象
Collection<String> c = new ArrayList<>();
//添加元素
c.add("hello");
c.add("world");
c.add("java");
c.add("javaee");
//Iterator<E> iterator():返回此集合中元素的迭代器,通过集合的iterator()方法得到
Iterator<String> it = c.iterator();
//用while循环改进元素的判断和获取
while (it.hasNext()) {
String s = it.next();
System.out.println(s);
}
}
}
4.集合的案例-Collection集合存储学生对象并遍历
创建一个存储学生对象的集合,存储3个学生对象,使用程序实现在控制台遍历该集合
学生类:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
}
测试类:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo02 {
public static void main(String[] args) {
//创建Collection集合对象
Collection<Student> c = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
c.add(s1);
c.add(s2);
c.add(s3);
//遍历集合(迭代器方式)
Iterator<Student> it = c.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
}
}
3.增强for循环
增强for:简化数组和Collection集合的遍历
- 实现Iterable接口的类允许其对象成为增强型 for语句的目标
- 它是JDK5之后出现的,其内部原理是一个Iterator迭代器
定义格式:
for(元素数据类型 变量名 : 数组/集合对象名) {
循环体;
}
范例:
import java.util.ArrayList;
import java.util.List;
public class ForDemo {
public static void main(String[] args) {
//int类型数组
int[] arr = {1,2,3,4,5};
for(int i : arr) {
System.out.println(i);
/*
1
2
3
4
5*/
}
//String类型数组
String[] strArray = {"java","python","scala"};
for(String s : strArray) {
System.out.println(s);
/*java
python
scala*/
}
//集合
List<String> list = new ArrayList<>();
list.add("y1");
list.add("y2");
list.add("y3");
for(String lt:list) {
System.out.println(lt);
/*y1
y2
y3*/
}
//判断:内部原理是一个Iterator迭代器
for(String s:list) {
if(s.equals("y1")) {
list.add("y4"); //ConcurrentModificationException:并发修改异常
}
}
/* //并发修改异常
for(int i=0; i<list.size(); i++) {
String s = list.get(i);
if(s.equals("world")) {
list.add("javaee");
}
}
*/
}
}
数据类型一定是集合或者数组中元素的类型
list就是要遍历的集合或数组
迭代器原理:修改第三方的值不会影响到集合中的元素
快捷生成:list.for
并发修改异常
迭代器遍历的过程中,通过集合对象修改了集合中的元素,造成了迭代器获取元素中判断预期修改值和实际修改值不一致,则会出现:ConcurrentModificationException
解决方法:用for循环遍历,然后用集合对象做对应的操作
4.List集合
- List系列集合:添加的元素是有序,可重复,有索引
- ArrayList: 添加的元素是有序,可重复,有索引
- LinkedList: 添加的元素是有序,可重复,有索引
- Vector :是线程安全的,速度慢,开发中很少使用
1.List集合的概述与特点
1.有序集合(也称为序列),用户可以精确控制列表中每个元索的插入位置。用户可以通过整数索引访问元素,并获取列表中的元素
2.与Set集合不同,List集合允许重复的元素
List集合特点
1.有索引
2.有序: 存储和取出的元素顺序一致
3.可重复: 存储的元素可以重复
2.List集合的特有方法
方法名 | 说明 |
---|---|
public void add(int index,E element) | 该集合中的指定位置上插入元素 |
public E remove(int index) | 删除列表中指定位置的元素,返回被删除的元素 |
public E set(int index,E element) | 修改指定索引的元素,返回被修改的元素 |
public E get(int index) | 返回集合中指定位置的元素 |
import java.util.ArrayList;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//创建集合对象
List<String> list = new ArrayList<>();
//添加元素
list.add("hello");
list.add("world");
list.add("java");
list.add("javaee");
System.out.println(list); //[hello,world,java,javaee]
//1、public void add(int index,E element) 该集合中的指定位置上插入元素
list.add(1,"javase");
System.out.println(list); //[hello, javase, world, java, javaee]
//2、public E remove(int index) 删除列表中指定位置的元素,返回被删除的元素
System.out.println(list.remove(1)); //javase
System.out.println(list); //[hello, world, java, javaee]
//3、public E set(int index,E element) 修改指定索引的元素,返回被修改的元素
System.out.println(list.set(0,"java1")); //hello
System.out.println(list); //[java1, world, java, javaee]
//4、public E get(int index) 返回集合中指定位置的元素
System.out.println(list.get(2)); //java
//for循环遍历
for(int i=0;i< list.size();i++) {
//5,public E get(int index) 返回集合中指定位置的元素
String s = list.get(i);
System.out.println(s);
/*java1
world
java
javaee*/
}
}
}
案例:
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListDemo {
public static void main(String[] args) {
//2、创建集合对象
List<Student> list = new ArrayList<Student>();
//3、创建学生对象
Student s1 = new Student("y1",10);
Student s2 = new Student("y2",20);
Student s3 = new Student("y3",30);
//4、学生对象添加到集合
list.add(s1);
list.add(s2);
list.add(s3);
//5、遍历集合:迭代器方法
Iterator<Student> it = list.iterator();
while(it.hasNext()) {
Student s = it.next();
System.out.println(s.getName()+","+s.getAge());
/*y1,10
y2,20
y3,30*/
}
System.out.println("--------");
//6。普通for:带有索引的遍历方式
for(int i=0; i<list.size(); i++) {
Student s = list.get(i);
System.out.println(s.getName()+","+s.getAge());
}
System.out.println("--------");
//7、遍历集合:for循环
for(int i=0;i<list.size();i++) {
Student ss = list.get(i);
System.out.println(ss.getName()+","+ss.getAge());
/*y1,10
y2,20
y3,30*/
}
}
}
5.List集合的实现类
1.List集合子类特点
ArrayList:底层数据结构数组实现,查询快,增删慢
LinkedList:底层数据结构链表实现,查询慢,增删快
2.ArrayList集合存储学生对象三种方式遍历
学生类:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
}
测试类:
import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
public static void main(String[] args) {
//创建ArrayList集合对象
ArrayList<Student> array = new ArrayList<Student>();
//创建学生对象
Student s1 = new Student("林青霞", 30);
Student s2 = new Student("张曼玉", 35);
Student s3 = new Student("王祖贤", 33);
//把学生添加到集合
array.add(s1);
array.add(s2);
array.add(s3);
//迭代器:集合特有的遍历方式
Iterator<Student> it = array.iterator();
while (it.hasNext()) {
Student s = it.next();
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//普通for:带有索引的遍历方式
for(int i=0; i<array.size(); i++) {
Student s = array.get(i);
System.out.println(s.getName() + "," + s.getAge());
}
System.out.println("--------");
//增强for:最方便的遍历方式
for(Student s : array) {
System.out.println(s.getName() + "," + s.getAge());
}
}
}
6.LinkedList集合
特有方法:
方法名 | 说明 |
---|---|
public void addFirst(E e) | 在该列表开头插入指定的元素 |
public void addLast(E e) | 将指定的元素追加到此列表的末尾 |
public E getFirst() | 返回此列表中的第一个元素 |
public E getLast() | 返回此列表中的最后一个元素 |
public E removeFirst() | 从此列表中删除并返回第一个元素 |
public E removeLast() | 从此列表中删除并返回最后一个元素 |
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
//创建集合对象
LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("java");
linkedList.add("python");
linkedList.add("scala");
System.out.println(linkedList); //[java, python, scala]
//1、public void addFirst(E,e) 在该列表开头插入指定的元素
linkedList.addFirst("1");
System.out.println(linkedList); //[1, java, python, scala]
//2、public void addLast(E,e) 将指定的元索追加到此列表的末尾
linkedList.addLast("5");
System.out.println(linkedList); //[1, java, python, scala, 5]
//3、public E getFirst() 返回此列表中的第一个元索
System.out.println(linkedList.getFirst()); //1
//4、public E getLast() 返回此列表中的最后一个元素
System.out.println(linkedList.getLast()); //5
//5、public E removeFirst 从此列表中删除并返回第一个元素
System.out.println(linkedList.removeFirst()); //1
System.out.println(linkedList);//[java, python, scala, 5]
//6、public E removeLast 从此列表中删除并返回最后一个元素
System.out.println(linkedList.removeLast()); //5
System.out.println(linkedList); //[java, python, scala]
}
}
ArrayList与LinkList的区别
ArrayList 底层是基于数组实现的,ArrayList 类是一个可以动态修改的数组,与普通数组的区别就是它是没有固定大小的限制,我们可以添加或删除元素。
LinkedList 底层是基于链表实现的,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的地址。
正因为底层数据结构的不同,他们适用的场景不同,ArrayList 更适合随机查找,LinkedList 更适合删除和添加,查询、添加、删除的时间复杂度不同。
7.set集合
1.set集合概述
- Set集合的特点
- 不包含重复元素的集合
- 没有带索引的方法,所以不能使用普通for循环
- Set集合是接口通过实现类实例化(多态的形式)
HashSet
:添加的元素是无序,不重复,无索引的LinkedHashSet
: 添加的元素是有序,不重复,无索引的TreeSet
: 不重复,无索引,按照大小默认升序排列
import java.util.HashSet;
import java.util.Set;
public class SetDemo {
public static void main(String[] args) {
//创建集合对象
Set<String> set = new HashSet<String>();
//添加元素
set.add("hello");
set.add("world");
set.add("java");
//不包含重复元素的集合
set.add("world");
//遍历
for(String s : set) {
System.out.println(s);
}
}
}
2.哈希值
哈希值:是JDK根据对象的地址或者字符串或者数字算出来的int类型的数值
Object类中有一个方法可以获取对象的哈希值
pubilc int hashcode() :返回对象的哈希码值
- 对象的哈希值特点
- 同一个对象多次调用hashCode()方法返回的哈希值是相同的
- 默认情况下,不同对象的哈希值是不同的。而重写hashCode0方法,可以实现让不同对象的哈希值相同
获取哈希值:
学生类:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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 int hashCode() {
return 0;
}
}
测试类:
public class HashDemo {
public static void main(String[] args) {
//创建学生对象
Student s1 = new Student("张三",23);
//同一个对象多次调用hashCode()方法返回的哈希值是相同的
System.out.println(s1.hashCode());
System.out.println(s1.hashCode());
System.out.println("--------");
Student s2 = new Student("李四",24);
//默认情况下,不同对象的哈希值是不相同的
//通过方法重写,可以实现不同对象的哈希值是相同的
System.out.println(s2.hashCode());
System.out.println("--------");
System.out.println("hello".hashCode()); //99162322
System.out.println("world".hashCode()); //113318802
System.out.println("java".hashCode()); //3254818
System.out.println("world".hashCode()); //113318802
System.out.println("--------");
System.out.println("唱".hashCode()); //21809
System.out.println("跳".hashCode()); //36339
}
}
8..HashSet
1.概述
HashSet集合特点
- 底层数据结构是哈希表
- 对集合的迭代顺序不作任何保证,也就是说不保证存储和取出的元素顺序一致
- 没有带索引的方法,所以不能使用普通for循环遍历
- 由于是Set集合,所以是不包含重复元素的集合
import java.util.HashSet;
import java.util.Iterator;
public class HashSetDemo01 {
public static void main(String[] args) {
HashSet<String> hs = new HashSet<>();
hs.add("java");
hs.add("python");
hs.add("scala");
hs.add("scala");
Iterator<String> it=hs.iterator();
while(it.hasNext()){
String s=it.next();
System.out.println(s);
/*python
java
scala*/
}
System.out.println("==========");
for(String s:hs) {
System.out.println(s);
/*python
java
scala*/
}
}
}
2.HashSet集合保证元素唯一性源码分析 (重要)
HashSet 1.7版本的存储流程
HashSet练习:
- 创建一个存储学生对象的集合,存储多个学生对象,使用程序实现在控制台遍历该集合
- 要求:学生对象的成员变量值相同,我们就认为是同一个对象
思路
学生类:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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 boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
if (age != student.age) return false;
return name != null ? name.equals(student.name) : student.name == null;
}
@Override
public int hashCode() {
int result = name != null ? name.hashCode() : 0;
result = 31 * result + age;
return result;
}
}
测试类:
import java.util.HashSet;
public class HashSetDemo02 {
public static void main(String[] args) {
HashSet<Student> hs = new HashSet<>();
Student s1 = new Student("y1",10);
Student s2 = new Student("y2",20);
Student s3 = new Student("y3",30);
Student s4 = new Student("y3",30);
hs.add(s1);
hs.add(s2);
hs.add(s3);
hs.add(s4);
for(Student s: hs) {
System.out.println(s.getName()+","+s.getAge());
/*y3,30
y2,20
y1,10
y3,30;s4内容和s3重复并存入了,需要重写hashCode()和equals()
*/
//重写后
/*
y1,10
y3,30
y2,20*/
}
}
}
注意:如果HashSet集合要存储自定义对象,那么必须重写hashcode和equals方法
4.LinkedHashSet集合
LinkedHashSet集合特点
哈希表和链表实现的Set接口,具有可预测的迭代次序
由链表保证元素有序,也就是说元素的存储和取出顺序是一致的
由哈希表保证元素唯一,也就是说没有重复的元素
9.TreeSet集合
1.TreeSet集合概述
- 元素有序,可以按照一定的规则进行排序,具体排序方式取决于构造方法
- TreeSet():根据其元素的自然排序进行排序
- TreeSet(Comparator comparator) :根据指定的比较器进行排序
- 没有带索引的方法,所以不能使用普通for循环遍历
- 由于是Set集合,所以不包含重复元素的集合
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Integer> ts = new TreeSet<>();
//jdk5以后添加元素自动装箱int》integer
ts.add(10);
ts.add(40);
ts.add(30);
ts.add(50);
ts.add(20);
ts.add(30);
for(Integer i:ts) {
System.out.println(i);
/*
10
20
30
40
50*/
}
}
}
2.自然排序Comparable的使用
-
案例需求
- 存储学生对象并遍历,创建TreeSet集合使用带参构造方法
- 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
-
实现步骤
- 用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元素进行排序的
- 比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(T o1,T o2)方法
- 重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
学生类:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
}
测试类:
package ceshi;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>();
//创建学生类
Student s1 = new Student("y1",10);
Student s2 = new Student("y3",30);
Student s3 = new Student("y2",20);
Student s4 = new Student("y4",40);
Student s5 = new Student("a4",40); //判断按字母排序
Student s6 = new Student("y4",40); //判断会存储重复值吗
//把学生添加到集合
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
ts.add(s5);
ts.add(s6);
//遍历集合
for(Student s:ts) {
System.out.println(s.getName()+","+s.getAge());
/*y1,10
y2,20
y3,30
a4,40
y4,40*/
}
}
}
3.比较器排序Comparator的使用
需求:
- 存储学生对象并遍历,创建TreeSet集合使用带参构造方法
- 要求:按照年龄从小到大排序,年龄相同时,按照姓名的字母顺序排序
步骤:
- 用TreeSet集合存储自定义对象,带参构造方法使用的是比较器排序对元索进行排序的
- 比较器排序,就是让集合构造方法接收Comparator的实现类对象,重写compare(To1,T o2)方法
- 重写方法时,一定要注意排序规则必须按照要求的主要条件和次要条件来写
学生类:
public class Student {
private String name;
private int age;
public Student() {
}
public Student(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;
}
}
测试类:
import java.util.Comparator;
import java.util.TreeSet;
public class TreeSetDemo {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>(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("y2",20);
Student s2 = new Student("y1",10);
Student s3 = new Student("y3",30);
Student s4 = new Student("y4",40);
ts.add(s1);
ts.add(s2);
ts.add(s3);
ts.add(s4);
for(Student s:ts) {
System.out.println(s.getName()+","+s.getAge());
}
}
}
练习:不重复的随机数
编写一个程序,获取10个1-20之间的随机数,要求随机数不能重复,并在控制台输出
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class SetDemo {
public static void main(String[] args) {
// Set<Integer> set = new HashSet<>();
Set<Integer> set = new TreeSet<>();
Random r = new Random();
//判断集合是否《10
while(set.size()<10) {
int number = r.nextInt(20)+1;
set.add(number); //把随机数添加到集合
}
for (Integer i:set) {
System.out.print(i+" "); //1(哈希set集合):16 17 2 20 8 9 10 11 14 15
//2(TreeSet集合):1 3 4 5 6 7 8 10 16 19
}
}
}
- TreeSet的主要功能用于排序
- LinkedHashSet的主要功能用于保证FIFO即有序的集合(先进先出)
- HashSet只是通用的存储数据的集合