使用 Java Stream API 編寫一個程式來計算列表中元素的累積和
您可以使用 Java Stream API 來計算列表中元素的累積和。這是一個簡單的程式來演示這一點：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> cumulativeSum = numbers.stream()
.mapToInt(Integer::intValue)
.boxed()
.collect(Collectors.toList());
for (int i = 1; i < cumulativeSum.size(); i++) {
cumulativeSum.set(i, cumulativeSum.get(i) + cumulativeSum.get(i - 1));
}
System.out.println("Original List: " + numbers);
System.out.println("Cumulative Sum: " + cumulativeSum);
}
}
該程式首先將 List<Integer> 轉換為 IntStream，然後將其裝箱回 Integer 物件。然後它將元素收集到一個列表中。最後，它迭代列表以計算累積和。
使用 Java Stream API 編寫一個程式來查詢列表中第 K 個最小的元素
您可以使用 Java Stream API 透過對列表進行排序然後選擇第 K 個元素來查詢列表中的第 K 個最小元素。這是一個演示這一點的程式：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class KthSmallestElement {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(10, 2, 6, 8, 4, 12, 7);
int k = 3; <font>// Find the 3rd smallest element<i>
int kthSmallest = findKthSmallest(numbers, k);
System.out.println("The " + k + "th smallest element is: " + kthSmallest);
}
public static int findKthSmallest(List<Integer> numbers, int k) {
List<Integer> sortedList = numbers.stream()
.sorted()
.collect(Collectors.toList());
return sortedList.get(k - 1);
}
}
|
在此程式中，我們首先建立一個整數列表。然後，我們使用stream()方法將列表轉換為流。我們使用sorted()方法對流進行排序，並將排序後的流收集回列表中。最後，我們使用 get(k - 1) 從排序列表中返回第 K 個最小元素，因為索引是從零開始的。
使用 Java Stream API 編寫一個程式將多個Map合併為一個Map
您可以使用 Java Stream API 將多個Map對映合併為一個對映。下面是一個簡單的例子來演示這一點：
import java.util.*;
import java.util.stream.Collectors;
public class CombineMapsExample {
public static void main(String[] args) {
<font>// Creating multiple maps<i>
Map<String, Integer> map1 = new HashMap<>();
map1.put("A", 1);
map1.put("B", 2);
Map<String, Integer> map2 = new HashMap<>();
map2.put("C", 3);
map2.put("D", 4);
Map<String, Integer> map3 = new HashMap<>();
map3.put("E", 5);
map3.put("F", 6);
// Combining maps using Java Stream API<i>
Map<String, Integer> combinedMap = Stream.of(map1, map2, map3)
.flatMap(map -> map.entrySet().stream())
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
// Printing the combined map<i>
System.out.println(combinedMap);
}
}
|
該程式建立三個對映（map1、map2 和 map3），然後使用 Stream API 的 flatMap 操作和 Collectors.toMap 方法將它們組合成一個對映 (combinedMap)。
使用 Java Stream API 編寫程式以將列表中的空值替換為預設值
您可以使用 Java Stream API 將列表中的空值替換為預設值。這是一個演示這一點的示例程式：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class ReplaceNullValues {
public static void main(String[] args) {
List<String> list = Arrays.asList(<font>"a", null, "b", null, "c", null);
List<String> replacedList = list.stream()
.map(value -> value != null ? value : "default")
.collect(Collectors.toList());
System.out.println("Original list: " + list);
System.out.println("List with nulls replaced: " + replacedList);
}
}
|
該程式建立一個包含一些空值的列表，然後使用對映函式將每個空值替換為“default”。最後，它將元素收集到一個新列表中。輸出將是：
Original list: [a, null, b, null, c, null]
List with nulls replaced: [a, default, b, default, c, default]
使用 Java Stream API 編寫一個程式來查詢數字列表的中位數
下面是一個使用 Java Stream API 查詢數字列表中位數的程式：
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class MedianCalculator {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(20);
numbers.add(30);
numbers.add(40);
numbers.add(50);
double median = findMedian(numbers);
System.out.println(<font>"Median: " + median);
}
public static double findMedian(List<Integer> numbers) {
Collections.sort(numbers);
int size = numbers.size();
if (size % 2 == 0) {
int mid1 = numbers.get(size / 2 - 1);
int mid2 = numbers.get(size / 2);
return (double) (mid1 + mid2) / 2;
} else {
return numbers.get(size / 2);
}
}
}
|
該程式首先使用 Collections.sort() 對數字列表進行排序。然後，它根據列表大小是偶數還是奇數來計算中位數。如果大小是偶數，則計算中間兩個元素的平均值。如果大小為奇數，則直接返回中間元素。
使用 Java Stream API 編寫一個轉置矩陣的程式
您可以使用 Java Stream API 轉置矩陣，方法是將矩陣轉換為行流，然後轉置它，最後將轉置後的矩陣收集回二維陣列。您可以這樣做：
import java.util.Arrays;
public class MatrixTranspose {
public static void main(String[] args) {
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
int[][] transposedMatrix = transpose(matrix);
<font>// Print the transposed matrix<i>
for (int[] row : transposedMatrix) {
System.out.println(Arrays.toString(row));
}
}
public static int[][] transpose(int[][] matrix) {
return Arrays.stream(matrix)
.reduce((a, b) -> IntStream.range(0, Math.max(a.length, b.length))
.mapToObj(i -> i < a.length ? a[i] : new int[a.length])
.mapToInt(row -> row.length > 0 ? row[0] : 0)
.zipWith(IntStream.range(0, Math.max(a.length, b.length))
.mapToObj(i -> i < b.length ? b[i] : new int[b.length])
.mapToInt(row -> row.length > 0 ? row[0] : 0), (x, y) -> {
int[] result = new int[]{x, y};
return result;
}))
.orElse(new int[0][]);
}
}
|
該程式將轉置給定的矩陣並列印轉置後的矩陣。請注意，此方法假設矩陣是矩形（所有行具有相同的長度）。如果您的矩陣不是矩形，您可能需要修改轉置方法來處理這種情況。
使用 Java Stream API 編寫程式來生成列表的排列
您可以使用 Java Stream API 生成列表的排列，方法是首先建立遞迴方法來生成排列，然後使用 Stream API 生成所有可能的排列。這是一個例子：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Permutations {
public static void main(String[] args) {
List<Integer> list = List.of(1, 2, 3);
List<List<Integer>> permutations = generatePermutations(list);
permutations.forEach(System.out::println);
}
public static <T> List<List<T>> generatePermutations(List<T> list) {
if (list.isEmpty()) {
return List.of(List.of());
}
return list.stream()
.flatMap(element ->
generatePermutations(list.stream().filter(e -> !e.equals(element)).collect(Collectors.toList()))
.stream()
.map(permutation -> {
List<T> perm = new ArrayList<>(permutation);
perm.add(element);
return perm;
})
)
.collect(Collectors.toList());
}
}
|
該程式生成並列印列表 [1, 2, 3] 的所有排列。您可以將 List.of(1, 2, 3) 替換為您想要為其生成排列的任何其他列表。
使用 Java Stream API 編寫程式以查詢一系列字元中缺失的字元
您可以使用 Java Stream API 從一系列字元中查詢丟失的字元。這是一個演示這一點的示例程式：
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class MissingCharactersFinder {
public static void main(String[] args) {
String input = <font>"abcdefghijklmnopqrstuvwxyz";
String range = "hijklmnopqrstuvwx";
String missingCharacters = findMissingCharacters(input, range);
System.out.println("Missing characters: " + missingCharacters);
}
public static String findMissingCharacters(String input, String range) {
return range.chars()
.filter(c -> input.indexOf(c) == -1)
.mapToObj(c -> String.valueOf((char) c))
.collect(Collectors.joining());
}
}
|
在此程式中，findMissingCharacters 方法採用兩個字串：輸入和範圍。它使用 Stream API 將範圍字串轉換為字元值的 IntStream。然後，它過濾掉輸入字串中不存在的字元，並將丟失的字元收集到一個新字串中。最後，它返回包含缺失字元的字串。
使用 Java Stream API 編寫一個程式來計算列表中每個元素的素因數
您可以使用 Java Stream API 計算列表中每個元素的素因數。這是一個演示這一點的程式：
import java.util.ArrayList;
import java.util.List;
public class PrimeFactorsCalculator {
public static void main(String[] args) {
List<Integer> numbers = List.of(12, 15, 20, 30, 35);
numbers.stream()
.forEach(number -> {
System.out.print(<font>"Prime factors of " + number + ": ");
calculatePrimeFactors(number).forEach(factor -> System.out.print(factor + " "));
System.out.println();
});
}
private static List<Integer> calculatePrimeFactors(int number) {
List<Integer> primeFactors = new ArrayList<>();
int divisor = 2;
while (number > 1) {
while (number % divisor == 0) {
primeFactors.add(divisor);
number /= divisor;
}
divisor++;
}
return primeFactors;
}
}
|
該程式定義了一個方法calculatePrimeFactors，用於計算給定數字的素因數。然後，它使用 Java Stream API 迭代數字列表，為每個數字呼叫calculatePrimeFactors 並列印結果。
使用 Java Stream API 編寫一個程式來查詢多個列表的交集。
您可以使用 Java Stream API 查詢多個列表的交集，方法是將列表轉換為流，然後使用“reduce”方法查詢公共元素。這是一個演示這一點的程式：
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<List<Integer>> lists = new ArrayList<>();
lists.add(Arrays.asList(1, 2, 3, 4, 5));
lists.add(Arrays.asList(2, 3, 4, 5, 6));
lists.add(Arrays.asList(3, 4, 5, 6, 7));
List<Integer> intersection = lists.stream()
.reduce((list1, list2) -> list1.stream()
.filter(list2::contains)
.collect(Collectors.toList()))
.orElse(new ArrayList<>());
System.out.println(<font>"Intersection: " + intersection);
}
}
|
該程式建立三個整數列表，並使用“reduce”方法找到它們的交集。 “filter”操作用於檢查第一個列表中的每個元素是否包含在第二個列表中，而“collect”方法將公共元素收集到一個新列表中。
編寫一個程式，使用 Java Stream API 將多個流合併為一個流。
您可以使用 Stream.concat 方法將多個流合併為一個流。這是一個演示這一點的示例程式：
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) {
<font>// Create multiple streams<i>
List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(4, 5, 6);
List<Integer> list3 = Arrays.asList(7, 8, 9);
// Combine streams<i>
Stream<Integer> combinedStream = Stream.concat(
Stream.concat(list1.stream(), list2.stream()),
list3.stream()
);
// Collect and print elements from the combined stream<i>
List<Integer> combinedList = combinedStream.collect(Collectors.toList());
System.out.println(combinedList);
}
}
|
在此示例中，我們有三個列表（“list1”、“list2”和“list3”），我們使用“Stream.concat”方法將它們組合成一個流。最後，我們將組合流的元素收集到一個列表中並列印它們。
使用 Java Stream API 編寫一個程式以從列表中刪除第 n 個元素
要使用 Java Stream API 從列表中刪除第 n 個元素，您可以將列表轉換為流，過濾掉第 n 個元素，然後將流收集回列表。這是一個例子：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
public class RemoveNthElement {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);
numbers.add(5);
int n = 2; <font>// Remove the 2nd element (index 1)<i>
List<Integer> updatedList = IntStream.range(0, numbers.size())
.filter(i -> i != n)
.mapToObj(numbers::get)
.collect(Collectors.toList());
System.out.println("Original List: " + numbers);
System.out.println("Updated List: " + updatedList);
}
}
|
在這個例子中，我們有一個整數“numbers”列表。我們想要刪除索引“n”（從零開始的索引）處的元素。 `IntStream.range` 方法用於建立從 0 到 `numbers.size() - 1` 的索引流。然後，我們使用“filter”方法排除索引“n”，並使用“mapToObj”獲取索引對應的元素。最後，我們將流收集回列表以獲取更新後的列表，其中不含第 n 個元素。
使用 Java Stream API 編寫一個程式來查詢兩個列表的交集。
您可以使用 Java Stream API 來查詢兩個列表的交集，方法是將它們轉換為流，然後使用過濾器僅保留公共元素。這是一個實現此目的的簡單程式：
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Integer> list1 = new ArrayList<>();
list1.add(1);
list1.add(2);
list1.add(3);
list1.add(4);
List<Integer> list2 = new ArrayList<>();
list2.add(3);
list2.add(4);
list2.add(5);
list2.add(6);
List<Integer> intersection = findIntersection(list1, list2);
System.out.println(<font>"Intersection: " + intersection);
}
public static <T> List<T> findIntersection(List<T> list1, List<T> list2) {
return list1.stream()
.filter(list2::contains)
.collect(Collectors.toList());
}
}
|
該程式將輸出：
交叉點：[ 3 , 4 ]
此程式碼採用兩個列表 list1 和 list2，並使用 Java Stream API 查詢它們的交集。然後它列印出兩個列表共有的元素。
使用 Java Stream API 編寫一個程式來計算列表中每個元素的階乘
您可以使用 Java Stream API 計算列表中每個元素的階乘。這是一個演示這一點的程式：
import java.math.BigInteger;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class FactorialCalculator {
public static BigInteger factorial(int n) {
if (n == 0 || n == 1) {
return BigInteger.ONE;
}
return BigInteger.valueOf(n).multiply(factorial(n - 1));
}
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<BigInteger> factorials = numbers.stream()
.map(n -> factorial(n))
.collect(Collectors.toList());
System.out.println(<font>"Factorials: " + factorials);
}
}
|
在這個程式中，我們首先定義一個階乘方法來使用遞迴計算給定數字的階乘。然後，我們建立一個整數列表，並使用stream方法將列表轉換為流。我們使用map方法對流中的每個元素應用階乘方法，最後使用collect方法將結果收集到列表中。
使用 Java Stream API 編寫程式以按多個條件對列表中的物件進行分組
您可以使用 Java Stream API 透過連結“Collectors.groupingBy”收集器按多個條件對列表中的物件進行分組。這是一個演示這一點的示例程式：
import java.util.*;
import java.util.stream.Collectors;
class Student {
private String name;
private int age;
private String department;
public Student(String name, int age, String department) {
this.name = name;
this.age = age;
this.department = department;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public String getDepartment() {
return department;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", department='" + department + '\'' +
'}';
}
}
public class Main {
public static void main(String[] args) {
List<Student> students = Arrays.asList(
new Student("Alice", 20, "Math"),
new Student("Bob", 21, "Math"),
new Student("Charlie", 22, "Physics"),
new Student("David", 20, "Physics"),
new Student("Eve", 21, "Physics")
);
Map<String, Map<Integer, List<Student>>> groupedStudents = students.stream()
.collect(Collectors.groupingBy(Student::getDepartment,
Collectors.groupingBy(Student::getAge)));
groupedStudents.forEach((department, ageMap) -> {
System.out.println("Department: " + department);
ageMap.forEach((age, studentList) -> {
System.out.println("\tAge: " + age);
studentList.forEach(System.out::println);
});
});
}
}
在此示例中，“Student學生”物件首先按部門分組，然後按年齡分組。 “groupedStudents”對映包含此分組的結果，其中外部對映的鍵是部門，內部對映的鍵是年齡。內部對映的值是符合院系和年齡標準的學生列表。
使用 Java Stream API 編寫程式以查詢列表中最接近的元素對
要使用 Java Stream API 查詢列表中最接近的元素對，您可以建立一個自定義方法來比較列表中的所有元素對並返回差異最小的對。這是實現此目的的示例程式：
import java.util.*;
import java.util.stream.*;
public class ClosestPair {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 4, 7, 10, 15);
Optional<Pair> closestPair = findClosestPair(numbers);
if (closestPair.isPresent()) {
System.out.println(<font>"Closest pair: " + closestPair.get());
} else {
System.out.println("No pair found");
}
}
public static Optional<Pair> findClosestPair(List<Integer> numbers) {
return IntStream.range(0, numbers.size() - 1)
.flatMap(i -> IntStream.range(i + 1, numbers.size())
.mapToObj(j -> new Pair(numbers.get(i), numbers.get(j))))
.min(Comparator.comparingInt(Pair::getDifference));
}
static class Pair {
private final int first;
private final int second;
public Pair(int first, int second) {
this.first = first;
this.second = second;
}
public int getDifference() {
return Math.abs(first - second);
}
@Override
public String toString() {
return "(" + first + ", " + second + ")";
}
}
}
|
該程式定義了一個“Pair”類來儲存一對整數並計算它們之間的差。 “findClosestPair”方法生成列表中的所有元素對，並使用 Stream API 的“min”方法查詢差異最小的對。
編寫一個程式，使用 Java Stream API 將多個列表合併並排序為單個排序列表
要使用 Java Stream API 將多個列表合併並排序為單個排序列表，您可以遵循以下方法：
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class MergeAndSortLists {
public static void main(String[] args) {
List<Integer> list1 = Arrays.asList(1, 4, 7);
List<Integer> list2 = Arrays.asList(2, 5, 8);
List<Integer> list3 = Arrays.asList(3, 6, 9);
List<Integer> mergedAndSorted = Stream.of(list1, list2, list3)
.flatMap(List::stream)
.sorted()
.collect(Collectors.toList());
System.out.println(<font>"Merged and Sorted List: " + mergedAndSorted);
}
}
|
該程式首先建立三個包含整數值的列表（list1、list2 和 list3）。然後，它使用 flatMap() 將這些列表合併到單個流中，使用 Sorted() 對流進行排序，並使用 Collectors.toList() 將排序後的元素收集到新列表中。最後，它列印合並和排序的列表。
編寫一個程式，將逗號分隔的字串拆分為各個元素，並使用 Java Stream API 過濾掉空字串
您可以使用 Java Stream API 來實現此目的，方法是拆分逗號分隔的字串，然後過濾掉空字串。下面是一個示例程式來演示這一點：
import java.util.Arrays;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
String input = <font>"apple,banana,,orange,,";
String[] elements = input.split(",");
Stream<String> stream = Arrays.stream(elements)
.filter(s -> !s.isEmpty());
stream.forEach(System.out::println);
}
}
|
該程式使用 split(",") 方法將輸入字串“apple,banana,,orange,,”拆分為各個元素，從而生成一個包含 ["apple", "banana", "", "orange" 的陣列元素”，“”]。然後，它使用 Arrays.stream(elements) 從陣列建立一個流，並使用 filter 方法過濾掉空字串。最後，它使用 forEach(System.out::println) 列印每個非空元素。
使用 Java Stream API 編寫一個程式，根據自定義比較器對物件列表進行排序
您可以使用 Java Stream API 和自定義比較器對物件列表進行排序。這是一個例子：
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
@Override
public String toString() {
return <font>"Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Main {
public static void main(String[] args) {
List<Person> persons = Arrays.asList(
new Person("Alice", 30),
new Person("Bob", 25),
new Person("Charlie", 35)
);
Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);
List<Person> sortedPersons = persons.stream()
.sorted(ageComparator)
.collect(Collectors.toList());
sortedPersons.forEach(System.out::println);
}
}
|
在此示例中，我們有一個包含姓名和年齡欄位的 Person 類。我們建立一個 Person 物件列表，然後使用 Stream 類的排序方法以及自定義比較器 (ageComparator) 根據人員的年齡對列表進行排序。最後，我們使用 Collectors.toList() 將排序後的元素收集到一個新列表中，並列印排序後的列表。
使用 Java Stream API 編寫一個程式來從字串列表中過濾字謎。
您可以使用 Java Stream API 從字串列表中過濾字謎，方法是按排序形式對字串進行分組，然後過濾掉僅包含一個元素的組。您可以這樣做：
import java.util.*;
import java.util.stream.Collectors;
public class AnagramFilter {
public static void main(String[] args) {
List<String> words = Arrays.asList(<font>"listen", "pot", "part", "opt", "trap", "silent", "top", "this", "hello", "hits");
Map<String, List<String>> anagramGroups = words.stream()
.collect(Collectors.groupingBy(str -> sortString(str)));
List<String> anagrams = anagramGroups.values().stream()
.filter(group -> group.size() > 1)
.flatMap(Collection::stream)
.collect(Collectors.toList());
System.out.println("Anagrams: " + anagrams);
}
private static String sortString(String str) {
char[] charArray = str.toCharArray();
Arrays.sort(charArray);
return new String(charArray);
}
}
|
在此程式中，sortString方法用於對字串的字元進行排序，該方法將用作groupingBy收集器中的鍵將字謎詞分組在一起。生成的 anagrams 列表將包含輸入列表中彼此互為 anagrams 的所有字串。