JAVA小白初级到中级水平 经典编程练习题目30道!

文章目录

从Java小白晋升到中级水平,开发者通常需要掌握以下核心技术和概念:

  1. Java语法与基础概念

    • 理解面向对象编程(OOP)原则:封装、继承、多态。
    • 掌握Java基本数据类型、变量、运算符、流程控制语句(条件判断、循环、跳转)。
    • 理解类和对象的概念,包括构造方法、成员变量、成员方法以及this关键字的使用。
    • 学习数组、字符串和集合框架(List, Set, Map等)的使用。
  2. 类与对象高级特性

    • 学习抽象类和接口的区别及使用场景。
    • 掌握方法重载和重写、访问权限修饰符(private, protected, public, default)。
    • 理解内部类、匿名内部类、静态内部类的应用。
    • 学习Java内存模型,了解对象生命周期和垃圾回收机制。
  3. 异常处理

    • 学习Java异常体系结构,掌握try-catch-finally块的使用。
    • 理解checked异常和unchecked异常的区别。
  4. I/O操作

    • 学习File I/O操作,包括文件读写、文件路径操作、目录操作等。
    • 理解字节流和字符流的原理及不同之处,掌握BufferedReader、BufferedWriter、FileReader、FileWriter等类的使用。
    • 学习网络编程,了解Socket编程基础。
  5. 多线程编程

    • 掌握线程的创建与销毁、线程状态管理、线程同步机制(如synchronized关键字、wait/notify方法、Lock接口等)。
    • 理解线程池和并发工具类的使用(如ExecutorService、CountDownLatch、Semaphore、CyclicBarrier等)。
  6. 集合框架

    • 深入理解List、Set、Queue、Map等各种集合接口及其常用实现类的特性、操作方法以及它们之间的差异。
    • 掌握迭代器、比较器(Comparator)、流(Stream API)的使用。
  7. 数据库操作

    • 学习SQL基础,能够编写基本的SQL查询语句。
    • 掌握Java JDBC API,能够实现数据库连接、查询、插入、删除、更新等操作。
    • 熟悉至少一种ORM框架(如Hibernate或MyBatis),能够基于框架进行数据库操作。
  8. Web开发基础

    • 理解HTTP协议及请求响应模型。
    • 掌握Servlet API,能够编写Servlet程序。
    • 学习Spring MVC或Spring Boot框架的基本使用,理解控制器、模型、视图的基本概念。
  9. 工具与环境

    • 熟悉Eclipse、IntelliJ IDEA等开发工具的使用。
    • 学会使用Git或SVN进行版本控制。
    • 熟练Linux操作系统的基本命令,能够在Linux环境下部署和运行Java应用。
  10. 设计模式

    • 了解常见设计模式,如工厂模式、单例模式、观察者模式等,并能在实际项目中适当应用。
  11. 测试

    • 学习单元测试框架JUnit,能够编写测试用例进行代码验证。
  12. Java 8及以上版本的新特性

    • Lambda表达式:掌握Java 8引入的函数式编程特性,能够使用lambda表达式替代匿名内部类,简化代码。
    • Stream API:理解并掌握Java 8新增的Stream API,能够进行高效的数据处理、筛选、转换和聚合操作。
    • Optional类:了解Optional类的作用,避免空指针异常,并优雅地处理可能不存在的值。
  13. 模块化系统(Java 9及以上)

    • 学习Java模块化系统(Java Platform Module System, JPMS),了解模块声明、模块间的依赖关系以及模块化的优点。
  14. 并发编程增强

    • 学习CompletableFuture类,实现异步编程和Future模式的改进方案。
    • 理解并掌握Java 8新增的并行流(Parallel Streams)。
  15. NIO.2(Java 7及以上)

    • 掌握非阻塞I/O(Non-blocking I/O, NIO)和通道(Channel)的概念,了解Selector和缓冲区(Buffer)的使用,实现高效的I/O操作。
  16. 反射与注解

    • 学习Java反射API,能够动态地创建对象、访问私有成员以及操作类的信息。
    • 理解注解的定义和使用,如自定义注解以及@Deprecated、@Override等内置注解。
  17. 软件设计原则与设计模式

    • 了解SOLID原则(单一职责原则、开闭原则、里氏替换原则、接口隔离原则、依赖倒置原则)以及其在实际编程中的应用。
    • 对常见的设计模式(如策略模式、装饰器模式、建造者模式、模板方法模式等)有深入理解,并能在项目中恰当运用。
  18. JVM优化与性能调优

    • 了解JVM内存结构,掌握JVM参数调优,如-Xms、-Xmx、-XX:NewRatio等。
    • 学习JVM垃圾回收机制,如新生代与老年代、Minor GC与Full GC、各种垃圾收集器的特点和选择等。
    • 进行性能监控和分析,如使用JConsole、VisualVM等工具查看内存分配、CPU使用率、线程状况等信息。
  19. Maven与Gradle构建工具

    • 掌握Maven或Gradle的基本使用,包括项目结构、依赖管理、构建生命周期、插件使用等。
  20. 持续集成与自动化部署

    • 学习使用Jenkins、GitLab CI/CD或其他CI/CD工具进行持续集成和自动化部署。

