校招Java面试基础题目解析与学习指南（含新技术实操）

八、Java 8+ 新特性

8.1 Lambda表达式与函数式接口

Lambda表达式是Java 8引入的重要特性，用于简化函数式接口的实现。函数式接口是指只包含一个抽象方法的接口。

示例： 使用Lambda表达式实现Runnable接口

// 传统方式
Runnable runnable1 = new Runnable() {
   
    @Override
    public void run() {
   
        System.out.println("传统方式实现Runnable");
    }
};

// Lambda表达式方式
Runnable runnable2 = () -> System.out.println("Lambda方式实现Runnable");

// 使用示例
new Thread(runnable1).start();
new Thread(runnable2).start();

8.2 Stream API

Stream API用于对集合进行高效处理，支持过滤、映射、排序等操作。

示例： 对列表进行过滤和映射

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

public class StreamExample {
   
    public static void main(String[] args) {
   
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 过滤偶数并乘以2
        List<Integer> result = numbers.stream()
                .filter(n -> n % 2 == 0)      // 过滤偶数
                .map(n -> n * 2)              // 每个元素乘以2
                .collect(Collectors.toList()); // 收集结果

        System.out.println(result); // 输出: [4, 8, 12]
    }
}

8.3 Optional类

Optional类用于解决空指针异常（NullPointerException），使代码更健壮。

示例： 使用Optional处理可能为空的值

import java.util.Optional;

public class OptionalExample {
   
    public static void main(String[] args) {
   
        String nullableString = null;

        // 创建Optional对象
        Optional<String> optional = Optional.ofNullable(nullableString);

        // 使用orElse方法提供默认值
        String result = optional.orElse("Default Value");

        // 使用ifPresent方法处理值存在的情况
        optional.ifPresent(s -> System.out.println("值存在: " + s));

        System.out.println(result); // 输出: Default Value
    }
}

九、多线程与并发

9.1 CompletableFuture异步编程

Java 8引入的CompletableFuture提供了强大的异步编程能力。

示例： 异步任务组合

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureExample {
   
    public static void main(String[] args) throws ExecutionException, InterruptedException {
   
        // 创建异步任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
   
            try {
   
                Thread.sleep(1000);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            return "Result from Future 1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
   
            try {
   
                Thread.sleep(1500);
            } catch (InterruptedException e) {
   
                e.printStackTrace();
            }
            return "Result from Future 2";
        });

        // 组合两个异步任务
        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> {
   
            return s1 + " and " + s2;
        });

        // 获取结果
        System.out.println(combinedFuture.get()); 
        // 输出: Result from Future 1 and Result from Future 2
    }
}

9.2 ReentrantLock与Condition

Java 5引入的ReentrantLock提供了比synchronized更灵活的锁机制。

示例： 使用ReentrantLock和Condition实现生产者-消费者模式

import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class ProducerConsumerExample {
   
    private final Queue<Integer> queue = new LinkedList<>();
    private final int capacity = 5;
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();

    public void produce() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (queue.size() == capacity) {
   
                notFull.await(); // 队列满时等待
            }
            int item = (int) (Math.random() * 100);
            queue.add(item);
            System.out.println("Produced: " + item);
            notEmpty.signal(); // 通知消费者队列非空
        } finally {
   
            lock.unlock();
        }
    }

    public void consume() throws InterruptedException {
   
        lock.lock();
        try {
   
            while (queue.isEmpty()) {
   
                notEmpty.await(); // 队列空时等待
            }
            int item = queue.poll();
            System.out.println("Consumed: " + item);
            notFull.signal(); // 通知生产者队列非满
        } finally {
   
            lock.unlock();
        }
    }
}

十、新的语法特性

10.1 局部变量类型推断(var)

Java 10引入的var关键字允许编译器自动推断局部变量的类型。

示例： 使用var简化变量声明

// 传统方式
List<String> names = new ArrayList<>();
Map<Integer, String> map = new HashMap<>();

