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(<font>"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; <font>// Generate prime numbers up to n<i>
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(<font>"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(<font>"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(<font>"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; <font>// Number of Fibonacci numbers to generate<i>
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());
<font>// Add remaining elements from longer list<i>
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);
}
}
|
該程式首先組合兩個列表中相應索引處的元素，然後將較長列表中的任何剩餘元素新增到組合列表的末尾。