总之,Java初级到中级水平的学习是一个全面的过程,不仅限于编程语法本身,还包括了对各种API的理解和应用、设计思想的实践以及相关工具的熟练使用。在实践中不断积累经验,结合具体项目加深对理论知识的理解是至关重要的。

以下是一些初级到中级水平的Java编程经典练习题目,并简要解释思路:

1. 练习1:编写程序输出“Hello, World!”

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

2. 练习2:定义一个整型变量,赋值为100,然后加1并输出

public class Main {
    public static void main(String[] args) {
        int number = 100;
        number++;
        System.out.println(number);
    }
}

3. 练习3:声明一个数组,存储5个整数,然后遍历并打印数组的所有元素

public class ArrayPractice {
    public static void main(String[] args) {
        int[] numbers = {10, 20, 30, 40, 50};
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

4. 练习4:定义一个方法,接受两个整数参数,返回它们的和

public class SumCalculator {
    public static int addNumbers(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        System.out.println(addNumbers(10, 20));  // 输出30
    }
}

5. 练习5:实现一个简单的条件判断,如果用户输入的年龄大于等于18岁,则输出“成年人”,否则输出“未成年人”

import java.util.Scanner;

public class AgeChecker {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的年龄:");
        int age = scanner.nextInt();
        if (age >= 18) {
            System.out.println("成年人");
        } else {
            System.out.println("未成年人");
        }
    }
}

6. 练习6:实现一个简单的for-each循环遍历String数组并打印

public class ForEachLoop {
    public static void main(String[] args) {
        String[] names = {"Alice", "Bob", "Charlie"};
        for (String name : names) {
            System.out.println(name);
        }
    }
}

请根据这些基础练习自行拓展和深化练习内容,逐步提高编程技能。对于进阶练习,可以从数据结构(如链表、队列、栈、树等)、算法(排序、查找、递归等)、面向对象编程(类与对象、继承、多态等)等方面进行训练。每一道题目的解答都要力求清晰、易懂,并理解背后的设计思路和编程原理。

7. 练习7:创建一个方法,用于计算一个整数数组的平均值

public class AverageCalculator {
    public static double calculateAverage(int[] numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return (double) sum / numbers.length;
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5};
        System.out.println("平均值为:" + calculateAverage(nums));
    }
}

8. 练习8:实现二分查找算法在一个有序整数数组中查找给定值

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

        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (sortedArray[mid] == target) {
                return mid;
            } else if (sortedArray[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1; // 如果没找到,返回-1
    }

    public static void main(String[] args) {
        int[] sortedArray = {1, 3, 5, 7, 9, 11};
        int target = 7;
        int result = binarySearch(sortedArray, target);
        if (result != -1) {
            System.out.println("找到元素 " + target + ",其索引为 " + result);
        } else {
            System.out.println(target + " 不在数组中");
        }
    }
}

9. 练习9:实现一个简单的银行账户类,具有存款、取款和查询余额的功能

public class BankAccount {
    private double balance;

    public BankAccount(double initialBalance) {
        this.balance = initialBalance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public boolean withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
            return true;
        } else {
            System.out.println("余额不足,取款失败!");
            return false;
        }
    }

    public double getBalance() {
        return balance;
    }

    public static void main(String[] args) {
        BankAccount account = new BankAccount(1000);
        account.deposit(500);
        System.out.println("存款后余额为:" + account.getBalance());
        account.withdraw(200);
        System.out.println("取款后余额为:" + account.getBalance());
    }
}

以上只是冰山一角,你还可以通过设计实现更复杂的类、进行异常处理、文件读写操作、多线程编程等来增加练习难度和深度。记住,编程不仅仅是写代码,更重要的是理解背后的逻辑和解决问题的方法。不断挑战自己,多思考、多动手实践,你的Java编程能力会逐渐提高。

接下来再为您提供几个进阶的Java编程练习题目:

10. 练习10:实现一个栈数据结构

```java
public class Stack {
    private Object[] stackArray;
    private int top;

    public Stack(int size) {
        stackArray = new Object[size];
        top = -1;
    }

    public void push(Object item) {
        if (top >= stackArray.length - 1) {
            throw new IllegalStateException("栈已满");
        }
        top++;
        stackArray[top] = item;
    }

    public Object pop() {
        if (top < 0) {
            throw new NoSuchElementException("栈为空");
        }
        Object item = stackArray[top];
        stackArray[top--] = null; // 清除引用,帮助垃圾回收
        return item;
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public int size() {
        return top + 1;
    }

    public static void main(String[] args) {
        Stack myStack = new Stack(5);
        myStack.push("First");
        myStack.push("Second");
        System.out.println("当前栈大小:" + myStack.size());
        System.out.println("弹出元素:" + myStack.pop());
        System.out.println("是否为空:" + myStack.isEmpty());
    }
}

// 注意:在实际项目中,建议使用泛型(Generic)以避免类型安全问题,例如 `public class Stack<T> {...}`
```

