Java综合基本语法实践：习题一解析，助你成为Java高手

集合的灵活运用

集合是 Java 中一种强大的数据结构，用于存储和操作元素组。它们在各种应用程序中都有广泛的应用，从管理数据到优化搜索算法。让我们通过一些实际示例来探索集合的灵活性。

从字符串中提取数字

假设您有一个包含数字和非数字字符的字符串。您可以使用集合轻松地从该字符串中提取所有数字。首先，使用 split() 方法将字符串拆分为单个字符。然后，使用 Integer.parseInt() 方法将每个字符转换为整数，并将其添加到集合中。

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

public class ExtractNumbers {

    public static List<Integer> extractNumbers(String str) {
        List<Integer> numbers = new ArrayList<>();
        String[] parts = str.split("");
        for (String part : parts) {
            try {
                int number = Integer.parseInt(part);
                numbers.add(number);
            } catch (NumberFormatException e) {
                // ignore non-numeric characters
            }
        }
        return numbers;
    }

    public static void main(String[] args) {
        String str = "123abc456def789";
        List<Integer> numbers = extractNumbers(str);
        System.out.println(numbers); // [1, 2, 3, 4, 5, 6, 7, 8, 9]
    }
}

从集合中删除偶数元素

现在，假设您有一个包含偶数和奇数的集合。您可以使用集合的 Iterator 接口轻松地删除所有偶数元素。

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class RemoveEvenNumbers {

    public static void removeEvenNumbers(List<Integer> numbers) {
        Iterator<Integer> it = numbers.iterator();
        while (it.hasNext()) {
            int number = it.next();
            if (number % 2 == 0) {
                it.remove();
            }
        }
    }

    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);
        numbers.add(6);
        numbers.add(7);
        numbers.add(8);
        numbers.add(9);

        removeEvenNumbers(numbers);

        System.out.println(numbers); // [1, 3, 5, 7, 9]
    }
}

基础编程能力

扎实的基础编程能力对于编写高效、可维护的代码至关重要。让我们通过一个例子来测试您的基本语法和控制流知识。

计算最小公倍数和最大公约数

最小公倍数 (LCM) 和最大公约数 (GCD) 是两个密切相关的数字，它们在许多数学问题中都有应用。您可以使用以下算法计算这两个值：

import java.util.Scanner;

public class LCMAndGCD {

    public static int lcm(int a, int b) {
        return a * b / gcd(a, b);
    }

    public static int gcd(int a, int b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("Enter two numbers: ");
        int a = scanner.nextInt();
        int b = scanner.nextInt();

        int lcm = lcm(a, b);
        int gcd = gcd(a, b);

        System.out.println("LCM: " + lcm);
        System.out.println("GCD: " + gcd);
    }
}

手写 ArrayList 集合

ArrayList 是一种动态数组，它可以自动扩容和缩容。实现自己的 ArrayList 集合可以帮助您更深入地了解集合的内部工作原理。

import java.util.Arrays;

public class MyArrayList<E> {

    private E[] data;
    private int size;

    public MyArrayList() {
        this(10);
    }

    public MyArrayList(int initialCapacity) {
        data = (E[]) new Object[initialCapacity];
        size = 0;
    }

    public void add(E element) {
        if (size == data.length) {
            data = Arrays.copyOf(data, data.length * 2);
        }
        data[size++] = element;
    }

    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        E element = data[index];
        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }
        size--;
        return element;
    }

    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IndexOutOfBoundsException();
        }
        return data[index];
    }

    public int size() {
        return size;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder("[");
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i < size - 1) {
                builder.append(", ");
            }
        }
        builder.append("]");
        return builder.toString();
    }

    public static void main(String[] args) {
        MyArrayList<Integer> list = new MyArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        System.out.println(list); // [1, 2, 3, 4, 5]

        list.remove(2);

        System.out.println(list); // [1, 2, 4, 5]

        System.out.println(list.get(3)); // 5

        System.out.println(list.size()); // 4
    }
}

二分查找的应用

二分查找是一种高效的搜索算法，用于在有序数组中查找元素。它通过不断缩小搜索范围来快速定位目标元素。

public class BinarySearch {

    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;

        while (left <= right) {
            int mid = (left + right) / 2;

            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }

        return -1;
    }

    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int target = 5;

        int index = binarySearch(arr, target);

        if (index == -1) {
            System.out.println("Target not found");
        } else {
            System.out.println("Target found at index " + index);
        }
    }
}

手写单链表

单链表是一种线性的数据结构，其中每个元素都包含一个数据值和指向下一个元素的指针。自己实现一个单链表可以帮助您理解其底层机制。

public class Node<E> {

    private E data;
    private Node<E> next;

    public Node(E data) {
        this.data = data;
        this.next = null;
    }

    public E getData() {
        return data;
    }

    public void setData(E data) {
        this.data = data;
    }

    public Node<E> getNext() {
        return next;
    }

    public void setNext(Node<E> next) {
        this.next = next;
    }
}

public class LinkedList<E> {

    private Node<E> head;
    private Node<E> tail;
    private int size;

    public LinkedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    public void add(E