💥 该系列属于【Java基础编程500题】专栏，如您需查看Java基础的其他相关题目，请您点击左边的连接
目录
14. 从员工（姓名、年龄）列表中找出年龄大于30岁的员工姓名列表
16. 对字符串列表按单词长度进行分组，并打印出每个长度组的单词列表
17. 将整数列表中的数字分为奇数和偶数，分别存储在不同的列表中
21. 给定两个字符串列表，合并这两个列表，并去除重复项，然后按字母顺序排序
22. 将字符串列表转换为Map，其中键是字符串，值是字符串长度
✨✨ 返回题目目录 ✨ ✨
1. 计算整数列表的总和
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = Arrays.asList("1", "2", "3");
//方法一
int IntAns = list.stream()
.mapToInt(Integer::valueOf) //IntStream类型
.sum();
//方法二
Integer IntegerAns = list.stream()
.map(Integer::parseInt) //Stream<Integer>类型
.reduce(0, Integer::sum); //对Stream<Integer>和IntStream类型都可以进行规约
System.out.println("总和为：" + IntAns); //总和为：6
System.out.println("总和为：" + IntegerAns); //总和为：6
}
}
2. 找出整数列表中的最大值
import java.util.Arrays;
import java.util.List;
import java.util.OptionalInt;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4);
// 方法一
OptionalInt max1 = list.stream()
.mapToInt(Integer::valueOf)
.max();
max1.ifPresent(System.out::println); //4
// 方法二
int max2 = list.stream()
.reduce(Integer.MIN_VALUE, (a, b) -> a >= b ? a : b);
// .reduce(Integer.MIN_VALUE, Integer::max); //初始值是第一个元素或最小值
System.out.println(max2); //4
}
}
3. 计算整数列表中所有偶数的平均值
import java.util.Arrays;
import java.util.List;
import java.util.OptionalDouble;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4);
//OptionalDouble是一个可能包含double数值容器，数值也有可能不存在
OptionalDouble average = list.stream()
.filter(n -> n % 2 == 0)
.mapToInt(Integer::valueOf)//转换成IntStream类型
.average();
//ifPresent()：这是OptionalDouble类中的一个方法，用于检查这个Optional对象中是否包含值。如果Optional对象包含值，那么ifPresent()方法会执行传递给它的lambda表达式。
average.ifPresent(value -> System.out.println(value)); //3.0
}
}
4. 筛选出一个整数列表中的偶数并打印
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> list = Arrays.asList("1", "2", "5", "3", "6");
list.stream()
.mapToInt(Integer::valueOf)//转换成int类型，也可以parseInt
.filter(x -> x % 2 == 0)
.forEach(System.out::println);
}
}5. 将字符串列表中的每个元素转换为大写并收集到新的列表
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
// 初始化列表
List<String> list = Arrays.asList("aaa", "bbb", "cc", "D");
// 将列表中的字符串转换为大写，并收集结果到新的列表中
List<String> collect = list.stream()
.map(String::toUpperCase) // 映射操作，将每个字符串转换为大写
.collect(Collectors.toList()); // 收集操作，将结果收集到列表中
// 打印转换后的列表
System.out.println(collect); //[AAA, BBB, CC, D]
}
}
6. 对整数列表进行降序排序，并获取前3个元素
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
List<Integer> collect = list.stream()
.sorted((a, b) -> b - a)
.limit(3)
.collect(Collectors.toList());
System.out.println(collect);//[8, 6, 5]
}
}
7. 将整数列表中的每个数字乘以2，并收集到一个新的列表中
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 4);
List<Integer> collect = list.stream()
.map(s -> s * 2)
.collect(Collectors.toList());
collect.forEach(s -> System.out.print(s + " ")); //2 4 6 8
}
}
8. 检查整数列表中是否所有数字都是正数
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
boolean b = list.stream()
.allMatch(Main::IsPositive); //对list里面的所有数进行判断
//.allMatch(n -> n > 0); //也可以直接该写法
System.out.println(b); //true
}
public static boolean IsPositive(int n) {
return n > 0;
}
}
9. 找出整数列表中大于5的最小值
import java.util.Arrays;
import java.util.List;
import java.util.OptionalInt;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
OptionalInt min = list.stream()
.mapToInt(Integer::valueOf)
.filter(n -> n > 5)
.findFirst();
min.ifPresent(System.out::println); //6
}
}
10. 检查整数列表中是否存在至少一个数字大于10
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
boolean b = list.stream().anyMatch(n -> n > 5);//判断列表中是否有一个存在>5的数字
System.out.println(b);
}
}
11. 检查整数列表中是否包含连续的数字
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 3, 5, 6, 7);
boolean hasConsecutiveNumbers = list.stream()
.anyMatch(n -> list.contains(n + 1));
System.out.println("列表中是否包含连续的数字：" + hasConsecutiveNumbers);//列表中是否包含连续的数字：true
}
}
12. 将整数列表中的数字进行去重
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9);
List<Integer> collect = list.stream()
.distinct()
.collect(Collectors.toList());
System.out.println(collect);//[3, 1, 4, 5, 9]
}
}
13. 从字符串列表中找出最长的字符串
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
public class Main {
public static void main(String[] args) {
List<String> strings = Arrays.asList("hello", "world2222", "stream22", "api", "java");
// 方法一
Optional<String> longestString = strings.stream().max((s1, s2) -> s1.length() - s2.length());
longestString.ifPresent(System.out::println); //world2222
// 方法二
Optional<String> reduce = strings.stream().reduce((a, b) -> a.length() > b.length() ? a : b);
System.out.println(reduce.orElse(null));//world2222
}
}
14. 从员工（姓名、年龄）列表中找出年龄大于30岁的员工姓名列表
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
class Employee {
private String name;
private int age;
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
public class Main {
public static void main(String[] args) {
List<Employee> employees = Arrays.asList(
new Employee("Alice", 32),
new Employee("Bob", 29),
new Employee("Charlie", 34)
);
String collect = employees.stream()
.filter(e -> e.getAge() > 30)
.map(e -> e.getName())//对每个员工取出姓名,或直接Employee::getName
.collect(Collectors.joining(", "));
System.out.println(collect); //Alice, Charlie
}
}
15. 计算列表中每个元素出现的次数
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> integerNumbers = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
Map<Integer, Long> collect = integerNumbers
.stream()
.collect(Collectors.groupingBy(e -> e, Collectors.counting()));
//groupingBy类似与SQL中的GROUP BY
//<e, Collectors.counting())>中,e值key,而Collectors.counting()是对每个key聚合后的值
System.out.println(collect); // {1=1, 2=1, 3=2, 4=1, 5=1, 6=1, 8=1}
}
}16. 对字符串列表按单词长度进行分组，并打印出每个长度组的单词列表
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "fig", "grape");
Map<Integer, List<String>> wordsByLength = words.stream()
.collect(Collectors.groupingBy(String::length));
//groupingBy只有一个参数时，key就是String::length，而value就是元素本身
//wordsByLength: {3=[fig], 4=[date], 5=[apple, grape], 6=[banana, cherry]}
wordsByLength.forEach((length, wordList) -> System.out.println("Length: " + length + ", Words: " + wordList));
}
}
17. 将整数列表中的数字分为奇数和偶数，分别存储在不同的列表中
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> list = Arrays.asList(1, 2, 4, 3, 6, 3, 8, 5);
Map<Boolean, List<Integer>> partitionedMap = list.stream()
.collect(Collectors.partitioningBy(n -> n % 2 == 0));
//partitioningBy是二元分组，groupingBy是多元分组
System.out.println("偶数列表：" + partitionedMap.get(true)); //偶数列表：[2, 4, 6, 8]
System.out.println("奇数列表：" + partitionedMap.get(false)); //奇数列表：[1, 3, 3, 5]
}
}
18. 将一个字符串列表中的每个字符串长度求和
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> strings = Arrays.asList("apple", "banana", "cherry");
// 方法一
int totalLength1 = strings.stream()
.collect(Collectors.summingInt(String::length));
System.out.println(totalLength1); // 输出：17
// 方法二
int totalLength2 = strings.stream()
.mapToInt(String::length).sum();
System.out.println(totalLength2); // 输出：17
// 方法三
int totalLength3 = strings.stream()
.reduce("",String::concat)
.length();
System.out.println(totalLength3); // 输出：17
}
}
19. 对员工列表按年龄分组，并打印每个年龄组的人数
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
class Employee {
String name;
int age;
Employee(String name, int age) {
this.name = name;
this.age = age;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return name + ": " + age;
}
}
public class Main {
public static void main(String[] args) {
List<Employee> people = Arrays.asList(
new Employee("Alice", 22),
new Employee("Bob", 20),
new Employee("Charlie", 21),
new Employee("David", 20)
);
//按照age进行分组，对每个分组求和
Map<Integer, Long> peopleByAge = people.stream()
.collect(Collectors.groupingBy(Employee::getAge, Collectors.counting()));
peopleByAge.forEach((age, count) -> System.out.println("Age: " + age + ", Count: " + count));
//按照age进行分组
Map<Integer, List<Employee>> collect = people.stream()
.collect(Collectors.groupingBy(person -> person.getAge()));
System.out.println(collect);
}
}
20. 计算字符串中每个字符出现的次数
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String str = "hello world";
Map<Character, Long> charCountMap = str.chars() // IntStream
.mapToObj(c -> (char) c) // Stream<Character>
.collect(Collectors.groupingBy(c -> c, Collectors.counting()));
System.out.println(charCountMap); //{ =1, r=1, d=1, e=1, w=1, h=1, l=3, o=2}
}
}
21. 给定两个字符串列表，合并这两个列表，并去除重复项，然后按字母顺序排序
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
List<String> list1 = Arrays.asList("a", "b", "c");
List<String> list2 = Arrays.asList("b", "c", "d");
List<String> mergedList = Stream.concat(list1.stream(), list2.stream())
.distinct()
.sorted()
.collect(Collectors.toList());
System.out.println(mergedList);//[a, b, c, d]
}
}
22. 将字符串列表转换为Map，其中键是字符串，值是字符串长度
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> strings = Arrays.asList("apple", "banana", "cherry");
Map<String, Integer> stringLengthMap = strings.stream()
.collect(Collectors.toMap(s -> s, String::length));
stringLengthMap.forEach((s, length) -> System.out.println(s + ": " + length));
// banana: 6
// apple: 5
// cherry: 6
}
}
23. 将字符串中的每个单词首字母转换为大写。
import java.util.Arrays;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String str = "this is a test";
// 方法一
String collect = Arrays.stream(str.split(" "))
.map(s -> Character.toUpperCase(s.charAt(0)) + s.substring(1))
.collect(Collectors.joining(" "));
System.out.println(collect); //This Is A Test
// 方法二
String[] strArr = str.split(" ");
StringBuilder sb = new StringBuilder();
for (var i : strArr) {
sb.append(Character.toUpperCase(i.charAt(0)))
.append(i.substring(1))
.append(" ");
}
System.out.println(sb.toString()); //This Is A Test
}
}24. 删除字符串中所有的指定字符。
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String str = "this is a test";
char delChar = 's';
// 方法一
char[] charArray = str.toCharArray();
StringBuilder sb = new StringBuilder();
for(char c : charArray){
if(c!=delChar){
sb.append(c);
}
}
System.out.println(sb.toString()); // thi i a tet
// 方法二
String collect = str.chars()
.mapToObj(c -> (char) c)
.filter(c -> c != delChar)
.map(String::valueOf)
.collect(Collectors.joining(""));
System.out.println(collect); // thi i a tet
}
}25. 去除字符串中所有重复的字符。
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String str = "this is a test";
String collect = str.chars()
.distinct()
.mapToObj(a -> String.valueOf((char) a))
.collect(Collectors.joining(""));
System.out.println(collect); //this ae
}
}26. 统计字符串中每个字母出现的次数。
import java.util.Map;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String test = "abbacccc";
Map<String, Long> collect = test.chars()
.mapToObj(s -> String.valueOf((char) s))
.collect(Collectors.groupingBy(s -> s, Collectors.counting()));
System.out.println(collect);
}
}
1475
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