11. 练习11:实现一个队列数据结构(先进先出,FIFO)

```java
public class Queue {
    private Object[] queueArray;
    private int front, rear;

    public Queue(int capacity) {
        queueArray = new Object[capacity];
        front = 0;
        rear = -1;
    }

    public void enqueue(Object item) {
        if ((rear + 1) % queueArray.length == front) {
            throw new IllegalStateException("队列已满");
        }
        rear = (rear + 1) % queueArray.length;
        queueArray[rear] = item;
    }

    public Object dequeue() {
        if (front == rear) {
            throw new NoSuchElementException("队列为空");
        }
        Object item = queueArray[front];
        queueArray[front] = null;
        front = (front + 1) % queueArray.length;
        return item;
    }

    public boolean isEmpty() {
        return front == rear;
    }

    public int size() {
        return ((rear - front + queueArray.length) % queueArray.length);
    }

    public static void main(String[] args) {
        Queue myQueue = new Queue(5);
        myQueue.enqueue("First");
        myQueue.enqueue("Second");
        System.out.println("当前队列大小:" + myQueue.size());
        System.out.println("出队元素:" + myQueue.dequeue());
        System.out.println("是否为空:" + myQueue.isEmpty());
    }
}

// 同样,实际项目中推荐使用泛型版本 `public class Queue<T> {...}`
```

12. 练习12:实现一个基于链表的单向列表类

```java
public class LinkedListNode {
    Object data;
    LinkedListNode next;

    public LinkedListNode(Object data) {
        this.data = data;
        this.next = null;
    }
}

public class LinkedList {
    private LinkedListNode head;

    public void add(Object data) {
        LinkedListNode newNode = new LinkedListNode(data);
        if (head == null) {
            head = newNode;
        } else {
            LinkedListNode current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
    }

    public void printList() {
        LinkedListNode temp = head;
        while (temp != null) {
            System.out.print(temp.data + " -> ");
            temp = temp.next;
        }
        System.out.println("NULL");
    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.add("One");
        list.add("Two");
        list.add("Three");
        list.printList();
    }
}
```

这些练习有助于加深对基础数据结构的理解,并掌握如何在Java中实现它们。同时,也可以尝试实现更复杂的数据结构,如树、图等,并考虑如何优化性能和处理边界情况。

13. 练习13:实现一个简单的计算器,支持加减乘除四则运算

```java
import java.util.Scanner;

public class SimpleCalculator {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数字:");
        double num1 = scanner.nextDouble();
        System.out.println("请输入运算符(+、-、*、/):");
        char operator = scanner.next().charAt(0);
        System.out.println("请输入第二个数字:");
        double num2 = scanner.nextDouble();

        switch (operator) {
            case '+':
                System.out.printf("结果是:%.2f\n", num1 + num2);
                break;
            case '-':
                System.out.printf("结果是:%.2f\n", num1 - num2);
                break;
            case '*':
                System.out.printf("结果是:%.2f\n", num1 * num2);
                break;
            case '/':
                if (num2 != 0) {
                    System.out.printf("结果是:%.2f\n", num1 / num2);
                } else {
                    System.out.println("错误:除数不能为零!");
                }
                break;
            default:
                System.out.println("错误:无效的运算符!");
        }
    }
}

14. 练习14:实现斐波那契数列

```java
public class FibonacciSeries {
    public static void printFibonacci(int n) {
        long prevPrev = 0;
        long prev = 1;
        System.out.print(prevPrev + ", " + prev + ", ");

        for (int i = 2; i < n; i++) {
            long current = prevPrev + prev;
            System.out.print(current + ", ");
            prevPrev = prev;
            prev = current;
        }
    }

    public static void main(String[] args) {
        int limit = 10;
        System.out.print("前 " + limit + " 项斐波那契数列是:");
        printFibonacci(limit);
    }
}

15. 练习15:实现一个简单的学生类,包含姓名、年龄、成绩等属性以及显示学生信息的方法

```java
public class Student {
    private String name;
    private int age;
    private double grade;

    public Student(String name, int age, double grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    public void displayStudentInfo() {
        System.out.println("姓名:" + name);
        System.out.println("年龄:" + age);
        System.out.println("成绩:" + grade);
    }

    public static void main(String[] args) {
        Student student = new Student("张三", 20, 90.5);
        student.displayStudentInfo();
    }
}

持续进行这些练习,并尝试将所学的知识运用到更复杂的场景中,如实现排序算法、数据结构的增删查改操作、文件读写操作、图形用户界面(GUI)设计等,从而不断提高Java编程技能。

16. 练习16:实现一个简易的图书管理系统

```java
class Book {
    String title;
    String author;
    int publicationYear;

