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); } }
|
该程序首先组合两个列表中相应索引处的元素,然后将较长列表中的任何剩余元素添加到组合列表的末尾。