// 使用var关键字
var namesList = new ArrayList<String>();
var numberMap = new HashMap<Integer, String>();

10.2 文本块(Text Blocks)

Java 13引入的文本块简化了多行字符串的表示。

示例： 使用文本块代替传统字符串拼接

// 传统方式
String html = "<html>\n" +
              "    <body>\n" +
              "        <h1>Hello, World!</h1>\n" +
              "    </body>\n" +
              "</html>";

// 使用文本块
String htmlBlock = """
        <html>
            <body>
                <h1>Hello, World!</h1>
            </body>
        </html>
        """;

十一、模块化系统(Java 9+)

Java 9引入的模块化系统(JPMS)增强了代码的安全性和可维护性。

示例： 创建一个简单的模块化应用

// module-info.java
module com.example.myapp {
   
    requires java.base;
    requires java.sql;

    exports com.example.myapp.api;
    opens com.example.myapp.impl to java.reflect;
}

// 在模块中使用
package com.example.myapp.api;

public interface Service {
   
    void doSomething();
}

十二、集合与泛型新特性

12.1 不可变集合

Java 9+提供了创建不可变集合的静态工厂方法。

示例： 创建不可变集合

// 创建不可变List
List<String> immutableList = List.of("A", "B", "C");

// 创建不可变Set
Set<Integer> immutableSet = Set.of(1, 2, 3);

// 创建不可变Map
Map<String, Integer> immutableMap = Map.of("One", 1, "Two", 2);

12.2 泛型改进

Java 10+对泛型进行了改进，支持更灵活的类型推断。

示例： 使用菱形语法与var结合

// Java 7+ 菱形语法
List<String> list = new ArrayList<>();

// Java 10+ 结合var
var map = new HashMap<String, List<Integer>>();

十三、实操项目：在线书店系统

13.1 项目需求

使用Java 8+特性开发一个简单的在线书店系统，包含书籍管理、用户管理和订单管理功能。

13.2 核心代码实现

import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

// 书籍类
class Book {
   
    private final String id;
    private final String title;
    private final String author;
    private final double price;

    public Book(String id, String title, String author, double price) {
   
        this.id = id;
        this.title = title;
        this.author = author;
        this.price = price;
    }

    // Getters
    public String getId() {
    return id; }
    public String getTitle() {
    return title; }
    public String getAuthor() {
    return author; }
    public double getPrice() {
    return price; }

    @Override
    public String toString() {
   
        return "Book{id=%s, title='%s', author='%s', price=%.2f}".formatted(id, title, author, price);
    }
}

// 用户类
class User {
   
    private final String id;
    private final String name;
    private final String email;
    private List<Order> orders = new ArrayList<>();

    public User(String id, String name, String email) {
   
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public String getId() {
    return id; }
    public String getName() {
    return name; }
    public String getEmail() {
    return email; }
    public List<Order> getOrders() {
    return orders; }
    public void addOrder(Order order) {
    orders.add(order); }
}

// 订单类
class Order {
   
    private final String id;
    private final User user;
    private final List<Book> books;
    private final LocalDateTime orderTime;
    private OrderStatus status;

    public Order(String id, User user, List<Book> books) {
   
        this.id = id;
        this.user = user;
        this.books = books;
        this.orderTime = LocalDateTime.now();
        this.status = OrderStatus.CREATED;
    }

    // Getters and Setters
    public String getId() {
    return id; }
    public User getUser() {
    return user; }
    public List<Book> getBooks() {
    return books; }
    public LocalDateTime getOrderTime() {
    return orderTime; }
    public OrderStatus getStatus() {
    return status; }
    public void setStatus(OrderStatus status) {
    this.status = status; }

    public double getTotalPrice() {
   
        return books.stream().mapToDouble(Book::getPrice).sum();
    }
}

// 订单状态枚举
enum OrderStatus {
   