    Book(String title, String author, int publicationYear) {
        this.title = title;
        this.author = author;
        this.publicationYear = publicationYear;
    }

    @Override
    public String toString() {
        return "Title: " + title + ", Author: " + author + ", Publication Year: " + publicationYear;
    }
}

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

public class LibrarySystem {
    List<Book> books;

    public LibrarySystem() {
        books = new ArrayList<>();
    }

    public void addBook(Book book) {
        books.add(book);
    }

    public void removeBook(Book book) {
        books.remove(book);
    }

    public void printAllBooks() {
        for (Book book : books) {
            System.out.println(book);
        }
    }

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

        while (true) {
            System.out.println("\n请选择操作:\n1. 添加图书\n2. 删除图书\n3. 显示所有图书\n4. 退出系统");
            int choice = scanner.nextInt();
            scanner.nextLine();

            switch (choice) {
                case 1:
                    System.out.println("请输入书名、作者和出版年份(逗号分隔):");
                    String input = scanner.nextLine();
                    String[] details = input.split(",");
                    Book book = new Book(details[0], details[1], Integer.parseInt(details[2]));
                    library.addBook(book);
                    break;
                case 2:
                    System.out.println("请输入要删除的书名:");
                    String titleToRemove = scanner.nextLine();
                    for (Book book : library.books) {
                        if (book.title.equals(titleToRemove)) {
                            library.removeBook(book);
                            System.out.println("图书已成功删除.");
                            break;
                        }
                    }
                    if (library.books.stream().noneMatch(b -> b.title.equals(titleToRemove))) {
                        System.out.println("未找到该图书.");
                    }
                    break;
                case 3:
                    library.printAllBooks();
                    break;
                case 4:
                    System.out.println("系统已退出...");
                    return;
                default:
                    System.out.println("无效的选择,请重新输入.");
            }
        }
    }
}

17. 练习17:实现一个简单的单链表,并支持插入和删除节点

```java
class ListNode {
    int val;
    ListNode next;

    ListNode(int val) {
        this.val = val;
        this.next = null;
    }
}

public class LinkedListOperations {
    public ListNode insert(ListNode head, int value) {
        ListNode newNode = new ListNode(value);
        if (head == null) {
            head = newNode;
        } else {
            ListNode current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
        return head;
    }

    public ListNode deleteNode(ListNode head, int value) {
        if (head == null) return null;
        if (head.val == value) return head.next;
        ListNode current = head;
        while (current.next != null) {
            if (current.next.val == value) {
                current.next = current.next.next;
                return head;
            }
            current = current.next;
        }
        return head;
    }

    public void printLinkedList(ListNode head) {
        ListNode node = head;
        while (node != null) {
            System.out.print(node.val + " -> ");
            node = node.next;
        }
        System.out.println("null");
    }

    public static void main(String[] args) {
        LinkedListOperations operations = new LinkedListOperations();
        ListNode head = null;

        head = operations.insert(head, 1);
        head = operations.insert(head, 2);
        head = operations.insert(head, 3);

        operations.printLinkedList(head);

        head = operations.deleteNode(head, 2);
        operations.printLinkedList(head);
    }
}
```

这些练习可以帮助你巩固面向对象编程、数据结构、控制流等基础知识,并逐步提升对复杂系统的理解和设计能力。后续可以尝试实现更复杂的数据结构、算法,以及利用Java特性如集合框架、多线程等进行实战演练。

18. 练习18:实现一个优先级队列(基于二叉堆)

