1、使用 Java Stream API 编写一个程序，在不对列表排序的情况下查找列表中的第二大元素。
要在不对列表排序的情况下找出列表中的第二大元素，可以使用 Java Stream API。一种方法是使用 reduce 方法，在遍历列表时跟踪最大元素和第二大元素。下面的程序演示了这种方法：
import java.util.Arrays;
import java.util.List;
public class SecondLargestElement {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(10, 5, 20, 8, 15);
Integer secondLargest = numbers.stream()
.reduce(Integer.MIN_VALUE, (first, second) -> {
if (second > first) {
return second;
} else {
return first;
}
});
System.out.println("Second largest element is: " + secondLargest);
}
}
|
在这个程序中，我们从 Integer.MIN_VALUE 的初始值开始，以确保初始最大值小于列表中的任何元素。然后，我们遍历列表中的每个元素，并将其与当前最大值进行比较。如果该元素较大，我们就将最大值更新为该元素。迭代结束后，secondLargest 变量将包含列表中第二大的元素。
2、编写一个程序，使用 Java Stream API 从列表中删除连续重复的元素。
您可以使用 Java Stream API 从列表中删除连续重复的元素。下面是一个简单的演示程序：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class PrimeNumberGenerator {
public static void main(String[] args) {
int n = 50; // Generate prime numbers up to n
List<Integer> primeNumbers = generatePrimeNumbers(n);
System.out.println("Prime numbers up to " + n + ": " + primeNumbers);
}
public static List<Integer> generatePrimeNumbers(int n) {
return IntStream.rangeClosed(2, n)
.filter(PrimeNumberGenerator::isPrime)
.boxed()
.collect(Collectors.toList());
}
public static boolean isPrime(int number) {
if (number <= 1) {
return false;
}
for (int i = 2; i <= Math.sqrt(number); i++) {
if (number % i == 0) {
return false;
}
}
return true;
}
}
|
本程序使用 generatePrimeNumbers 方法生成不超过给定极限 n 的质数，并使用 isPrime 方法检查数字是否是质数。isPrime 方法使用基本的质数检查算法，从 2 到数字的平方根迭代检查因数。3、编写一个程序，使用 Java Stream API 查找范围中的缺失数字
您可以使用 Java Stream API 从范围中查找缺失的数字。下面的程序演示了这一点：
import java.util.Arrays;
import java.util.stream.IntStream;
public class MissingNumbersFinder {
public static void main(String[] args) {
int[] numbers = {1, 2, 4, 6, 9};
int start = 1;
int end = 10;
System.out.println("Missing numbers between " + start + " and " + end + ":");
findMissingNumbers(numbers, start, end)
.forEach(System.out::println);
}
public static IntStream findMissingNumbers(int[] numbers, int start, int end) {
int[] allNumbers = IntStream.rangeClosed(start, end).toArray();
return Arrays.stream(allNumbers)
.filter(num -> Arrays.binarySearch(numbers, num) < 0);
}
}
|
该程序首先定义了一个数字数组和一个范围（开始和结束）。然后，使用 IntStream.rangeClosed(start, end).toArray() 创建一个数组，其中包含指定范围内的所有数字。最后，程序使用流 API 过滤出数组中的数字，并打印出缺少的数字。
4、使用 Java Stream API 编写一个程序来从列表中过滤回文字符串
下面是一个使用 Stream API 从列表中过滤回文字符串的 Java 程序：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<String> words = Arrays.asList("level", "hello", "radar", "world", "civic");
List<String> palindromes = words.stream()
.filter(word -> isPalindrome(word))
.collect(Collectors.toList());
System.out.println("Palindromic words: " + palindromes);
}
private static boolean isPalindrome(String word) {
int length = word.length();
for (int i = 0; i < length / 2; i++) {
if (word.charAt(i) != word.charAt(length - 1 - i)) {
return false;
}
}
return true;
}
}
|
该程序定义了一个 isPalindrome 方法来检查给定的单词是否是回文。然后，它使用 Stream API 从输入列表单词中过滤回文单词，并将它们收集到一个新的回文列表中，然后将其打印到控制台。
5、编写一个程序，使用 Java Stream API 从字符串列表中查找最长的字符串
您可以使用 Java Stream API 从字符串列表中找到最长的字符串，如下所示：
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> strings = Arrays.asList("Java", "Python", "JavaScript", "C++", "Ruby");
String longest = strings.stream()
.max((s1, s2) -> s1.length() - s2.length())
.orElse(null);
System.out.println("Longest string: " + longest);
}
}
|
在此示例中，我们使用stream()方法从字符串列表创建流。然后，我们使用 max 方法和比较器根据字符串的长度找到最长的字符串。最后，我们使用 orElse 来处理流为空（即列表为空）的情况，并在这种情况下返回 null。
6、使用 Java Stream API 编写程序来生成斐波那契数列
您可以使用 Java Stream API 生成斐波那契数列。这是一个执行此操作的程序：
import java.util.stream.Stream;
public class FibonacciSeries {
public static void main(String[] args) {
int n = 10; // Number of Fibonacci numbers to generate
System.out.println("Generating Fibonacci series up to " + n + " numbers:");
Stream.iterate(new long[]{0, 1}, f -> new long[]{f[1], f[0] + f[1]})
.limit(n)
.map(f -> f[0])
.forEach(System.out::println);
}
}
|
该程序使用 Stream.iterate 生成从 {0, 1} 开始的无限斐波那契数流。然后使用 limit(n) 方法将流限制为前 n 个元素。最后，map方法用于提取每对的第一个元素（f[0]），forEach用于打印每个斐波那契数。
7、编写一个程序将两个列表组合成一个列表，并使用 Java Stream API 交替每个列表中的元素。
您可以通过使用 IntStream.range 方法以及 Java Stream API 中的 flatMap 操作来实现此目的。下面的程序将两个列表组合成一个列表，并交替显示每个列表中的元素：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 2, 3, 4);
List<Integer> list2 = Arrays.asList(5, 6, 7, 8);
List<Integer> combinedList = IntStream.range(0, Math.min(list1.size(), list2.size()))
.flatMap(i -> IntStream.of(list1.get(i), list2.get(i)))
.boxed()
.collect(Collectors.toList());
// Add remaining elements from longer list
if (list1.size() > list2.size()) {
combinedList.addAll(list1.subList(list2.size(), list1.size()));
} else if (list2.size() > list1.size()) {
combinedList.addAll(list2.subList(list1.size(), list2.size()));
}
System.out.println("Combined List: " + combinedList);
}
}
|
该程序首先组合两个列表中相应索引处的元素，然后将较长列表中的任何剩余元素添加到组合列表的末尾。