真实笔试题

线程题

实现一个类支持100个线程同时向一个银行账户中存入一元钱.需通过同步机制消除竞态条件,当所有线程执行完成后,账户余额必须精确等于100元

package com.itheima.thread;

public class ShowMeBug {
    private double balance; // 账户余额
    private final Object lock = new Object(); // 锁对象，用于同步

    /**
     * 存款
     *
     * @param money 存入金额
     */
    public void deposit(double money) {
        synchronized (lock) { // 使用同步块确保线程安全
            balance += 1;
        }
    }

    /**
     * 获得账户余额
     */
    public double getBalance() {
        return balance; // 修正：getBalance 不需要参数
    }

    public static void main(String[] args) throws InterruptedException{
        ShowMeBug account = new ShowMeBug();
        int numberOfThreads = 100;
        Thread[] threads = new Thread[numberOfThreads];

         //创建并启动100个线程，每个线程存入1元
        for (int i = 0; i < numberOfThreads; i++) {
            threads[i] = new Thread(() -> {
                account.deposit(1.0);
            });
            threads[i].start();
        }

        // 等待所有线程完成
        for (int i = 0; i < numberOfThreads; i++) {
            threads[i].join();
        }

        // 输出账户余额
        System.out.println("账户余额: " + account.getBalance());
    }
}

树的深度遍历

package com.itheima.tree;

import java.util.*;

public class ShowMeBug {
    static class Node {
        int id;
        int parentId;
        String name;

        public Node(int id, int parentId, String name) {
            this.id = id;
            this.parentId = parentId;
            this.name = name;
        }
    }

    public static void main(String[] args) {
        List<Node> nodeList = Arrays.asList(
                new Node(1, 0, "AA"),
                new Node(2, 1, "BB"),
                new Node(3, 1, "CC"),
                new Node(4, 3, "DD"),
                new Node(5, 3, "EE"),
                new Node(6, 2, "FF"),
                new Node(7, 2, "GG"),
                new Node(8, 4, "HH"),
                new Node(9, 5, "II"),
                new Node(10, 0, "JJ"),
                new Node(11, 10, "KK"),
                new Node(12, 10, "LL"),
                new Node(13, 12, "MM"),
                new Node(14, 13, "NN"),
                new Node(15, 14, "OO")
        );
        print(nodeList);
    }

    public static void print(List<Node> nodeList) {
        // Step 1: 构建父子关系
        Map<Integer, List<Node>> parentToChildren = new HashMap<>();
        for (Node node : nodeList) {
            parentToChildren.computeIfAbsent(node.parentId, k -> new ArrayList<>()).add(node);
        }

        // Step 2: 递归打印树形结构
        printTree(parentToChildren, 0, 0);
    }

    private static void printTree(Map<Integer, List<Node>> parentToChildren, int parentId, int level) {
        // 获取当前父节点的所有子节点
        List<Node> children = parentToChildren.getOrDefault(parentId, Collections.emptyList());

        // 遍历子节点并打印
        for (Node child : children) {
            // 打印缩进（根据层级）
            for (int i = 0; i < level; i++) {
                System.out.print("  "); // 使用两个空格表示缩进
            }
            // 打印节点名称
            System.out.println(child.name);

            // 递归打印子节点的子树
            printTree(parentToChildren, child.id, level + 1);
        }
    }
}