```java
class PriorityQueue<Item extends Comparable<Item>> {
    private Item[] pq;
    private int N = 0;

    public PriorityQueue(int capacity) {
        pq = (Item[]) new Comparable[capacity + 1];
    }

    private boolean less(int i, int j) {
        return pq[i].compareTo(pq[j]) < 0;
    }

    private void swap(int i, int j) {
        Item t = pq[i];
        pq[i] = pq[j];
        pq[j] = t;
    }

    public void insert(Item item) {
        pq[++N] = item;
        swim(N);
    }

    public Item delMin() {
        Item min = pq[1];
        exch(1, N--);
        sink(1);
        pq[N + 1] = null; // avoid loitering
        return min;
    }

    private void swim(int k) {
        while (k > 1 && less(k / 2, k)) {
            exch(k / 2, k);
            k = k / 2;
        }
    }

    private void sink(int k) {
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && less(j, j + 1)) j++;
            if (!less(k, j)) break;
            exch(k, j);
            k = j;
        }
    }

    private void exch(int i, int j) {
        swap(i, j);
    }

    public boolean isEmpty() {
        return N == 0;
    }
}

public class PriorityQueueTest {
    public static void main(String[] args) {
        PriorityQueue<Integer> pq = new PriorityQueue<>(10);
        for (int i = 0; i < 10; i++) {
            pq.insert(i);
        }
        while (!pq.isEmpty()) {
            System.out.print(pq.delMin() + " ");
        }
    }
}

19. 练习19:实现一个简单的LRU缓存(Least Recently Used)

```java
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class LRUCache<K, V> {
    private final int capacity;
    private Map<K, Node<K, V>> map;
    private Queue<Node<K, V>> queue;
    private int size;

    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.map = new HashMap<>();
        this.queue = new LinkedList<>();
    }

    public V get(K key) {
        if (!map.containsKey(key)) return null;
        moveToHead(key);
        return map.get(key).value;
    }

    public void put(K key, V value) {
        if (map.containsKey(key)) {
            moveToHead(key);
            map.get(key).value = value;
        } else {
            if (size == capacity) {
                Node<K, V> removedNode = queue.poll();
                map.remove(removedNode.key);
                size--;
            }
            Node<K, V> newNode = new Node<>(key, value);
            map.put(key, newNode);
            queue.offer(newNode);
            size++;
        }
    }

    private void moveToHead(K key) {
        Node<K, V> node = map.get(key);
        queue.remove(node);
        queue.offer(node);
    }

    private static class Node<K, V> {
        K key;
        V value;
        Node(K key, V value) {
            this.key = key;
            this.value = value;
        }
    }

    public static void main(String[] args) {
        LRUCache<Integer, String> cache = new LRUCache<>(2);
        cache.put(1, "one");
        cache.put(2, "two");
        System.out.println(cache.get(1)); // 返回 "one"
        cache.put(3, "three"); // 去除 key 2
        System.out.println(cache.get(2)); // 返回 null(已移除)
        cache.put(4, "four"); // 去除 key 1
        System.out.println(cache.get(1)); // 返回 null(已移除)
        System.out.println(cache.get(3)); // 返回 "three"
        System.out.println(cache.get(4)); // 返回 "four"
    }
}
```

这些练习涵盖了数据结构(如二叉堆和双向链表)以及算法(如优先级队列和LRU缓存策略)的实现,对于提升编程技巧和解决问题的能力非常有帮助。

20. 练习20:实现一个简单的数据库连接池

```java
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.LinkedList;
import java.util.Queue;

public class ConnectionPool {
    private static final int MAX_POOL_SIZE = 10;
    private static final String DB_URL = "jdbc:mysql://localhost:3306/testdb";
    private static final String USER = "username";
    private static final String PASS = "password";

    private Queue<Connection> connections;
    private int poolSize;

    public ConnectionPool() {
        connections = new LinkedList<>();
        initPool();
    }