    CREATED, PAID, SHIPPED, DELIVERED, CANCELLED
}

// 书店服务类
class BookstoreService {
   
    private final List<Book> books = new ArrayList<>();
    private final Map<String, User> users = new HashMap<>();
    private final Map<String, Order> orders = new HashMap<>();

    // 添加书籍
    public void addBook(Book book) {
   
        books.add(book);
    }

    // 根据作者查找书籍
    public List<Book> findBooksByAuthor(String author) {
   
        return books.stream()
                .filter(book -> book.getAuthor().equalsIgnoreCase(author))
                .collect(Collectors.toList());
    }

    // 创建用户
    public User createUser(String id, String name, String email) {
   
        User user = new User(id, name, email);
        users.put(id, user);
        return user;
    }

    // 创建订单
    public CompletableFuture<Order> createOrderAsync(String userId, List<String> bookIds) {
   
        return CompletableFuture.supplyAsync(() -> {
   
            User user = users.get(userId);
            if (user == null) {
   
                throw new IllegalArgumentException("用户不存在: " + userId);
            }

            List<Book> orderBooks = bookIds.stream()
                    .map(id -> books.stream()
                            .filter(b -> b.getId().equals(id))
                            .findFirst()
                            .orElseThrow(() -> new IllegalArgumentException("书籍不存在: " + id)))
                    .collect(Collectors.toList());

            String orderId = UUID.randomUUID().toString();
            Order order = new Order(orderId, user, orderBooks);
            orders.put(orderId, order);
            user.addOrder(order);

            return order;
        });
    }

    // 获取用户订单统计
    public Map<String, Double> getUserOrderStatistics() {
   
        return users.values().stream()
                .collect(Collectors.toMap(
                        User::getName,
                        user -> user.getOrders().stream()
                                .mapToDouble(Order::getTotalPrice)
                                .sum(),
                        (existing, replacement) -> existing // 处理键冲突
                ));
    }
}

// 主类 - 演示使用
public class OnlineBookstore {
   
    public static void main(String[] args) throws Exception {
   
        BookstoreService service = new BookstoreService();

        // 添加书籍
        service.addBook(new Book("B001", "Java核心技术", "Cay Horstmann", 99.99));
        service.addBook(new Book("B002", "Effective Java", "Joshua Bloch", 89.99));
        service.addBook(new Book("B003", "Python Crash Course", "Eric Matthes", 79.99));

        // 创建用户
        User user = service.createUser("U001", "张三", "zhangsan@example.com");

        // 创建订单（异步）
        CompletableFuture<Order> orderFuture = service.createOrderAsync(
                "U001", Arrays.asList("B001", "B002"));

        orderFuture.thenAccept(order -> {
   
            System.out.println("订单创建成功: " + order.getId());
            System.out.println("订单总价: " + order.getTotalPrice());
        }).exceptionally(ex -> {
   
            System.out.println("订单创建失败: " + ex.getMessage());
            return null;
        }).get(); // 等待异步操作完成

        // 统计用户消费
        Map<String, Double> statistics = service.getUserOrderStatistics();
        System.out.println("\n用户消费统计:");
        statistics.forEach((name, total) -> System.out.printf("%s: %.2f元%n", name, total));
    }
}

这个在线书店系统示例展示了如何结合Java 8+的新特性（Lambda表达式、Stream API、CompletableFuture等）来构建一个现代的Java应用。通过学习和实践这些技术，你将能够更好地应对校招面试中的高级问题。

通过上述代码和解释，你可以看到Java最新技术的实际应用。建议你运行这些示例代码，并尝试根据需求进行扩展，以加深对这些技术的理解。如果你需要进一步的帮助或有任何疑问，请随时告诉我。

校招，Java 面试，基础题目，解析，学习指南，新技术，实操要点，Java 基础，数据结构，算法，面向对象编程，Spring 框架，MyBatis,MySQL, 微服务

资源地址：
https://pan.quark.cn/s/14fcf913bae6