Java集合与字符串操作：高效移除元素与字符的策略

static void printFolgenOhne3(int anz) {
    List<Integer> item = new ArrayList<>();
    List<Integer> remove;
    item.add(anz); // 错误：只添加了参数anz，而不是生成序列

    remove = item.stream()
            .filter(i -> anz % 3 == 0) // 错误：过滤条件使用了外部变量anz，而不是流中的元素i
            .collect(Collectors.toList());
    item.removeAll(remove);
    item.forEach(System.out::println);
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class CollectionRemovalExample {

    public static void main(String[] args) {
        // 示例数据：一个包含数字的列表
        List<Integer> numbers = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15));
        System.out.println("原始列表: " + numbers);

        // 使用 removeIf 移除所有3的倍数
        numbers.removeIf(element -> element % 3 == 0);
        System.out.println("移除3的倍数后的列表: " + numbers); // 输出: [1, 2, 4, 5, 7, 8, 10, 11, 13, 14]
    }
}

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SequenceGenerationExample {

    /**
     * 生成一个从指定起始值开始，不包含3的倍数的数字序列。
     *
     * @param start 起始值
     * @param count 要生成的序列长度
     * @return 包含所需数字的列表
     */
    public static List<Integer> generateSequenceWithoutMultiplesOfThree(int start, int count) {
        return IntStream.iterate(start, n -> n + 1) // 从start开始，每次加1
                        .filter(n -> n % 3 != 0)     // 过滤掉3的倍数
                        .limit(count)                // 限制序列长度
                        .boxed()                     // 将IntStream转换为Stream<Integer>
                        .collect(Collectors.toList()); // 收集到List中
    }

    public static void main(String[] args) {
        // 生成从4开始，长度为10的序列，不包含3的倍数
        List<Integer> sequence = generateSequenceWithoutMultiplesOfThree(4, 10);
        System.out.println("生成的序列: " + sequence); // 预期输出: [4, 5, 7, 8, 10, 11, 13, 14, 16, 17]
    }
}

static void deleteBlanks(String s1) {
    List<String> elements = new ArrayList<>();
    elements.add(s1); // 列表只包含一个字符串
    List<String> deleted = elements
            .stream()
            .filter(x -> !x.isBlank()) // 错误：isBlank()检查整个字符串是否为空白，而不是字符
            .collect(Collectors.toList());
    System.out.println(deleted); // 打印的仍然是包含原始字符串的列表
}

public class StringManipulationExample {

    /**
     * 移除字符串中的所有空格。
     *
     * @param s 原始字符串
     * @return 移除空格后的字符串
     */
    public static String removeAllSpaces(String s) {
        // 使用 replace() 方法替换所有空格字符
        return s.replace(" ", "");
    }

    /**
     * 移除字符串中的所有空白字符（包括空格、制表符、换行符等）。
     *
     * @param s 原始字符串
     * @return 移除空白字符后的字符串
     */
    public static String removeAllWhitespace(String s) {
        // 使用 replaceAll() 方法结合正则表达式 s 匹配所有空白字符
        return s.replaceAll("\s", "");
    }

    public static void main(String[] args) {
        String originalString = "Hello world, how are you?";
        System.out.println("原始字符串: " + originalString);

        String noSpaces = removeAllSpaces(originalString);
        System.out.println("移除空格后的字符串: " + noSpaces); // 输出: Helloworld,howareyou?

        String anotherString = "  Java	Streams
Are	Powerful!  ";
        System.out.println("另一个字符串: " + anotherString);

        String noWhitespace = removeAllWhitespace(anotherString);
        System.out.println("移除所有空白字符后的字符串: " + noWhitespace); // 输出: JavaStreamsArePowerful!
    }
}