    private void initPool() {
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            for (int i = 0; i < MAX_POOL_SIZE; i++) {
                Connection conn = DriverManager.getConnection(DB_URL, USER, PASS);
                conn.setAutoCommit(false); // 可根据需求设置自动提交
                connections.add(conn);
                poolSize++;
            }
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
        }
    }

    public synchronized Connection getConnection() {
        while (poolSize == 0) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        Connection conn = connections.poll();
        notifyAll(); // 唤醒所有等待的线程
        return conn;
    }

    public synchronized void releaseConnection(Connection conn) {
        if (conn != null) {
            try {
                if (!conn.isClosed()) {
                    connections.offer(conn);
                }
                poolSize--;
                notifyAll(); // 唤醒所有等待的线程
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ConnectionPool pool = new ConnectionPool();
        // 使用getConnection()获取连接,使用完毕后调用releaseConnection()释放连接
    }
}

21. 练习21:实现一个简单的文件上传功能(HTTP POST请求)

```java
import java.io.File;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;

public class FileUploader {
    public static void uploadFile(String serverUrl, String filePath) {
        try {
            URL url = new URL(serverUrl);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setDoOutput(true);
            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "multipart/form-data");

            File file = new File(filePath);
            Files.copy(file.toPath(), connection.getOutputStream(), StandardCopyOption.REPLACE_EXISTING);

            int responseCode = connection.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                System.out.println("文件上传成功");
            } else {
                System.out.println("文件上传失败,响应码:" + responseCode);
            }

            connection.disconnect();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String serverUrl = "http://example.com/upload"; // 替换为实际服务器地址
        String filePath = "/path/to/your/file.txt"; // 替换为你要上传的文件路径
        uploadFile(serverUrl, filePath);
    }
}

请注意,上述示例简化了某些细节,实际应用中需处理更多边界情况和错误,例如完善异常处理、关闭资源、加密传输等。在实现数据库连接池时,可选用成熟的开源库如HikariCP或Druid。而在文件上传功能中,通常会使用Apache HttpClient或OkHttp库以支持更复杂的HTTP请求处理和文件上传格式(如Multipart)。

22. 练习22:实现一个简单的文件下载器

```java
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.HttpURLConnection;
import java.net.URL;

public class FileDownloader {
    public static void downloadFile(String urlString, String saveDir, String fileName) {
        try {
            URL url = new URL(urlString);
            HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
            int responseCode = httpConn.getResponseCode();
            if (responseCode == HttpURLConnection.HTTP_OK) {
                BufferedInputStream bis = new BufferedInputStream(httpConn.getInputStream());
                String saveFilePath = saveDir + File.separator + fileName;
                FileOutputStream fos = new FileOutputStream(saveFilePath);
                byte[] buffer = new byte[1024];
                int bytesRead;
                while ((bytesRead = bis.read(buffer)) != -1) {
                    fos.write(buffer, 0, bytesRead);
                }
                fos.close();
                bis.close();
                httpConn.disconnect();
                System.out.println("文件已成功下载到:" + saveFilePath);
            } else {
                System.out.println("无法下载文件,响应码:" + responseCode);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        String urlString = "http://example.com/path/to/file.zip"; // 需替换为实际URL
        String saveDir = "/path/to/save/directory"; // 替换为本地保存目录
        String fileName = "file.zip"; // 文件名
        downloadFile(urlString, saveDir, fileName);
    }
}

23. 练习23:实现一个简单的哈希表(HashMap)

```java
public class MyHashMap<K, V> {
    private static final int INITIAL_CAPACITY = 16;
    private static final float LOAD_FACTOR = 0.75f;
    private Entry<K, V>[] table;
    private int size;

    public MyHashMap() {
        table = new Entry[INITIAL_CAPACITY];
    }

    private static class Entry<K, V> {
        K key;
        V value;
        Entry<K, V> next;

        Entry(K key, V value, Entry<K, V> next) {
            this.key = key;
            this.value = value;
            this.next = next;
        }
    }

    public V put(K key, V value) {
        int hash = hash(key);
        int index = indexFor(hash, table.length);

        Entry<K, V> entry = table[index];
        while (entry != null) {
            if (entry.key.equals(key)) {
                V oldValue = entry.value;
                entry.value = value;
                return oldValue;
            }
            entry = entry.next;
        }

        resizeIfNeeded();
        entry = new Entry<>(key, value, table[index]);
        table[index] = entry;
        size++;
        return null;
    }

    public V get(K key) {
        int hash = hash(key);
        int index = indexFor(hash, table.length);

        Entry<K, V> entry = table[index];
        while (entry != null) {
            if (entry.key.equals(key)) {
                return entry.value;
            }
            entry = entry.next;
        }
        return null;
    }

    private void resizeIfNeeded() {
        if (size > table.length * LOAD_FACTOR) {
            resize(2 * table.length);
        }
    }

    private void resize(int newCapacity) {
        Entry<K, V>[] oldTable = table;
        table = new Entry[newCapacity];

        for (Entry<K, V> entry : oldTable) {
            while (entry != null) {
                rehash(entry);
                entry = entry.next;
            }
        }
    }

    private void rehash(Entry<K, V> entry) {
        int hash = hash(entry.key);
        int index = indexFor(hash, table.length);

        entry.next = table[index];
        table[index] = entry;
    }

    private int hash(K key) {
        return Math.abs(key.hashCode()) % table.length;
    }

    private int indexFor(int h, int length) {
        return h & (length - 1);
    }

    // 其他方法如remove、size、isEmpty等可以按照类似的方式实现

    public static void main(String[] args) {
        MyHashMap<String, Integer> map = new MyHashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        System.out.println(map.get("Apple")); // 输出 1
    }
}
```

以上练习涵盖了网络请求、文件操作和数据结构(哈希表)的实现,能够帮助你更好地理解并应用这些关键概念。后续你可以尝试实现哈希表的扩容机制、解决哈希冲突以及优化性能等进阶功能。

24. 练习24:实现一个简单的命令行版文本编辑器

```java
import java.io.*;

public class SimpleTextEditor {
    private StringBuilder content;

    public SimpleTextEditor() {
        content = new StringBuilder();
    }

    public void readFromFile(String filePath) {
        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                content.append(line).append("\n");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void writeToFile(String filePath) {
        try (PrintWriter writer = new PrintWriter(new FileWriter(filePath))) {
            writer.print(content.toString());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void append(String text) {
        content.append(text);
    }

    public void delete(int startIndex, int endIndex) {
        if (startIndex < 0 || startIndex > endIndex || endIndex > content.length()) {
            System.out.println("Invalid range");
        } else {
            content.delete(startIndex, endIndex);
        }
    }

    public void replace(int startIndex, int endIndex, String newText) {
        if (startIndex < 0 || startIndex > endIndex || endIndex > content.length()) {
            System.out.println("Invalid range");
        } else {
            content.replace(startIndex, endIndex, newText);
        }
    }

    public void display() {
        System.out.println(content.toString());
    }

    public static void main(String[] args) {
        SimpleTextEditor editor = new SimpleTextEditor();
        editor.readFromFile("input.txt");
        editor.display();
        editor.append("\nAppended text.");
        editor.replace(0, 5, "Replaced!");
        editor.delete(10, 15);
        editor.writeToFile("output.txt");
    }
}

25. 练习25:实现一个简单的TCP聊天客户端和服务器

```java
// TCP聊天服务器端
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class ChatServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(12345);
        System.out.println("服务器启动,等待客户端连接...");

        while (true) {
            Socket socket = serverSocket.accept();
            new Thread(new ClientHandler(socket)).start();
        }
    }

    static class ClientHandler implements Runnable {
        private Socket socket;
        private BufferedReader in;
        private PrintWriter out;

        public ClientHandler(Socket socket) throws IOException {
            this.socket = socket;
            in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            out = new PrintWriter(socket.getOutputStream(), true);
        }

        @Override
        public void run() {
            String message;
            try {
                while ((message = in.readLine()) != null) {
                    System.out.println("客户端消息:" + message);
                    // 在这里可以添加转发消息至其他客户端的逻辑
                    out.println("服务器回复:" + message);
                }
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// TCP聊天客户端
import java.io.*;
import java.net.Socket;

public class ChatClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 12345);
        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        PrintWriter out = new PrintWriter(socket.getOutputStream(), true);

        BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));

        String messageFromServer, messageToServer;
        while (true) {
            messageToServer = userInput.readLine();
            out.println(messageToServer);
            messageFromServer = in.readLine();
            System.out.println("服务器消息:" + messageFromServer);
        }
    }
}
```

以上练习涉及到了文件操作、字符串处理、线程管理和网络通信等方面的知识,通过完成这些练习,你可以进一步提升对Java核心特性的理解和应用能力。

接下来是一些关于Java GUI编程的练习题目:

26. 练习26:使用Java Swing创建一个简单的计时器应用程序

```java
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

