集合
集合
1 集合常用方法
public static void main(String[] args) {
// 创建集合
Collection<String> collection = new ArrayList<>();
System.out.println(collection);
// 添加数据
collection.add("丁真");
collection.add("马嘉祺");
collection.add("蔡徐坤");
collection.add("黄子韬");
collection.add("肖战");
collection.add("鹿晗");
collection.add("吴亦凡");
// 清空集合
// collection.clear();
// 判断是否包含某个元素
boolean contains = collection.contains("马嘉祺");
System.out.println(contains);
// 判断集合是否是空
boolean empty = collection.isEmpty();
System.out.println(empty);
// 删除元素
boolean remove = collection.remove("张艺兴");
System.out.println(remove);
// 集合的实际元素个数
int size = collection.size();
System.out.println(size);
// 把集合转换成数组
String[] array = collection.toArray(new String[0]);
for (String o : array) {
System.out.println(o.substring(1));
}
System.out.println(collection);
}
2 List接口
2.1 List接口的介绍
特点:
- 有序的集合
- 方法具有索引
- 允许存储重复的元素
public static void main(String[] args) {
// 创建集合
List<String> list = new ArrayList<>();
// 添加数据
list.add("赵本山");
list.add("宋丹丹");
list.add("范伟");
list.add("宋小宝");
list.add("宋丹丹");
// 插入元素
list.add(2,"赵四");
// 获取指定索引处的元素
// IndexOutOfBoundsException 索引越界
String s = list.get(3);
System.out.println(s);
// 获取元素首次出现的索引 找不到就返回-1
int indexOf = list.indexOf("郭德纲");
System.out.println(indexOf);
// 获取元素最后一次出现的索引
int lastIndexOf = list.lastIndexOf("宋丹丹");
System.out.println(lastIndexOf);
// 删除指定索引处的元素
String remove = list.remove(2);
System.out.println(remove);
// 修改指定索引处的元素
String string = list.set(1, "高秀敏");
System.out.println(string);
System.out.println(list);
// 截取子列表 包头不包尾
List<String> strings = list.subList(1, 3);
System.out.println(strings);
}
2.2 List接口的实现类--ArrayList
ArrayList底层的数据结构是数组
内存是连续的
增删速度相对慢
查询速度相对快
异步线程不安全的集合
当第一次添加数据时会创建长度为10的数组
每次扩容是原来容量 + 原来容量 / 2
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("aa");
// 把容量变成实际个数
arrayList.trimToSize();
}
2.3 实现ArrayList
package cn.javasm.demo;
import java.util.Arrays;
import java.util.Objects;
/**
* @className: ArrayList
* @description:
* @author: gfs
* @date: 2025/7/7 10:52
* @version: 0.1
* @since: jdk17
*/
public class ArrayListDemo {
// 存储数据的数组
private String[] data;
// 元素的实际个数
private int size;
// 定义无参的构造方法
public ArrayListDemo(){
data = new String[10];
}
// 定义有参的构造方法
public ArrayListDemo(int len){
// 判断参数是否合法
if (len < 0) throw new IllegalArgumentException();
data = new String[len];
}
/**
* 添加元素方法
*/
public void add(String str){
// 判断是否需要扩容
if (size == data.length){
grow();
}
data[size++] = str;
}
/**
* 数组扩容方法
*/
private void grow() {
if (data.length <= 1)
data = Arrays.copyOf(data,data.length + 1);
else
data = Arrays.copyOf(data,data.length + (data.length >> 1));
}
/**
* 插入元素
* @param index 要插入的索引
* @param str 要插入的数据
*/
public void add(int index,String str){
// 判断索引是否越界
if (index < 0 || index > size) throw new IndexOutOfBoundsException("数组越界了");
// 判断是否需要扩容
if (size == data.length) grow();
// 插入元素
// 方式一:
// 其实就是将数据统一向后挪动一位，然后腾出来的那一位赋值要插入的数据即可
// for (int i = size - 1; i >= index;i--){
// data[i + 1] = data[i];
// }
// 方式二:
// 参数一:要拷贝的数组
// 参数二:要拷贝的数组的起始索引
// 参数三：要拷贝到的数组
// 参数四:要拷贝到的数组的起始索引
// 参数五：要拷贝的数据的长度
System.arraycopy(data,index,data,index+1,size - index);
data[index] = str;
// 实际元素个数 + 1
size++;
}
/**
* 删除指定索引处的元素
* @param index
*/
public void remove(int index){
// 判断索引是否越界
out(index);
// 删除元素就是将后面的元素统一向前挪动一位
// 方式一:
// for (int i = index;i < size - 1;i++){
// data[i] = data[i + 1];
// }
// 方式二:
System.arraycopy(data,index + 1,data,index,size - index - 1);
// 实际元素个数-1
size--;
// 最后一位设置为null
data[size] = null;
}
private void out(int index) {
if (index < 0 || index >= size) throw new IndexOutOfBoundsException();
}
/**
* 获取指定元素首次出现的索引
* @param str
* @return
*/
public int indexOf(String str){
for (int i = 0; i < size; i++) {
// if (str == data[i] || (str != null && str.equals(data[i]))){
//
// }
if (Objects.equals(str,data[i])){
return i;
}
}
return -1;
}
/**
* 删除指定的元素
* @param str 要删除的元素
*/
public void remove(String str){
int i = indexOf(str);
// 找到了元素就删除
if (i != -1) remove(i);
}
/**
* 清空集合
*/
public void clear(){
data = new String[10];
size = 0;
}
/**
* 判断是否包含指定的元素
* @param str 指定的元素
* @return true包含 false不包含
*/
public boolean contains(String str){
return indexOf(str) != -1;
}
/**
* 获取指定索引处的元素
* @param index 指定索引
* @return 元素
*/
public String get(int index){
// 判断索引是否越界
out(index);
return data[index];
}
/**
* 判断集合是否为空
* @return true 为空 false 不为空
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 替换元素
*/
public void set(int index,String str){
// 判断是否越界
out(index);
data[index] = str;
}
// 获取元素个数
public int size(){
return size;
}
public ArrayListDemo subList(int fromIndex,int toIndex){
// 判断索引是否越界
out(fromIndex);
out(toIndex);
// 判断参数是否合法
if (fromIndex > toIndex) throw new IllegalArgumentException();
// 创建新的列表
ArrayListDemo sublist = new ArrayListDemo(toIndex - fromIndex);
System.arraycopy(this.data,fromIndex,sublist.data,0,toIndex - fromIndex);
// 设置列表实际元素个数
sublist.size = toIndex - fromIndex;
return sublist;
}
@Override
public String toString() {
// [1, 2, 3]
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("[");
for (int i = 0; i < size; i++) {
if (i != size - 1){
stringBuilder.append(data[i]).append(", ");
}else {
stringBuilder.append(data[i]);
}
}
stringBuilder.append("]");
return stringBuilder.toString();
}
}
2.4 List接口的实现类--LinkedList
- 底层数据结构是双向不循环链表
- 内存的不连续的
- 增删相对快
- 查询相对慢
- 异步线程不安全的集合
2.5 实现LinkedList
package cn.javasm.demo;
import com.sun.jdi.connect.spi.TransportService;
import java.util.Objects;
/**
* @className: LinkedListDemo
* @description:
* @author: gfs
* @date: 2025/7/7 15:33
* @version: 0.1
* @since: jdk17
*/
public class LinkedListDemo {
/**
* 实际元素个数
*/
private int size;
/**
* 头节点
*/
private Node first;
/**
* 尾节点
*/
private Node last;
/**
* 私有内部类
*/
private class Node {
/**
* 数据
*/
String data;
/**
* 上一个节点
*/
Node prev;
/**
* 下一个节点
*/
Node next;
public Node(String data, Node prev, Node next) {
this.data = data;
this.prev = prev;
this.next = next;
}
}
public int getSize() {
return size;
}
public Node getFirst() {
return first;
}
public Node getLast() {
return last;
}
/**
* 添加元素
*
* @param str 要添加的元素
*/
public void add(String str) {
// 创建节点
Node node = new Node(str, null, null);
// 添加元素分为两种情况
// 如果当前是第一个节点,那么头节点和尾节点都是同一个
if (size == 0) {
this.first = node;
} else {
this.last.next = node;
node.prev = this.last;
}
this.last = node;
size++;
}
/**
* 插入元素
* @param index 要插入的索引
* @param str 要插入的数据
*/
public void add(int index,String str){
// 判断索引是否越界
if (index < 0 || index > size) throw new IndexOutOfBoundsException("索引越界");
// 插入元素分为三种情况
// 1.插入到尾部 和添加元素方法相同，直接调用添加元素方法
if (index == size){
add(str);
return;
}
// 2.插入头部
// 创建新节点
Node node = new Node(str,null,null);
if (index == 0){
node.next = this.first;
this.first.prev = node;
this.first = node;
}else {
// 3.插入到中间
Node no = getNode(index);
no.prev.next = node;
node.prev = no.prev;
node.next = no;
no.prev = node;
}
size++;
}
private void out(int index) {
if (index < 0 || index >= size) throw new IndexOutOfBoundsException("索引越界");
}
/**
* 删除指定索引处的元素
* @param index 指定的索引
*/
public void remove(int index){
// 判断索引是否越界
out(index);
// 1.删除头节点
if (index == 0){
this.first = this.first.next;
this.first.prev = null;
}else if (index == size - 1){
// 2.删除尾节点
this.last = this.last.prev;
this.last.next = null;
}else {
// 删除中间节点
// 获取指定索引处的节点
Node no = getNode(index);
no.prev.next = no.next;
no.next.prev = no.prev;
}
// 实际元素个数-1
size--;
}
/**
* 根据索引返回索引处的节点
* @param index 索引
* @return 节点
*/
private Node getNode(int index) {
Node no = first;
for (int i = 0; i < index; i++) {
no = no.next;
}
return no;
}
/**
* 查询指定元素首次出现的索引
*/
public int indexOf(String str){
// 获取头节点
Node node = this.first;
// 遍历查询
for (int i = 0; i < size; i++) {
if (Objects.equals(node.data,str)){
return i;
}
node = node.next;
}
return -1;
}
/**
* 删除指定的元素
*/
public void remove(String str){
// 获取元素首次出现的索引
int index = indexOf(str);
if (index != -1){
this.remove(index);
}
}
/**
* 清空集合
*/
public void clear(){
this.first = this.last = null;
size = 0;
}
/**
* 判断包含指定的元素
*/
public boolean contains(String str){
return indexOf(str) != -1;
}
/**
* 获取指定索引处的元素
*/
public String get(int index){
// 判断是否越界
out(index);
return getNode(index).data;
}
/**
* 判断链表是否为空
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 替换元素
*/
public void set(int index,String str){
// 判断是否越界
out(index);
// 替换元素
getNode(index).data = str;
}
/**
* 截取子列表
* @param fromIndex 开始索引
* @param toIndex 结束索引
* @return 新的子列表
*/
public LinkedListDemo subList(int fromIndex,int toIndex){
// 判断是否越界
out(fromIndex);
out(toIndex);
// 判断参数是否合法
if (fromIndex > toIndex) throw new IllegalArgumentException();
// 创建子链表
LinkedListDemo sublist = new LinkedListDemo();
// 获取fromIndex处的节点
Node node = getNode(fromIndex);
// 循环添加节点中的元素到新的子链表中
for (int i = fromIndex;i < toIndex;i++){
sublist.add(node.data);
node = node.next;
}
return sublist;
}
@Override
public String toString() {
// 创建拼接字符串对象
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("[");
Node node = first;
for (int i = 0; i < size; i++) {
if (i != size - 1){
stringBuilder.append(node.data).append(", ");
}else {
stringBuilder.append(node.data);
}
node = node.next;
}
stringBuilder.append("]");
return stringBuilder.toString();
}
}
```### 2.6 Vector
Vector的特点:
- 内部数据结构是数组,内存连续
- 查询速度快
- 增删速度慢
- 同步线程安全的集合
- 如果不需要线程安全实现，建议使用 [`ArrayList` ](https://doc.qzxdp.cn/jdk/17/zh/api/java.base/java/util/ArrayList.html)代替 `Vector`。
- 默认初始容量是10
- 默认的向量增量是0
- 如果向量增量是0，那么扩容是原来容量+原来容量
- 如果向量增量不是0，那么扩容是原来容量+向量增量
### 2.7 迭代器
- 古老迭代器
```java
public static void main(String[] args) {
Vector<String> vector = new Vector<>(15,5);
vector.add("aa");
vector.add("bb");
vector.add("cc");
vector.add("dd");
// 古老迭代器 遍历集合
Enumeration<String> elements = vector.elements();
while (elements.hasMoreElements()){
String s = elements.nextElement();
System.out.println(s);
}
System.out.println(vector);
}
- 现代迭代器
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("洛阳");
list.add("安阳");
list.add("南阳");
list.add("信阳");
list.add("驻马店");
list.add("开封");
list.add("许昌");
list.add("新乡");
// 获取迭代器
// Iterator<String> iterator = list.iterator();
// // 在java中是不允许一边遍历一边增删
// // 判断是否有下一个元素
// while (iterator.hasNext()){
// // 获取下一个元素
// String next = iterator.next();
// System.out.println(next);
// // 实际上是遍历完之后统一删除
// iterator.remove();
//// list.remove(next);
// }
// 匿名内部类
// list.forEach(new Consumer<String>() {
// // 自动把元素通过参数传入方法中
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
// lambda表达式
// list.forEach(s -> System.out.println(s));
list.forEach(System.out::println);
// System.out.println(list);
}
2.8 Stack类
Stack类是Vector的子类，也拥有Vector的特点
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
// 压栈
stack.push("石家庄");
stack.push("郑州");
stack.push("武汉");
stack.push("兰州");
// 弹栈 获取并移除栈顶元素
// EmptyStackException
// String pop = stack.pop();
// System.out.println(pop);
// 弹栈 获取栈顶元素
// String peek = stack.peek();
// System.out.println(peek);
boolean empty = stack.empty();
System.out.println(empty);
// 从栈顶向栈底搜索，位置从1开始
int i = stack.search("郑州");
System.out.println(i);
System.out.println(stack);
}
自定义Stack类
package cn.javasm.demo;
import java.util.Arrays;
import java.util.EmptyStackException;
import java.util.Objects;
/**
* @className: ArrayStack
* @description:
* @author: gfs
* @date: 2025/7/8 11:00
* @version: 0.1
* @since: jdk17
*/
public class ArrayStack {
// 底层的数组
private String[] data = new String[10];
// 实际元素个数
private int size;
/**
* 判断是否为空
*/
public boolean empty(){
return size == 0;
}
/**
* 返回栈顶元素
*/
public String peek(){
// 判断栈是否为空
if (size == 0) throw new EmptyStackException();
return data[size - 1];
}
/**
* 返回和删除栈顶元素
*/
public String pop(){
// 获取栈顶元素
String str = peek();
// 实际长度-1
size--;
return str;
}
/**
* 压栈
*/
public void push(String str){
if (size >= data.length){
data = Arrays.copyOf(data,data.length * 2);
}
// 添加元素
data[size++] = str;
}
/**
* 搜索元素
* @param str
* @return
*/
public int search(String str){
// 方式一
// for (int i = size - 1,j = 1;i >= 0;i--,j++){
// if (Objects.equals(str,data[i])){
// return j;
// }
// }
// 方式二
for (int i = size - 1;i >= 0;i--){
if (Objects.equals(str,data[i])){
return size - i;
}
}
return -1;
}
}
2.9 List接口的排序方法
public static void main(String[] args) {
// 创建一个列表
List<String> list = new ArrayList<>();
// 添加元素
list.add("dfds");
list.add("grgwe");
list.add("adgfa");
list.add("frgg");
list.add("kukth");
list.add("brthgrt");
// 排序
// list.sort(new A());
// 匿名内部类
// list.sort(new Comparator<String>() {
// @Override
// public int compare(String o1, String o2) {
// return o1.charAt(0) - o2.charAt(0);
// }
// });
// lambda表达式
list.sort((o1,o2) -> o1.charAt(0) - o2.charAt(0));
System.out.println(list);
List<Person> personList = new ArrayList<>();
personList.add(new Person("萧峰",30,98));
personList.add(new Person("段誉",18,96));
personList.add(new Person("虚竹",25,99));
// personList.sort(new Comparator<Person>() {
// @Override
// public int compare(Person o1, Person o2) {
// return o1.getScore() - o2.getScore();
// }
// });
// lambda表达式
personList.sort((a,b) -> a.getScore() - b.getScore());
personList.forEach(System.out::println);
}
3 Set接口
Set接口中不包含重复的元素
3.1 HashSet类
特点:
- 底层是哈希表
- 元素不能重复
- 元素是无序的
- 元素的位置可能发生改变
- 异步线程不安全的
- HashMap底层是数组加链表加红黑树
- 可以指定初始容量和加载因子，指定的初始容量一定是2的n次方的形式
- 当链表长度>8,并且数组长度>=64,那么会把链表扭转成红黑树
- 当红黑树的长度<=6,会把红黑树扭转成链表
3.2 LinkedHashSet类
特点:
- 底层结构是哈希表和双向链表
- 有序的
- 异步线程不安全的
LinkedHashSet<String> linkedHashSet = new LinkedHashSet<>();
linkedHashSet.add("逍遥子");
linkedHashSet.add("曲非烟");
linkedHashSet.add("木婉清");
linkedHashSet.add("东方不败");
System.out.println(linkedHashSet);
3.3 TreeSet类
public static void main(String[] args) {
// 如果是字符串，会按照字符进行升序的排序
TreeSet<String> treeSet = new TreeSet<>();
treeSet.add("lala");
treeSet.add("ufo");
treeSet.add("nba");
treeSet.add("abc");
treeSet.add("aad");
System.out.println(treeSet);
// 在TreeSet中的元素对应的类必须实现Comparable接口
TreeSet<Person> treeSet1 = new TreeSet<>();
treeSet1.add(new Person("刘亦菲",37,90));
treeSet1.add(new Person("赵雅芝",70,100));
treeSet1.add(new Person("杨幂",40,95));
System.out.println(treeSet1);
}
public class Person implements Comparable<Person>{
/**
* 当前的对象和传入的对象进行比较
* 如果返回值是正值，那么当前对象放在传入对象的后面
* 如果返回值是负值，那么当前对象放在传入对象的前面
* @param o the object to be compared.
* @return
*/
@Override
public int compareTo(Person o) {
return this.score - o.getScore();
}
}
4 Queue
Queue称之为队列接口，通常以FIFO(First In First Out)先进先出形式排序
public static void main(String[] args) {
Queue<String> queue = new LinkedList<>();
// 添加元素
// queue.add("杨颖");
// queue.add("迪丽热巴");
// queue.add("古力娜扎");
// queue.add("张若男");
// queue.offer("赵丽颖");
// 获取并删除元素
// 如果没有元素返回null
// String poll = queue.poll();
// System.out.println(poll);
// // 如果没有元素抛出NoSuchElementException
// String remove = queue.remove();
// System.out.println(remove);
// 获取元素 如果没有元素抛出NoSuchElementException
// String element = queue.element();
// System.out.println(element);
// 获取元素 如果没有元素,返回null
String peek = queue.peek();
System.out.println(peek);
System.out.println(queue);
}
5 泛型
泛型是jdk1.5的特性，保证程序的安全性，减少了代码量，避免了类型的强制转换
优点:把运行时的问题提前到了编译阶段
泛型可以定义在类，接口和方法上面
5.1 泛型类
在类的后面添加<>,一般使用大写字母来表示泛型
E: element 元素
T: type 类型
R: result 结果
K: key 键
V: value 值
如果有多个泛型，使用,隔开
public class Student<E,A> {
private E name;
private A age;
public A getAge() {
return age;
}
public void setAge(A age) {
this.age = age;
}
public void setName(E name){
this.name = name;
}
public E getName(){
return name;
}
}
5.2 接口中的泛型
public interface MyInter <E>{
void show(E e);
}
// 定义实现类实现接口，但是不实现泛型
class MyInterImpl<E> implements MyInter<E>{
@Override
public void show(E e) {
System.out.println(e);
}
}
// 实现接口并且实现泛型
class MyInterImpl2 implements MyInter<Integer>{
@Override
public void show(Integer integer) {
System.out.println(integer);
}
}
5.3 方法中的泛型
// 方法的泛型
public <K> void test(K k){
System.out.println(k);
}
5.4 泛型的上限和下限
// 针对所有的数值的集合操作
// 泛型的上限: ? extends XX 表示是XX类\接口 或者是XX类的子类\子接口
public static void print(List<? extends Number> list){
}
// 泛型的下限: ? super XX 表示是XX类\接口 或者是XX类的父类\父接口
public static void test(List<? super String> list){
}
5.5 泛型的应用
- 自定义枚举
package cn.javasm.demo;
/**
* @className: AxiosStatus
* @description:
* @author: gfs
* @date: 2025/7/8 16:28
* @version: 0.1
* @since: jdk17
*/
public enum AxiosStatus {
OK(200,"success"),
ERROR(50000,"操作失败"),
PHONE_NOT_FOUND(110,"手机号未找到"),
NOT_FOUND(404,"资源未找到");
private int code;
private String message;
public int getCode() {
return code;
}
public String getMessage() {
return message;
}
AxiosStatus(int code, String message) {
this.code = code;
this.message = message;
}
}
- 自定义返回类型
package cn.javasm.demo;
/**
* @className: AxiosResult
* @description:
* @author: gfs
* @date: 2025/7/8 16:31
* @version: 0.1
* @since: jdk17
*/
public class AxiosResult<T> {
private int code;
private String message;
private T data;
private static <T> AxiosResult<T> setData(AxiosStatus axiosStatus,T t){
AxiosResult<T> axiosResult = new AxiosResult<>();
axiosResult.setCode(axiosStatus.getCode());
axiosResult.setMessage(axiosStatus.getMessage());
axiosResult.setData(t);
return axiosResult;
}
/**
* 成功 携带数据
*/
public static <T> AxiosResult<T> success(T t){
return setData(AxiosStatus.OK,t);
}
/**
* 成功 不携带数据
*/
public static <T> AxiosResult<T> success(){
return setData(AxiosStatus.OK,null);
}
/**
* 失败
*/
public static <T> AxiosResult<T> error(){
return setData(AxiosStatus.ERROR,null);
}
/**
* 自定义的失败
*/
public static <T> AxiosResult<T> error(AxiosStatus axiosStatus){
return setData(axiosStatus,null);
}
/**
* 自定义的失败 携带数据
*/
public static <T> AxiosResult<T> error(AxiosStatus axiosStatus,T t){
return setData(axiosStatus,t);
}
private AxiosResult(){}
private AxiosResult(int code, String message, T data) {
this.code = code;
this.message = message;
this.data = data;
}
public int getCode() {
return code;
}
public void setCode(int code) {
this.code = code;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
@Override
public String toString() {
return "AxiosResult{" +
"code=" + code +
", message='" + message + '\'' +
", data=" + data +
'}';
}
}
6 Stream流
Stream流是一种流式结构，是JDK1.8出现的特性，对于集合做聚合操作。Stream流中所有的接口都是函数式接口，可以使用lambda表达式
6.1 获取Stream流的方式
public static void main(String[] args) {
// 创建一个集合
List<Integer> list = Arrays.asList(1,2,3,4,5,6);
// 获取流
// 方式一:
Stream<Integer> stream = list.stream();
// 方式二:
List<Integer> list1 = Arrays.asList(1,2,3,4,5,6);
List<Integer> list2 = Arrays.asList(6,5,4,7,8,3);
List<Integer> list3 = Arrays.asList(5,4,3,8,7);
Stream<Integer> stream1 = list1.stream();
Stream<Integer> stream2 = list2.stream();
Stream<Integer> stream3 = list3.stream();
// 合并流
Stream<Integer> concat = Stream.concat(stream1, stream2);
Stream<Integer> concat1 = Stream.concat(concat, stream3);
}
6.2 常用方法
- 案例一:对指定的集合数据进行去重，然后降序排列。并且获取前3个最大值。
public static void main(String[] args) {
// 对指定的集合数据进行去重，然后降序排列。并且获取前3个最大值。
// 传统方式
List<Integer> list = new ArrayList<>();
// 向集合中添加元素
Collections.addAll(list,23,1,45,6,7,22,8,7,45,3);
// 把集合转换成TreeSet
// TreeSet<Integer> integers = new TreeSet<>(list);
// System.out.println(integers);
//
// List<Integer> datalist = new ArrayList<>();
// for (int i = 0; i < 3; i++) {
// datalist.add(integers.pollLast());
// }
// System.out.println(datalist);
// 方式二
// 获取流对象 一个stream对象只能操作一次
Stream<Integer> stream = list.stream();
// 去重
Stream<Integer> distinct = stream.distinct();
// 排序
// Stream<Integer> sorted = distinct.sorted(new Comparator<Integer>() {
// @Override
// public int compare(Integer o1, Integer o2) {
// return o2 - o1;
// }
// });
// 默认是升序 Comparator.reverseOrder() 降序
Stream<Integer> sorted = distinct.sorted(Comparator.reverseOrder());
// 获取一定的数量内容
Stream<Integer> limit = sorted.limit(3);
// 终止操作 把流转换成集合
// limit.count();
List<Integer> collect = limit.collect(Collectors.toList());
System.out.println(collect);
// 方式三
//lambda表达式
// List<Integer> collect = list.stream().distinct().sorted(Comparator.reverseOrder()).limit(3).collect(Collectors.toList());
// System.out.println(collect);
}
- 案例二: 通过多个list中最大最小值，平均值，求和。降序排序并去重后获取结果。
public static void main(String[] args) {
// 统计多个list中最大最小值，平均值，求和。降序排序并去重后获取结果
// 定义三个集合
List<Integer> list1 = Arrays.asList(3,2,5,6,1,8);
List<Integer> list2 = Arrays.asList(5,6,2,8,9,10);
List<Integer> list3 = Arrays.asList(11,4,56,2,78,3,1);
// 合并流
// Stream<Object> stream = Stream.of(list1, list2, list3).flatMap(new Function<List<Integer>, Stream<?>>() {
// // 把每个集合传进来获取集合的流
// @Override
// public Stream<?> apply(List<Integer> integers) {
// return integers.stream();
// }
// });
// 合并流后去重降序转换成集合
List<Integer> collect = Stream.of(list1, list2, list3).flatMap(List::stream).distinct().sorted(Comparator.reverseOrder()).collect(Collectors.toList());
System.out.println(collect);
// collect.stream().mapToInt(new ToIntFunction<Integer>() {
// @Override
// public int applyAsInt(Integer value) {
// return value.intValue();
// }
// });
// 把集合转换成int类型 获取统计对象
IntSummaryStatistics intSummaryStatistics = collect.stream().mapToInt(Integer::intValue).summaryStatistics();
// 平均值
System.out.println(intSummaryStatistics.getAverage());
// 最大值
System.out.println(intSummaryStatistics.getMax());
// 最小值
System.out.println(intSummaryStatistics.getMin());
// 和
System.out.println(intSummaryStatistics.getSum());
}
```- 统计集合中名字带j，分数score>75的人，根据成绩进行降序排序，根据id进行升序排序
```java
public static void main(String[] args) {
// 统计集合中名字带j，分数score>75的人，根据成绩进行降序排序，根据id进行升序排序
List<Student> students = Arrays.asList(
new Student().setId(1001).setName("james").setScore(80),
new Student().setId(1004).setName("jim").setScore(90),
new Student().setId(1002).setName("jerry").setScore(90),
new Student().setId(1003).setName("tom").setScore(98),
new Student().setId(1005).setName("jay").setScore(40)
);
// 创建集合
// List<Student> datalist = new ArrayList<>();
// for (Student student : students) {
// if (student.getName().contains("j") && student.getScore() > 75){
// datalist.add(student);
// }
// }
// System.out.println(datalist);
//
//// 根据成绩进行降序排序，根据id进行升序排序
// datalist.sort(Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getId));
// System.out.println(datalist);
// List<Student> collect = students.stream().filter(new Predicate<Student>() {
// // 返回true的元素会留在集合中 返回false的元素会被筛选掉
// @Override
// public boolean test(Student student) {
// return student.getName().contains("j") && student.getScore() > 75;
// }
// }).collect(Collectors.toList());
List<Student> collect = students.stream()
.filter((s -> s.getName().contains("j") && s.getScore() > 75))
.sorted(Comparator.comparing(Student::getScore).reversed().thenComparing(Student::getId))
.collect(Collectors.toList());
System.out.println(collect);
}
- 案例四: 把集合中的学生名称转换成大写,并且求名称中带e的同学
public static void main(String[] args) {
// 统计集合中名字带j，分数score>75的人，根据成绩进行降序排序，根据id进行升序排序
List<Student> students = Arrays.asList(
new Student().setId(1001).setName("james").setScore(80),
new Student().setId(1004).setName("jim").setScore(90),
new Student().setId(1002).setName("jerry").setScore(90),
new Student().setId(1003).setName("tom").setScore(98),
new Student().setId(1005).setName("jay").setScore(40)
);
// List<String> collect = students.stream().map(new Function<Student, String>() {
// @Override
// public String apply(Student student) {
// return student.getName().toUpperCase();
// }
// }).collect(Collectors.toList());
List<String> collect = students.stream()
.map(student -> student.getName().toUpperCase())
.filter(s -> s.contains("E"))
.collect(Collectors.toList());
System.out.println(collect);
}
- 案例五:给每一个同学都加5分
public static void main(String[] args) {
// 统计集合中名字带j，分数score>75的人，根据成绩进行降序排序，根据id进行升序排序
List<Student> students = Arrays.asList(
new Student().setId(1001).setName("james").setScore(80),
new Student().setId(1004).setName("jim").setScore(90),
new Student().setId(1002).setName("jerry").setScore(90),
new Student().setId(1003).setName("tom").setScore(98),
new Student().setId(1005).setName("jay").setScore(40)
);
// List<Student> collect = students.stream().map(new Function<Student, Student>() {
// @Override
// public Student apply(Student student) {
// student.setScore(student.getScore() + 5);
// return student;
// }
// }).collect(Collectors.toList());
// List<Student> collect = students.stream().map(student -> {
// student.setScore(student.getScore() + 5);
// return student;
// }).collect(Collectors.toList());
// List<Student> collect = students.stream().peek(new Consumer<Student>() {
// @Override
// public void accept(Student student) {
// student.setScore(student.getScore() + 5);
// }
// }).collect(Collectors.toList());
List<Student> collect = students.stream().peek(student -> student.setScore(student.getScore() + 5)).collect(Collectors.toList());
System.out.println(collect);
}
补充:断点调试
BUG:虫子 漏洞
调试:DEBUG
F8 执行下一行
F9 跳到下一个断点
浙公网安备 33010602011771号