Java中算法、正则表达式、异常、集合框架举例详解
更新时间：2026年06月29日 09:32:51 作者：企鹅不困
这篇文章主要介绍了Java中算法、正则表达式、异常、集合框架的相关资料,文中通过代码详细介绍了排序算法（冒泡排序、选择排序）、查找算法（二二查找）、异常处理、集合（List、Set、Map）和Lambda表达式等核心概念,需要的朋友可以参考下
算法
排序算法
冒泡排序
每次从数组中找出最大值放在数组的后面去【两两比较】
package com.sandwich.d1_algorithm;
import java.util.Arrays;
public class Test1 {
public static void main(String[] args) {
int[] arr = {5, 2, 3, 1};
for(int i = 0; i < arr.length - 1; i ++) {
for(int j = 0; j < arr.length - i - 1; j ++) {
if(arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}选择排序
每轮选择当前位置，开始找出后面的较小值与该位置交换【定位比较】
package com.sandwich.d1_algorithm;
import java.util.Arrays;
public class Test2 {
public static void main(String[] args) {
int[] arr = {5, 1, 3, 2};
//普通版
for(int i = 0; i < arr.length - 1; i ++) {
for(int j = i + 1; j < arr.length; j ++) {
if(arr[i] > arr[j]) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
}
// 优化后
for(int i = 0; i < arr.length - 1; i++) {
int minIndex = i;
for(int j = i + 1; j < arr.length; j++) {
if(arr[minIndex] > arr[j]) {
minIndex = j;
}
}
if(i != minIndex) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
System.out.println(Arrays.toString(arr));
}
}查找算法
二分查找（折半查找）
前提条件：数组中的数据必须是有序的
核心思想：每次排除一半的数据，查询数据的性能明显提高极多
Java库中也有一个二分查找：Arrays.binarySearch(arr, data)
package com.sandwich.d1_algorithm;
import java.util.Arrays;
public class Test3 {
public static void main(String[] args) {
int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
System.out.println(binarySearch(arr, 150));
System.out.println(binarySearch(arr, 81));
System.out.println(Arrays.binarySearch(arr, 131));
}
public static int binarySearch(int[] arr, int data) {
int left = 0, right = arr.length - 1;
while(left <= right) {
int mid = (left + right) / 2;
if(arr[mid] == data) {
return mid;
} else if(arr[mid] < data) {
left = mid + 1;
} else if(arr[mid] > data) {
right = mid - 1;
}
}
return -1;
}
}
正则表达式
正则表达式就是由一些特定的字符组成，代表的是一个规则
作用
- 用来校验数据格式是否合法
- 在一段文本中查找满足要求的内容
package com.sandwich.d2_regex;
/**
* 目标：体验一下正则表达式来校验数据格式的合法性
* 需求：校验QQ号码是否正确，要求全部是数字，长度是（6-20）之间，不能以0开头
* */
public class regexTest {
public static void main(String[] args) {
System.out.println(checkQQ(null));
System.out.println(checkQQ("12345678"));
System.out.println(checkQQ("123Q456"));
System.out.println("================");
System.out.println(checkQ(null));
System.out.println(checkQ("12345678"));
System.out.println(checkQ("123Q456"));
}
public static boolean checkQ(String qq) {
return qq != null && qq.matches("[1-9]\\d{5,19}");
//"[1-9]": 开头不为0
//"\\d": 剩余的为数字
//"{5, 19}": 剩余的数字位数为5-19
}
public static boolean checkQQ(String qq) {
if(qq == null || qq.startsWith("0") || qq.length() < 6 || qq.length() > 20)
return false;
for (int i = 0; i < qq.length(); i++) {
char ch = qq.charAt(i);
if(ch < '0' || ch > '9')
return false;
}
return true;
}
}书写规则
应用
校验用户输入的电话、邮箱、时间是否合法
package com.sandwich.d2_regex;
import java.util.Scanner;
public class regexTest2 {
public static void main(String[] args) {
// checkPhone();
// checkEmail();
checkTime();
}
public static void checkPhone() {
while(true) {
System.out.println("请输入您的电话号码（手机|座机）：");
Scanner sc = new Scanner(System.in);
String phone = sc.nextLine();
if (phone.matches("(1[3-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})")) {
System.out.println("手机号码格式正确！");
break;
} else {
System.out.println("手机号码格式失败，请重新输入");
}
}
}
public static void checkEmail() {
while(true) {
System.out.println("请输入您的邮箱：");
Scanner sc = new Scanner(System.in);
String email = sc.nextLine();
if (email.matches("\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2}")) {
System.out.println("邮箱格式正确！");
break;
} else {
System.out.println("邮箱格式失败，请重新输入");
}
}
}
//12:59
public static void checkTime() {
while(true) {
System.out.println("请输入时间：：");
Scanner sc = new Scanner(System.in);
String time = sc.nextLine();
if (time.matches("(([01]\\d|2\\d[0-3]):[0-5]\\d)")) {
System.out.println("时间格式正确！");
break;
} else {
System.out.println("时间格式失败，请重新输入");
}
}
}
}用于查找信息
package com.sandwich.d2_regex;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class regexTest3 {
public static void main(String[] args) {
method1();
}
public static void method1() {
String data = "来黑马程序员学习Java，\n" +
"电话:1866668888，18699997777\n" +
"或者联系邮箱:boniu@itcast.cn，\n" +
"座机电话:01036517895，010-98951256\n" +
"邮箱:bozai@itcast.cn，\n" +
"邮箱:dlei0009@163.com，\n" +
"热线电话:400-618-9090，400-618-4000，4006184000，4006189090";
// 1.定义爬取谷子额
String regex = "(1[3-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})|(\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2})"
+ "|(400-?\\d{3,7}->\\d{3,7})";
// 2.把正则表达式封装成一个Pattern对象
Pattern pattern = Pattern.compile(regex);
// 3.通过pattern对象去获取查找内容的匹配器对象
Matcher matcher = pattern.matcher(data);
// 4.定义一个循环开始爬取信息
while(matcher.find()) {
String rs = matcher.group(); //获取找到的内容
System.out.println(rs);
}
}
}
用于搜索替换、分割内容
package com.sandwich.d2_regex;
import java.util.Arrays;
public class regexTest4 {
public static void main(String[] args) {
//1、public String replaceAll(String regex，String newstr):按照正则表达式匹配的内容进行替换
// 需求1:请把古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴，中间的非中文字符替换成“_“
String s1 = "请把古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴";
System.out.println(s1.replaceAll("\\w+", "-"));
//需求2(拓展):某语音系统，收到一个口吃的人说的"我我我喜欢编编编编编编编编编编编编程程程!"，需要优化成“我喜欢编程!"
/**
* (.)一组：.匹配任意字符的
* \\1：为这个组声明一个组号：1号
* +：声明必须是重复的字
* $1可以去到第1组代表的那个重复的字
*/
String s2 = "我我我喜欢编编编编编编编编编编编编程程程!";
System.out.println(s2.replaceAll("(.)\\1+", "$1"));
//2、public string[] split(string regex):按照正则表达式匹配的内容进行分割字符串，反回一个字符串数组。
// 需求1:请把古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴，中的人名获取出来。
String s3 = "古力娜扎ai8888迪丽热巴999aa5566马尔扎哈fbbfsfs42425卡尔扎巴";
String[] names = s3.split("\\w+");
System.out.println(Arrays.toString(names));
}
}
异常
异常就是代表程序出现的问题
- RuntimeException：运行时异常
- 其他异常：编译时异常
抛出异常（throws）
在方法上使用throws关键字，可以将方法内部出现的异常抛出去给调用者处理
方法 throws 异常1，异常2，异常3... {
...
}捕获异常（try...catch）直接捕获程序出现的异常
try {
//监视可能出现异常的代码
} catch(异常类型1 变量) {
//处理异常
} catch(异常类型2 变量) {
//处理异常
}...注意：throw 抛出去这个异常对象； throws 用在方法上，抛出方法内部异常
自定义异常
自定义运行时异常
package com.sandwich.d3_exception;
public class AgeIllegalRuntimeException extends RuntimeException{
public AgeIllegalRuntimeException() {
}
public AgeIllegalRuntimeException(String message) {
super(message);
}
}package com.sandwich.d3_exception;
public class ExceptionTest {
public static void main(String[] args) {
// 需求：保存一个合法的年龄
try {
saveAge(160);
System.out.println("success");
} catch (Exception e) {
e.printStackTrace();
System.out.println("bug");
}
}
public static void saveAge(int age) {
if(age > 0 && age < 150) {
System.out.println("The age is saved: " + age);
} else {
// 用一个异常对象封装这个问题
// throw抛出去这个异常对象
throw new AgeIllegalRuntimeException("/age is illegal, your age is " + age);
}
}
}
自定义编译时异常
package com.sandwich.d3_exception;
public class AgeIllegalException extends Exception{
public AgeIllegalException() {
}
public AgeIllegalException(String message) {
super(message);
}
}package com.sandwich.d3_exception;
public class ExceptionTest {
public static void main(String[] args) {
// 需求：保存一个合法的年龄
try {
saveAge2(256);
System.out.println("SaveAge2 success");
} catch (AgeIllegalException e) {
e.printStackTrace();
System.out.println("SaveAge2 has bugs");
}
}
public static void saveAge2(int age) throws AgeIllegalException{
if(age > 0 && age < 150) {
System.out.println("The age is saved: " + age);
} else {
// 用一个异常对象封装这个问题
// throw 抛出去这个异常对象
// throws 用在方法上，抛出方法内部异常
throw new AgeIllegalException("/age is illegal, your age is " + age);
}
}
}
异常的处理
集合进阶
- Collection：代表单列集合，每个元素（数据）只包含一个值
- Map：代表双列集合，每个元素包含两个值（键值对）Collection
Collection
规定的方法（功能）是全部单列集合都会继承的
Collection集合特点
- List系别集合：添加的元素是有序、可重复、有索引
- ArrayLsit、LinkedList：有序、可重复、有索引
- Set系列集合：添加的元素是无序、不重复、无索引
- HashSet：无序、不重复、无索引
- LinkedHashSet：有序、不重复、无索引
- TreeSet：按照大小默认升序排序、不重复、无索引
Collection
package com.sandwich.d4_collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class CollectionTestAPI {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>(); //多态写法
//1.public boolean add(E e):添加元素，添加成功返回true.
c.add("Java1");
c.add("Java2");
c.add("Java1");
c.add("Java2");
c.add("Java3");
System.out.println(c);
// 3.public boolean isEmpty():判断集合是否为空 是空返间true,反之。
System.out.println(c.isEmpty());
// 4.public int size():获取集合的大小。
System.out.println(c.size());
// 5.public boolean contains(object obj);判断集合中是否包含某个元素。
System.out.println(c.contains("Java1"));
// 6.public boolean remove(E e):删除某个元素:如果有多个肃复元素默认剔除前面的第一个!
System.out.println(c.remove("Java1"));
// 7.public 0bject[] toArray():把集合转换威数组
Object[] arr = c.toArray();
System.out.println(Arrays.toString(arr));
//指定类型
String[] ar = c.toArray(new String[c.size()]);
System.out.println(Arrays.toString(ar));
// 2.public void clear();清空集合的元素
c.clear();
System.out.println(c);
System.out.println("====================");
// 把一个集合的全部数据倒入到另一个集合中去
Collection<String> c1 = new ArrayList<>();
c1.add("Java1");
c1.add("Java2");
Collection<String> c2 = new ArrayList<>();
c2.add("Java3");
c2.add("Java4");
c1.addAll(c2); // 就是把c2集合的全部数据倒入到c1集合去
System.out.println(c1);
System.out.println(c2);
}
}
迭代器
迭代器是用来遍历集合的专用方法（数组没有迭代器），在Java中迭代器的代表是iterator
package com.sandwich.d4_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo01 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("A");
c.add("B");
c.add("C");
c.add("D");
System.out.println(c);
// 1.从集合对象中获取迭代器对象
Iterator<String> it = c.iterator();
System.out.println(it.next());
System.out.println(it.next());
// 2.使用循环结合迭代器遍历集合
while(it.hasNext()){
String ele = it.next();
System.out.println(ele);
}
}
}增强for循坏
for(元素的数据类型 变量名 : 数组或集合) {
}
package com.sandwich.d4_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo01 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("A");
c.add("B");
c.add("C");
c.add("D");
System.out.println(c);
Iterator<String> it = c.iterator();
for(String ele : c){
System.out.println(ele);
}
String[] names = {"A", "B", "C", "D"};
for(String name : names) {
System.out.println(name);
}
}
}
Lambda表达式
package com.sandwich.d4_collection;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.function.Consumer;
public class CollectionDemo01 {
public static void main(String[] args) {
Collection<String> c = new ArrayList<String>();
c.add("A");
c.add("B");
c.add("C");
c.add("D");
Iterator<String> it = c.iterator();
c.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
c.forEach(s -> {
System.out.println(s);
});
c.forEach(s-> System.out.println(s));
c.forEach(System.out::println);
}
}案例
package com.sandwich.d4_collection;
public class Movie {
private String name;
private double score;
private String actor;
public Movie() {
}
public Movie(String name, double score, String actor) {
this.name = name;
this.score = score;
this.actor = actor;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
public String getActor() {
return actor;
}
public void setActor(String actor) {
this.actor = actor;
}
@Override
public String toString() {
return "Movie{"
+ "name = " + name
+ ", score = " + score
+ ", actor = " + actor
+ '}';
}
}package com.sandwich.d4_collection;
import java.util.ArrayList;
import java.util.Collection;
public class CollectionTest {
public static void main(String[] args) {
Collection<Movie> movies = new ArrayList<>();
movies.add(new Movie("《肖生克的救赎》", 9.7, "罗宾斯"));
movies.add(new Movie("《霸王别姬》", 9.6, "张国荣，张丰毅"));
movies.add(new Movie("《阿甘正传》", 9.5, "汤姆·汉克斯"));
System.out.println(movies);
for (Movie movie : movies) {
System.out.println(movie.getName());
System.out.println();
}
}
}List<E>
package com.sandwich.d5_collection_list;
import java.util.ArrayList;
import java.util.List;
public class ListTest1 {
public static void main(String[] args) {
// 1.创建一个ArrayList集合对象(有序、可重复、有索引)
List<String> list = new ArrayList<>();
list.add("Z");
list.add("A");
list.add("A");
list.add("C");
System.out.println(list);
// 2.public void add(int index，E element):在某个索引位置插入元素。
list.add(2, "X");
System.out.println(list);
// 3.public E remove(int index): 根据索引删除元素,返回被删除元素
list.remove(2);
System.out.println(list);
// 4.public E get(int index):返回集合中指定位置的元素
System.out.println(list.get(3));
// 5.public E set(int index,E element): 修改索引位置处的元素,修改成功后，会返回原来的数据
System.out.println(list.set(3, "D"));
System.out.println(list);
}
}
遍历方式
package com.sandwich.d5_collection_list;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class ListTest2 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("堂宝宝");
list.add("蜘蛛精");
list.add("至尊宝");
// (1)for循环
for(int i = 0; i < list.size(); i ++) {
String s = list.get(i);
System.out.println(s);
}
// (2)迭代器
Iterator<String> it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
// (3)增强for循环（foreach遍历））
for(String s : list) {
System.out.println(s);
}
// （4）Lambda表达式
list.forEach(s -> {
System.out.println(s);
});
}
}ArrayList集合
底层原理
ArrayList是基于数组实现的，查询快、增删慢
- 利用无参构造器创建的集合，会在底层创建一个默认长度为0的数组
- 添加第一个元素时，底层会创建一个新的长度为10的数组
- 存满时，会扩容1.5倍
- 如果一次添加多个元素，1.5倍还放不下，则新创建数组的长度以实际为准
- 意思是假设原本长度为10，此时需要添加11个元素，那么长度扩增到10+11 = 21
LinkedList集合
底层原理
LinkedList是基于双链表实现的，查询慢，增删相对较快，但对首尾元素进行增删改查的速度是极快的
应用场景——适合只在首尾增删元素
可以用来设计队列
package com.sandwich.d5_collection_list;
import java.util.LinkedList;
public class ListTest3 {
public static void main(String[] args) {
// 1.创建一个队列
LinkedList<String> queue = new LinkedList<>();
queue.addLast("第1号人");
queue.addLast("第2号人");
queue.addLast("第3号人");
queue.addLast("第4号人");
System.out.println(queue);
//出队
System.out.println(queue.removeFirst());
System.out.println(queue.removeFirst());
System.out.println(queue.removeFirst());
System.out.println(queue);
}
}
可以用来设计栈
package com.sandwich.d5_collection_list;
import java.util.LinkedList;
public class ListTest3 {
public static void main(String[] args) {
// 1.创建一个栈对象
LinkedList<String> stack = new LinkedList<>();
// 压栈 push
stack.addFirst("第1颗子弹");
stack.addFirst("第2颗子弹");
stack.addFirst("第3颗子弹");
stack.addFirst("第4颗子弹");
System.out.println(stack);
// 出栈 pop
System.out.println(stack.removeFirst());
System.out.println(stack.removeFirst());
System.out.println(stack.removeFirst());
System.out.println(stack);
}
}Set<E>
特点：无序（添加数据的顺序和获取出的数据顺序不一致）；不重复；无索引
package com.sandwich.d6_collection_set;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.TreeSet;
public class SetTest1 {
public static void main(String[] args) {
// 1.创建一个Set集合的对象
// HashSet: 无序 不重复 无索引
// Set<Integer> set = new HashSet<>(); // 创建了一个HashSet的集合对象
// LinkedHashSet: 有序 不重复 无索引
// Set<Integer> set = new LinkedHashSet<>();
//TreeSet: 可排序（升序） 不重复 无索引
Set<Integer> set = new TreeSet<>();
set.add(666);
set.add(777);
set.add(555);
set.add(555);
set.add(888);
set.add(777);
System.out.println(set);
}
}哈希值
HashSet
无序 不重复 无索引
底层原理
- 基于哈希表实现
- 哈希表是一种增删改查数据，性能都较好的数据结构
HashSet集合默认不能对内容一样的两个不同对象去重复！
如果希望Set集合认为2个内容一样的对象是重复的，必须重写对象的hashCode()和equals()方法
LinkedHashSet
有序 不重复 无索引
底层原理
是基于哈希表（数组、链表、红黑树）实现的但是，它的每一个元素都额外的多了一个双链表的机制记录它前后元素的位置
TreeSet
排序（默认升序排序，按照元素的大小，由小到大排序） 不重复 无索引
底层是基于红黑树实现的排序
注意
- 对于数值类型：Integer，Double，默认按照数值本身的大小进行升序排序
- 对于字符串类型：默认按照首字母的编号升序排序
- 对于自定义类型如Student对象，TreeSet默认是无法直接排序的
自定义排序规则
- TreeSet集合存储自定义类型的对象时，必须指定排序规则，支持如下两种方式来指定比较规则
- 方法一
- 让自定义的类（如学生类）实现Comparable接口，重写里面的compareTo方法来指定比较规则
package com.sandwich.d6_collection_set;
public class Student implements Comparable<Student>{
private String name;
private int age;
private double height;
public Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
@Override
public int compareTo(Student o) {
/**
* 如果认为左边对象大于右边对象返回正整数
* 如果认为左边对象小于右边对象返回负整数
* 如果认为左边对象等于右边对象返回0
**/
// 需求：按照年龄升序排序
return this.age - o.age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}package com.sandwich.d6_collection_set;
import java.util.Set;
import java.util.TreeSet;
public class SetTest2 {
public static void main(String[] args) {
Set<Integer> set1 = new TreeSet<>();
set1.add(6);
set1.add(5);
set1.add(5);
set1.add(7);
System.out.println(set1);
Set<Student> students = new TreeSet<>();
students.add(new Student("蜘蛛精", 23, 155.5));
students.add(new Student("紫霞", 22, 162.7));
students.add(new Student("至尊宝", 26, 175.3));
students.add(new Student("牛魔王", 22, 183.5));
System.out.println(students);
}
}
牛魔王那条数据没有的原因是因为与紫霞那条中age相同，因为TreeSet不重复，因此没有了
方法二
通过调用TreeSet集合有参数构造器，可以设置Comparator对象（比较器对象，用于指定比较规则）
package com.sandwich.d6_collection_set;
import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;
public class SetTest2 {
public static void main(String[] args) {
Set<Integer> set1 = new TreeSet<>();
set1.add(6);
set1.add(5);
set1.add(5);
set1.add(7);
System.out.println(set1);
// Set<Student> students = new TreeSet<>(new Comparator<Student>() {
// @Override
// public int compare(Student o1, Student o2) {
// return Double.compare(o1.getHeight(), o2.getHeight());
// }
// });
Set<Student> students = new TreeSet<>((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()));
students.add(new Student("蜘蛛精", 23, 155.5));
students.add(new Student("紫霞", 22, 162.7));
students.add(new Student("至尊宝", 26, 175.3));
students.add(new Student("牛魔王", 22, 183.5));
System.out.println(students);
}
}
集合的并发修改异常
- 使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误
- 由于增强for循环遍历集合就是迭代器遍历集合的简化写法，因此，使用增强for循环遍历集合，又在同时删除集合中的数据时，程序也会出现并发修改异常的错误
package com.sandwich.d7_collection_exception;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
public class Test1 {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("王麻子");
list.add("小李子");
list.add("李爱华");
list.add("张全蛋");
list.add("小李");
list.add("李玉刚");
System.out.println(list);
Iterator<String> it = list.iterator();
while(it.hasNext()){
String name = it.next();
if(name.contains("李")) {
list.remove(name);
}
}
System.out.println(list);
}
}
解决：
使用it.remove();
Iterator<String> it = list.iterator();
while(it.hasNext()){
String name = it.next();
if(name.contains("李")) {
it.remove();
}
}倒着去删除
利用for循环实现删除
for(int i = 0; i < list.size(); i++){
String name = list.get(i);
if(name.contains("李")) {
list.remove(name);
}
}
解决：
i--
for(int i = 0; i < list.size(); i++){
String name = list.get(i);
if(name.contains("李")) {
list.remove(name);
i --;
}
}倒着去删除
可变参数
是一种特殊形参，定义在方法、构造器的形参列表里，格式是：数据类型...参数名称;
特点：可以不传数据给它；可以传一个或者同时传多个数据给它；也可以传一个数组给它
好处：常常用来灵活的接收数据
注意事项：
- 可变参数在方法内部就是一个数组
- 一个形参列表中，只能有一个可变参数
- 可变参数必须放在列表的最后面
Collections
package com.sandwich.d9_collections;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class CollectionsTest {
public static void main(String[] args) {
// 1、public static <T> boolean addAll(Collection<? super T>c,T...elements):为集合批量添加数据
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三","王五","李四","张麻子");
System.out.println(names);
// 2、public static void shuffle(List<?> list):打乱List集合中的元素顺序。
Collections.shuffle(names);
System.out.println(names);
System.out.println("----------------");
// 3、 public static <T> void sort(List<T> list):对List集合中的元素进行升序排序。
List<Integer> list = new ArrayList<>();
list.add(3);
list.add(5);
list.add(2);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
List<Student> students = new ArrayList<>();
students.add(new Student("蜘蛛精", 23, 155.5));
students.add(new Student("紫霞", 22, 162.7));
students.add(new Student("至尊宝", 26, 175.3));
students.add(new Student("牛魔王", 22, 183.5));
// Collections.sort(students);
// System.out.println(students);
// 4、public static <T> void sort(List<T> list,Comparator<?super T>c):对List集合中元素，按照比较器对象指定的规则
Collections.sort(students, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Double.compare(o1.getHeight(), o2.getHeight());
}
});
System.out.println(students);
}
}案例：斗地主游戏
package com.sandwich.d10_GameDemo;
public class Card {
private String number;
private String color;
private int size; // 每张牌是存在大小的
public Card() {
}
public Card(String number, String color, int size) {
this.number = number;
this.color = color;
this.size = size;
}
public String getNumber() {
return number;
}
public void setNumber(String number) {
this.number = number;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getSize() {
return size;
}
public void setSize(int size) {
this.size = size;
}
@Override
public String toString() {
return color + number;
}
}package com.sandwich.d10_GameDemo;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Room {
// 必须有一副牌
private List<Card> allCards = new ArrayList<>();
public Room() {
// 1. 做出54张牌，存入到集合allCards中
// a、点数：个数确定了，类型确定
String[] numbers = {"3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A", "2"};
// b、花色：个数确定了，类型确定
String[] colors = {"♠","❤","♣", "♦"};
int size = 0;
// c、遍历点数，再遍历花色，组织牌
for(String number : numbers) {
size ++;
for(String color : colors) {
Card c = new Card(number, color, size);
allCards.add(c);
}
}
Card c1 = new Card("", "🤡", ++ size);
Card c2 = new Card("", "🫅", ++ size);
Collections.addAll(allCards, c1, c2);
System.out.println("新牌：" + allCards);
}
// 游戏启动
public void start() {
// 洗牌
Collections.shuffle(allCards);
System.out.println("洗牌后：" + allCards);
// 发牌
List<Card> player1 = new ArrayList<>();
List<Card> player2 = new ArrayList<>();
List<Card> player3 = new ArrayList<>();
for(int i = 0; i < allCards.size() - 3; i++) {
Card c = allCards.get(i);
if(i % 3 == 0) {
player1.add(c);
} else if(i % 3 == 1) {
player2.add(c);
} else if(i % 3 == 2) {
player3.add(c);
}
}
// 排序
sortCards(player1);
sortCards(player2);
sortCards(player3);
// 看牌
System.out.println("玩家1：" + player1);
System.out.println("玩家2：" + player2);
System.out.println("玩家3：" + player3);
List<Card> lastThreeCards = allCards.subList(allCards.size() - 3, allCards.size());
System.out.println("底牌：" + lastThreeCards);
player2.addAll(lastThreeCards);
sortCards(player2);
System.out.println("玩家2抢地主：" + player2);
}
private void sortCards(List<Card> cards) {
Collections.sort(cards, new Comparator<Card>() {
@Override
public int compare(Card o1, Card o2) {
return o1.getSize() - o2.getSize();
}
});
}
}package com.sandwich.d10_GameDemo;
public class GameDemo {
public static void main(String[] args) {
Room m = new Room();
m.start();
}
}
Map
- Map集合称为双列集合，格式：{key1=value1,key2=value2,key3=value3,…}，一次需要存一对数据做为一个元素
- Map集合的每个元素“key=value”称为一个键值对/键值对对象/一个Entry对象，Map集合也被叫做“键值对集合”
- Map集合的所有键是不允许重复的，但值可以重复，键和值是一一对应的，每一个键只能找到自己对应的值
Map系列集合的特点都是由键决定的，值只是一个附属品，值是不做要求的
- HashMap（由键决定特点）：无序、不重复、无索引；（用的最多）
- LinkedHashMap（由键决定特点）：有序、不重复、无索引
- TreeMap（由键决定特点）：按照大小默认升序排序、不重复、无索引
遍历方式
键找值
package com.sandwich.d11_map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTraverseTest1 {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 162.5);
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
// map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
Set<String> keys = map.keySet();
System.out.println(keys);
for (String key : keys) {
double value = map.get(key);
System.out.println(key + "->" + value);
}
}
}键值对
package com.sandwich.d11_map;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
public class MapTraverseTest2 {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 162.5);
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
// map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
// entries = [(蜘蛛精=169.8), (牛魔王=183.6), (至尊宝=169.5), (紫霞=165.8)]
Set<Map.Entry<String, Double>> entries = map.entrySet();
for (Map.Entry<String, Double> entry : entries) {
String key = entry.getKey();
Double value = entry.getValue();
System.out.println(key + "->" + value);
}
}
}Lambda
package com.sandwich.d11_map;
import java.util.HashMap;
import java.util.Map;
import java.util.function.BiConsumer;
public class MapTraverseTest3 {
public static void main(String[] args) {
Map<String, Double> map = new HashMap<>();
map.put("蜘蛛精", 162.5);
map.put("蜘蛛精", 169.8);
map.put("紫霞", 165.8);
map.put("至尊宝", 169.5);
map.put("牛魔王", 183.6);
System.out.println(map);
// map = {蜘蛛精=169.8, 牛魔王=183.6, 至尊宝=169.5, 紫霞=165.8}
map.forEach((k, v) -> {
System.out.println(k + "->" + v);
});
map.forEach(new BiConsumer<String, Double>() {
@Override
public void accept(String k, Double v) {
System.out.println(k + "->" + v);
}
});
}
}案例
package com.sandwich.d11_map;
import java.util.*;
public class MapApplication {
public static void main(String[] args) {
List<String> data = new ArrayList<>();
String[] selects = {"A", "B", "C", "D"};
Random r = new Random();
for(int i = 1; i <= 80; i ++) {
int index = r.nextInt(4);
data.add(selects[index]);
}
Map<String, Integer> result = new HashMap<>();
for (String s : data) {
if(result.containsKey(s)) {
result.put(s, result.get(s) + 1);
} else {
result.put(s, 1);
}
}
result.forEach((k, v) -> System.out.println("景点" + k + ": " + v + "人"));
}
}HashMap
//package com.sandwich.d6_collection_set;
//
//public class Student implements Comparable<Student>{
// private String name;
// private int age;
// private double height;
//
// public Student() {
// }
//
// public Student(String name, int age, double height) {
// this.name = name;
// this.age = age;
// this.height = height;
// }
//
// @Override
// public int compareTo(Student o) {
// /**
// * 如果认为左边对象大于右边对象返回正整数
// * 如果认为左边对象小于右边对象返回负整数
// * 如果认为左边对象等于右边对象返回0
// **/
// // 需求：按照年龄升序排序
// return this.age - o.age;
// }
//
// @Override
// public String toString() {
// return "Student{" +
// "name='" + name + '\'' +
// ", age=" + age +
// ", height=" + height +
// '}';
// }
//}
package com.sandwich.d11_map;
import java.util.Objects;
public class Student {
private String name;
private int age;
private double height;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Double.compare(height, student.height) == 0 && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age, height);
}
public Student() {
}
public Student(String name, int age, double height) {
this.name = name;
this.age = age;
this.height = height;
}
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 double getHeight() {
return height;
}
public void setHeight(double height) {
this.height = height;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", height=" + height +
'}';
}
}package com.sandwich.d11_map;
import java.util.HashMap;
import java.util.Map;
public class HashMapTest {
public static void main(String[] args) {
Map<Object, Object> map = new HashMap<>();
map.put(new Student("蜘蛛精", 25, 168.5), "盘丝洞");
map.put(new Student("蜘蛛精", 25, 168.5), "水帘洞");
map.put(new Student("至尊宝", 25, 168.5), "水帘洞");
map.put(new Student("牛魔王", 25, 168.5), "牛头山");
System.out.println(map);
}
}LinkedHashMap
TreeMap
集合的嵌套
意思是集合中的元素又是一个集合
package com.sandwich.d11_map;
import java.util.*;
public class CollectionNesting {
// 江苏省 = "南京市","扬州市","苏州市","无锡市","常州市"
// 湖北省 = "武汉市","孝感市","十堰市","宜昌市","鄂州市"
// 河北省 = "石家庄市","唐山市","邢台市","保定市","张家口市"
public static void main(String[] args) {
Map<String, List<String>> map = new HashMap<>();
List<String> cities1 = new ArrayList<>();
Collections.addAll(cities1, "南京市","扬州市","苏州市","无锡市","常州市");
map.put("江苏省", cities1);
List<String> cities2 = new ArrayList<>();
Collections.addAll(cities2, "武汉市","孝感市","十堰市","宜昌市","鄂州市");
map.put("湖北省", cities2);
List<String> cities3 = new ArrayList<>();
Collections.addAll(cities3, "石家庄市","唐山市","邢台市","保定市","张家口市");
map.put("河北省", cities3);
System.out.println(map);
List<String> cities = map.get("湖北省");
for (String city : cities) {
System.out.println(city);
}
}
}Stream
package com.sandwich.d12_Stream;
import java.util.*;
import java.util.stream.Collectors;
public class StreamTest {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰", "张无忌", "周芷若", "赵敏", "张强");
System.out.println(names);
List<String> list = new ArrayList<>();
for(String name : names) {
if(name.startsWith("张") && name.length() == 3) {
list.add(name);
}
}
System.out.println(list);
// 利用stream流实现该功能
List<String> list2 = names.stream().filter(s -> s.startsWith("张")).
filter(s -> s.length() == 3).collect(Collectors.toList());
System.out.println(list2);
}
}
常用方法
获取Stream流
package com.sandwich.d12_Stream;
import java.util.*;
import java.util.stream.Stream;
public class StreamTest2 {
public static void main(String[] args) {
//1、如何获取List集合的stream流?
List<String> names = new ArrayList<>();
Collections.addAll(names, "张三丰", "张无忌", "周芷若", "赵敏", "张强");
Stream<String> stream = names.stream();
//2、如何获取Set集合的Stream流?
Set<String> set = new HashSet<>();
Collections.addAll(set, "刘德华", "张曼玉", "蜘蛛精", "马德", "德玛西亚");
Stream<String> stream1 = set.stream();
stream1.filter(s -> s.contains("德")).forEach(s -> System.out.println(s));
//3、如何获取Map集合的Stream流?
Map<String, Double> map = new HashMap<>();
map.put("古力娜扎", 172.3);
map.put("迪丽热巴", 168.3);
map.put("马尔扎哈", 166.3);
map.put("卡尔扎巴", 168.3);
Set<String> keys = map.keySet();
Stream<String> ks = keys.stream();
Collection<Double> values = map.values();
Stream<Double> vs = values.stream();
Set<Map.Entry<String, Double>> entries = map.entrySet();
Stream<Map.Entry<String, Double>> kvs = entries.stream();
kvs.filter( s -> s.getKey().contains("巴"))
.forEach(s -> System.out.println(s.getKey() + "->" + s.getValue()));
// 4、如何获取数组的stream流?
String[] names2 = {"张翠山", "东方不败", "唐大山", "独孤求败"};
Stream<String> s1 = Arrays.stream(names2);
Stream<List<String>> s2 = Stream.of(names);
}
}
package com.sandwich.d12_Stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
public class StreamTest3{
public static void main(String[] args){
List<Double> scores = new ArrayList<>();
Collections.addAll(scores,88.5, 100.0, 60.0, 99.0, 9.5, 99.6, 25.0);
// 需求1:找出成绩大于等于60分的数据，并升序后，再输出。
scores.stream().filter(score -> score >= 60).sorted().forEach(score -> System.out.println(score));
System.out.println("--------------------------------------------------");
List<Student> students = new ArrayList<>();
Student s1 =new Student("蜘蛛精",26,172.5);
Student s2 = new Student("蜘蛛精", 26,172.5);
Student s3 =new Student("紫霞", 23, 167.6);
Student s4= new Student( "白晶晶", 25, 169.0);
Student s5 =new Student( "牛魔王", 35, 183.3);
Student s6 =new Student( "牛夫人", 34, 168.5);
Collections.addAll(students,s1,s2,s3,s4,s5,s6);
// 需求2:找出年龄大于等于23,且年龄小于等于30岁的学生，并按照年龄降序输出
students.stream().filter(s->s.getAge() >= 23 && s.getAge() <= 30)
.sorted((o1, o2) -> o2.getAge() - o1.getAge())
.forEach(s-> System.out.println(s));
System.out.println("--------------------------------------------------");
// 需求3:取出身高最高的前3名学生，并输出。
students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
.limit(3).forEach(s-> System.out.println(s));
System.out.println("--------------------------------------------------");
// 需求4:取出身高倒数的2名学生，并输出。
students.stream().sorted((o1, o2) -> Double.compare(o2.getHeight(), o1.getHeight()))
.skip(students.size() - 2).forEach(System.out::println);
System.out.println("--------------------------------------------------");
students.stream().sorted((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight()))
.limit(2).forEach(s-> System.out.println(s));
System.out.println("--------------------------------------------------");
// 需求5:找出身高超过168的学生叫什么名字，要求去除重复的名字，再输出。
students.stream().filter(s -> s.getHeight() > 168).map(s -> s.getName())
.distinct().forEach(System.out::println);
System.out.println("--------------------------------------------------");
Stream<String> st1 = Stream.of("张三", "李四");
Stream<String> st2 = Stream.of("张三1", "李四2", "王五");
Stream<String> allSt = Stream.concat(st1, st2);
allSt.forEach(System.out::println);
}
}
package com.sandwich.d12_Stream;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class StreamTest4 {
public static void main(String[] args) {
List<Student> students = new ArrayList<>();
Student s1 = new Student("蜘蛛精", 26, 172.5);
Student s2 = new Student("蜘蛛精", 26, 172.5);
Student s3 = new Student("紫霞", 23, 167.6);
Student s4 = new Student("白晶晶", 25, 169.0);
Student s5 = new Student("牛魔王", 35, 183.3);
Student s6 = new Student("牛夫人", 34, 168.5);
Collections.addAll(students, s1, s2, s3, s4, s5, s6);
// 需求1:请计算出身高超过168的学生有几人。
long size = students.stream().filter(s -> s.getHeight() > 168).count();
System.out.println(size);
System.out.println("-----------------------------------------");
// 需求2:请找出身高最高的学生对象，并输出。
Student s = students.stream().max((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
System.out.println(s);
System.out.println("-----------------------------------------");
// 需求3:请找出身高最矮的学生对象，并输出。
Student ss = students.stream().min((o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())).get();
System.out.println(ss);
System.out.println("-----------------------------------------");
// 需求4:请找出身高超过170的学生对象，并放到一个新集合中去返回。
Stream<Student> studentStream = students.stream().filter(a -> a.getHeight() > 170);
// List<Student> students1 = students.stream().filter(a -> a.getHeight() > 170).collect(Collectors.toList());
List<Student> students1 = studentStream.collect(Collectors.toList());
System.out.println(students1);
//报错，因为流只能收集一次
// Set<Student> students2 = studentStream.collect(Collectors.toSet());
// System.out.println(students2);
System.out.println("----------------------------------------");
// 需求5:请找出身高超过170的学生对象，并把学生对象的名字和身高，存入到一个Map集合返回。
Map<String, Double> map = students.stream().filter(a -> a.getHeight() > 170)
.distinct().collect(Collectors.toMap(a -> a.getName(), a -> a.getHeight()));
System.out.println(map);
// Object[] array = students.stream().filter(a -> a.getHeight() > 170).toArray();
Student[] array = students.stream().filter(a -> a.getHeight() > 170).toArray(len -> students.toArray(new Student[len]));
System.out.println(Arrays.toString(array));
}
}总结
到此这篇关于Java中算法、正则表达式、异常、集合框架举例详解的文章就介绍到这了,更多相关Java算法、正则表达式、异常、集合内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！
相关文章
深度剖析Java成员变量、局部变量和静态变量的创建和回收时机
这篇文章主要介绍了深度剖析Java成员变量、局部变量和静态变量的创建和回收时机,成员变量是定义在类中的变量，每个类的实例都会拥有自己的成员变量。它们的生命周期与对象的创建和销毁相对应,下面我将详细介绍它们的特点和生命周期,需要的朋友可以参考下2023-07-07
这篇文章主要介绍了SpringBoot中的自定义线程池解析,实现自定义线程池重写spring默认线程池的方式使用的时候,只需要加@Async注解就可以,不用去声明线程池类,需要的朋友可以参考下2023-11-11
虚拟线程是Java19中作为预览功能提出,21中正式完成的轻量级线程,旨在减少编写易于观察的高吞吐量的并发程序的工作量,这篇文章主要介绍了Java21之虚拟线程用法的相关资料,需要的朋友可以参考下2026-01-01
这篇文章主要介绍了Spring boot2.0 实现日志集成的方法,基于上一篇将日志信息根据类别输出到不同的文件中，这篇文章将通过日志来监控用户的操作行为、请求的耗时情况，针对耗时久的请求进行性能分析，提升系统性能，需要的小伙伴可以参考一下2022-04-04
这篇文章主要介绍了SpringMVC如何访问WEB-INF jsp过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-09-09
这篇文章主要介绍了Java Web制作登录验证码实现代码解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-09-09
本文主要介绍了MyBatis中的ResultSetHandler及其核心功能和实现,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧2025-09-09
这篇文章主要介绍了java 数据结构之删除链表中的元素实例代码的相关资料,需要的朋友可以参考下2017-01-01
这篇文章主要介绍了如何把VS Code打造成Java开发IDE,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-10-10
这篇文章主要介绍了Java难点解读之异或运算的相关资料,Java中的异或运算是一种位运算符,用于对两个整数的每一位进行比较并执行异或操作,文中通过代码介绍的非常详细,需要的朋友可以参考下2025-04-04
最新评论