public class TimerApp extends JFrame {
    private JLabel timerLabel;
    private JButton startButton, stopButton;
    private int seconds = 0;
    private Timer timer;

    public TimerApp() {
        setTitle("简易计时器");
        setSize(300, 100);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        timerLabel = new JLabel("00:00");
        startButton = new JButton("开始");
        stopButton = new JButton("停止");

        startButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                startTimer();
            }
        });

        stopButton.addActionListener(new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                stopTimer();
            }
        });

        JPanel panel = new JPanel();
        panel.setLayout(new FlowLayout());
        panel.add(timerLabel);
        panel.add(startButton);
        panel.add(stopButton);

        add(panel);
        setVisible(true);
    }

    private void startTimer() {
        timer = new Timer(1000, new ActionListener() {
            @Override
            public void actionPerformed(ActionEvent e) {
                seconds++;
                int mins = seconds / 60;
                int secs = seconds % 60;
                timerLabel.setText(String.format("%02d:%02d", mins, secs));
            }
        });
        timer.start();
    }

    private void stopTimer() {
        if (timer != null) {
            timer.stop();
        }
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                new TimerApp();
            }
        });
    }
}

27. 练习27:使用JavaFX创建一个简单的登录界面

```java
import javafx.application.Application;
import javafx.geometry.Pos;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.control.PasswordField;
import javafx.scene.control.TextField;
import javafx.scene.layout.GridPane;
import javafx.stage.Stage;

public class LoginApp extends Application {
    @Override
    public void start(Stage primaryStage) {
        GridPane grid = new GridPane();
        grid.setAlignment(Pos.CENTER);
        grid.setHgap(10);
        grid.setVgap(10);

        Label usernameLabel = new Label("用户名:");
        TextField usernameField = new TextField();
        grid.add(usernameLabel, 0, 0);
        grid.add(usernameField, 1, 0);

        Label passwordLabel = new Label("密码:");
        PasswordField passwordField = new PasswordField();
        grid.add(passwordLabel, 0, 1);
        grid.add(passwordField, 1, 1);

        Button loginButton = new Button("登录");
        grid.add(loginButton, 1, 2);

        Scene scene = new Scene(grid, 300, 200);
        primaryStage.setTitle("简易登录界面");
        primaryStage.setScene(scene);
        primaryStage.show();

        // 添加登录按钮点击事件监听器,验证用户名和密码(此处仅为模拟,实际需要与后台交互)
        loginButton.setOnAction(e -> {
            String username = usernameField.getText();
            String password = passwordField.getText();
            if ("admin".equals(username) && "123456".equals(password)) {
                System.out.println("登录成功");
            } else {
                System.out.println("登录失败");
            }
        });
    }

    public static void main(String[] args) {
        launch(args);
    }
}
```

以上练习旨在帮助你熟悉Java的Swing和JavaFX GUI编程库,掌握如何构建基本的桌面应用程序界面以及处理用户交互。在实际开发中,可以根据项目需求深入学习布局管理、事件处理、模型视图控制器(MVC)模式等内容。

28. 练习28:实现一个简单的生产者消费者模型

```java
import java.util.LinkedList;
import java.util.Queue;
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumer {
    private final Queue<Integer> buffer = new LinkedList<>();
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final int BUFFER_SIZE = 10;

    class ProducerThread extends Thread {
        @Override
        public void run() {
            Random random = new Random();
            while (true) {
                lock.lock();
                try {
                    while (buffer.size() == BUFFER_SIZE) {
                        notFull.await();
                    }
                    buffer.add(random.nextInt(100));
                    System.out.println("Producer produced: " + buffer.peek());
                    notEmpty.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    class ConsumerThread extends Thread {
        @Override
        public void run() {
            while (true) {
                lock.lock();
                try {
                    while (buffer.isEmpty()) {
                        notEmpty.await();
                    }
                    int data = buffer.poll();
                    System.out.println("Consumer consumed: " + data);
                    notFull.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();
        Thread producer = new pc.ProducerThread();
        Thread consumer = new pc.ConsumerThread();
        producer.start();
        consumer.start();
    }
}

29. 练习29:实现一个简单的Future模式,异步获取结果

```java
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class FuturePatternExample {
    interface DataFetcher {
        String fetchData() throws Exception;
    }

    static class AsyncDataFetcher {
        ExecutorService executorService = Executors.newFixedThreadPool(10);

        Future<String> fetchAsyncData(DataFetcher dataFetcher) {
            return executorService.submit(dataFetcher::fetchData);
        }
    }

    public static void main(String[] args) {
        AsyncDataFetcher asyncDataFetcher = new AsyncDataFetcher();
        DataFetcher dataFetcher = () -> {
            Thread.sleep(2000); // 模拟耗时操作
            return "Fetched Data!";
        };

        Future<String> future = asyncDataFetcher.fetchAsyncData(dataFetcher);

        try {
            System.out.println("Doing some other tasks...");
            Thread.sleep(1000);
            System.out.println("Received data from the Future: " + future.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }
    }
}

这两个练习将帮助你掌握Java中的并发工具类和接口,如ReentrantLock, Condition, ExecutorService, 和 Future,以便更好地进行多线程编程和异步任务处理。在实际项目中,合理地运用并发技术能有效提高程序执行效率和响应速度。

下面是另一个关于Java集合框架和流API的练习题目:

30. 练习30:使用Java 8 Stream API对集合进行操作

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

public class StreamAPITest {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("apple", "banana", "cherry", "date", "elderberry");

        // 示例1:过滤出长度大于5的单词,并转换为大写
        List<String> longWordsInUppercase = words.stream()
                .filter(word -> word.length() > 5)
                .map(String::toUpperCase)
                .collect(Collectors.toList());
        System.out.println(longWordsInUppercase); // 输出:[BANANA, ELDERBERRY]

        // 示例2:统计列表中每个单词的字符数,并按字符数从低到高排序
        List<Integer> wordLengthsSorted = words.stream()
                .mapToInt(String::length)
                .boxed()
                .sorted()
                .collect(Collectors.toList());
        System.out.println(wordLengthsSorted); // 输出:[5, 5, 6, 6, 10]

        // 示例3:将单词列表合并为一个字符串,单词之间用逗号分隔
        String concatenatedWords = words.stream()
                .collect(Collectors.joining(", "));
        System.out.println(concatenatedWords); // 输出:apple, banana, cherry, date, elderberry

        // 示例4:计算列表中单词的总字符数
        int totalCharacters = words.stream()
                .mapToInt(String::length)
                .sum();
        System.out.println(totalCharacters); // 输出:28
    }
}

这个练习将帮助你熟练掌握Java 8引入的Stream API,学会如何对集合进行高效且简洁的操作,包括过滤、映射、排序、聚合等多种函数式编程特性。通过使用Stream API,可以使代码更加清晰易读,同时也提升了代码的运行效率。

此外,也可以尝试实现更复杂的流操作,比如找出列表中的最大值、最小值、平均值,或者使用reduce方法进行聚合运算等。在实际项目中,合理利用Stream API可以极大地提升数据处理和业务逻辑实现的效率。


综上所述,从初级到中级的Java程序员需要逐步掌握以上各项技能,同时注重实践,在项目中灵活运用所学知识,不断提升自己的编码能力和问题解决能力。此外,保持对新技术的关注和学习,如Spring BootSpring Cloud微服务架构等,也是成长为一名优秀Java开发者的重要环节。

 python推荐学习汇总连接:
[50个开发必备的Python经典脚本(1-10)](https://blog.csdn.net/qqrrjj2011/article/details/135201319)

[50个开发必备的Python经典脚本(11-20)](https://blog.csdn.net/qqrrjj2011/article/details/135220796)

[50个开发必备的Python经典脚本(21-30)](https://blog.csdn.net/qqrrjj2011/article/details/135220906)

[50个开发必备的Python经典脚本(31-40)](https://blog.csdn.net/qqrrjj2011/article/details/135222295)

[50个开发必备的Python经典脚本(41-50)](https://blog.csdn.net/qqrrjj2011/article/details/135222681)
————————————————


 
**​最后我们放松一下眼睛**
![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/25f61fadc35f491dae24742ab85fd90a.png)

 
  • 28
    点赞
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

极致人生-010

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值