Java 中的场景题

2024年9月10日 | 11 分钟阅读

场景 1：缓存

您需要从数据库加载股票交易所证券代码及其价格，并将它们缓存起来以提高性能。证券代码需要每 30 分钟刷新一次。这些缓存数据需要由单个写入线程填充和刷新，并由多个读取线程读取。您将如何确保您的读/写解决方案具有可扩展性和线程安全性？

解决方案

java.util.concurrent.locks 包提供了实现读/写锁的类，其中读锁可以由多个线程并行执行，写锁只能由单个线程持有。ReadWriteLock 接口维护一对相关的锁，一个用于只读，一个用于写入。readLock() 可以被多个读线程同时持有，而 writeLock() 是排他的。通常，与互斥锁（即通过 synchronized 关键字）相比，当

存在更多读取操作，并且每次读取的持续时间比写入操作及其持续时间更长时，这种实现可以提高性能和可扩展性。
性能还取决于运行代码的机器，特别是如果它具有多核处理器，因为它允许更好的并行性。

Caching.java

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class Caching {
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(2);
        Map<String, BigDecimal> map = new HashMap<>();
        ReadWriteLock lock = new ReentrantReadWriteLock();
        executor.submit(() -> {
            lock.writeLock().lock();
            System.out.println("Writing ....." );
            try {
                try {
                    TimeUnit.SECONDS.sleep(3); //emulating update
                } catch (Exception e) {
                    e.printStackTrace();
                }
                map.put("stock-ABC", BigDecimal.valueOf(12.35));
            } finally {
                lock.writeLock().unlock();
            }
        });
        Runnable readTask = () -> {
            lock.readLock().lock();
            try {
                System.out.println("Reading ....." + map.get("stock-ABC"));
                try {
                    TimeUnit.SECONDS.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            } finally {
                lock.readLock().unlock();
            }
        };
        //multiple reads
        executor.submit(readTask);
        executor.submit(readTask);
        //...............other code. As it keeps running.
        //executor.shutdown();
    }
}

输出

Writing .....
Reading .....12.35
Reading .....12.35

场景 2：异步处理

如果您需要通过从数据库提取数百万条历史记录来生成在线报告或文件馈送，您会提出什么问题，以及如何着手设计它？

解决方案

设计系统就是要提出正确的问题以收集需求。

在线与离线？我们是否应限制在线报告仅包含过去 12 个月的数据，以减小报告大小并提高性能，并通过离线处理提供超过 12 个月的数据的报告/馈送？例如，过去 12 个月的银行对账单在线提供，而 12 个月以上的交易则通过离线异步处理，而不会阻止客户浏览网站的其余部分。报告可以异步生成，一旦准备好，就可以通过 URL 在稍后通过电子邮件发送或下载。

使用哪个报告生成框架，如 Jasper Reports、Open CSV、XSL-FO 和 Apache FOP 等，具体取决于所需的输出格式？

如何处理异常情况？发送错误电子邮件，使用 Tivoli 或 Nagios 等监控系统在发生故障时提起生产支持工单等？

安全要求。我们是否通过电子邮件发送包含 PII（即个人身份信息）的数据的馈送/报告？我们需要适当的访问控制来限制谁可以生成哪些在线报告吗？我们应该为电子邮件附件设置密码保护吗？是否有任何合规性或监管要求，如 PCI（即支付卡行业）、GDPR（即通用数据保护条例）、ACCC（即澳大利亚竞争与消费者委员会）等，具体取决于应用程序服务的司法管辖区？

我们是否应该在非高峰时段安排离线报告运行？例如，将所有报告请求输入“请求”表，然后安排一个进程在午夜运行，以引用“请求”表中所有待处理的请求来生成并将相关报告存储在发件箱中供客户下载。可以向客户发送一封电子邮件，其中包含报告的 URL 以供下载。

历史报告的存档和清除策略。出于审计和合规目的，报告保留期是多久？文件有多大？

具有生成耗时报告或业务流程（例如，重新平衡账户、聚合分层信息等）要求的在线应用程序可以从使这些长时间运行的操作异步化中受益。一旦报告或长时间运行的业务流程完成，就可以通过电子邮件或通过称为“服务器推送（JEE 异步 Servlet）”或“客户端拉取（刷新元标记）”的技术异步刷新网页来将结果通知用户。一个典型的例子是

用户在线请求聚合报告或诸如重新平衡其投资组合之类的业务流程。
用户请求将被保存到一个数据库表中，供单独的进程定期提取并异步处理。
然后，用户可以继续执行网站的其他功能，而不会被阻塞。
在同一台机器或不同机器上运行的单独进程可以定期扫描表以获取任何条目，并生成必要的报告或执行相关的业务流程。这可以是一个在非高峰时段运行一次的计划作业，或每 10 分钟运行一次。这取决于业务需求。
一旦报告或进程完成，通过电子邮件通知用户，或使报告在线可用以下载。

场景 3：正则表达式

我们需要在 350 多个 HTML 文件中查找文本“Client”并将其更改为“Customer”。

解决方案

Regex.java

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Regex{
    public static void replaceClientWithCustomer(File file) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader(file));
        FileWriter writer = new FileWriter(new File("/tmp/tempfile.tmp"));
        String line;
        while ((line = reader.readLine()) != null) {
            line = line.replaceAll("Client", "Customer");
            writer.write(line + "\n");
        }
        reader.close();
        writer.close();
        file.delete();
        new File("/tmp/tempfile.tmp").renameTo(file);
    }
    public static void main(String[] args) throws IOException {
        File directory = new File(".");
        for (File file : directory.listFiles()) {
            if (file.getName().endsWith(".html")) {
                replaceClientWithCustomer(file);
            }
        }
        System.out.println("All HTML files have been updated.");
    }
}

输出

All HTML files have been updated.

场景 4：并发管理

引用计数，其中共享资源被增加或减少。增量/减量操作必须是线程安全的。例如，一个计数器，它跟踪已登录用户的数量，当用户登录时增加计数，当用户注销时减少计数。有时您希望允许有限数量的并发访问，例如一次 3 个用户。

解决方案

互斥锁 (Mutex): 是对象的唯一钥匙（例如，一个厕所）。一个人可以一次拿到钥匙并占用厕所。完成后，该人将钥匙交给队列中的下一个人（或释放）。在 Java 中，每个对象都有一个互斥锁，一次只有一个线程可以获得该互斥锁。

信号量 (Semaphore): 是数量相同的空闲厕所钥匙。例如，有 3 个具有相同锁和钥匙的厕所。信号量计数最初设置为 3，然后随着人们获取厕所钥匙而递减。如果所有厕所都已满，即没有空闲钥匙了，则信号量计数为 0。现在，当一个人离开厕所时，信号量会增加到 1（一把空闲钥匙），并交给队列中的下一个人。

ConcurrencyManagement.java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
public class  ConcurrencyManagement{ 
    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(10);
        Semaphore semaphore = new Semaphore(3);
        Runnable longRunningTask = () -> {
            boolean permit = false;
            try {
                permit = semaphore.tryAcquire(6, TimeUnit.SECONDS);
                if (permit) {
                    System.out.println("Semaphore is acquired");
                    TimeUnit.SECONDS.sleep(3);
                } else {
                    System.out.println("Could not acquire semaphore");
                }
            } catch (InterruptedException e) {
                throw new IllegalStateException(e);
            } finally {
                if (permit) {
                    semaphore.release();
                }
            }
        };
        IntStream.range(0, 10).forEach(i -> executor.submit(longRunningTask));
        //Some other code as it keeps running 
        //executor.shutdown();
    }
}

输出

Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Semaphore is acquired
Could not acquire semaphore

场景 5：外部化业务规则

我们被要求设计一个应用程序，该应用程序使用 100 多条规则来验证数据，以符合政府合规性要求和税法。这些合规性要求可能会发生变化，并且应用程序需要能够快速轻松地适应不断变化的要求。

解决方案

利用规则引擎（如 Drools）的力量。Drools 是一个流行的开源业务规则和工作流引擎。它有助于将规则外部化到数据库表或 Excel 电子表格中，而不是嵌入到 Java 代码中。规则以“当给定（$ condition）时执行（$ consequence）”的形式执行。业务部门将是这些规则的保管者，这些规则可以很容易地在 Excel 电子表格中查看或通过查询数据库表来查看。可以构建一个 GUI 来维护这些存在于数据库中的规则。

场景 6：审计

我们需要维护对“客户”表的插入、修改和删除的历史记录。您将如何完成这项工作？

解决方案

创建一个 ETL（即提取、转换和加载）批处理作业，该作业定期将所有更改提取到批处理文件中，并将这些文件发送到数据仓库系统，该系统将这些批处理文件加载到 SCD Type 2 历史表中。SCD Type 2 意味着维护每次更改。这在 13 个数据仓库面试问答 - Fact vs Dimension, CDC, SCD 等中有详细讨论。
通过发布/订阅模式进行异步处理。将每个更改作为事件发布到消息导向中间件，如 Apache Kafka、Rabbit MQ、Websphere MQ 等，独立的订阅者应用程序会将每个事件保存到 SQL 或 NoSQL 历史表中。
创建数据库表触发器，将已过期的记录插入到单独的历史表中。数据库触发器是过程代码，它在特定表或视图上发生插入、更新等事件时自动执行。使用或编写触发器时必须小心，因为编写不正确或使用不当的触发器可能会严重影响数据库性能。

场景 6：学生成绩系统

有一个包含学生（姓名、成绩）的列表。我们需要找出成绩最高的女学生的姓名。

GradeSystem.java

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.NoSuchElementException;
class Student {
    private String name;
    private double grades;
    public Student(String name, double grades) {
        this.name = name;
        this.grades = grades;
    }
    public String getName() {
        return name;
    }
    public double getGrades() {
        return grades;
    }
}
public class GradeSystem {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Pawan", 99.0));
        students.add(new Student("Nishant", 82.0));
        students.add(new Student("Charlie", 82.5));
        students.add(new Student("Rob", 88.5));
        students.add(new Student("Daniel", 99.5));
        //else throw null
        Student studentWithHighestGrade1 = students.stream()
                .max(Comparator.comparingDouble(Student::getGrades))
                .orElse(null);        
        if (studentWithHighestGrade1 != null) {
            System.out.println("(First Method) Student with the highest grade:");
            System.out.println("Name: " + studentWithHighestGrade1.getName());
            System.out.println("Grade: " + studentWithHighestGrade1.getGrades());
        }else{
            System.out.println("No student found.");
        }
        //else throw NoSuchElementException
        Student studentWithHighestGrade2 = students.stream()
                .max(Comparator.comparingDouble(Student::getGrades))
                .orElseThrow(NoSuchElementException::new);         
        if (studentWithHighestGrade2 != null) {
            System.out.println("(Second Method) Student with the highest grade:");
            System.out.println("Name: " + studentWithHighestGrade2.getName());
            System.out.println("Grade: " + studentWithHighestGrade2.getGrades());
        }else{
            System.out.println("No student found.");
        }
    }
}

输出

(First Method) Student with the highest grade:
Name: Daniel
Grade: 99.5
(Second Method) Student with the highest grade:
Name: Daniel
Grade: 99.5

场景 7：数据转换

给定一个字符串列表，我们必须使用 Java 8 流将其转换为大写。

UpperCaseConverter.java

import java.util.*; 
import java.util.stream.Collectors;
public class UpperCaseConverter {
    public static void main(String[] args) {
        List<String> strings = Arrays.asList("java", "python", "react", "javascript");
        //method 1
        List<String> upperCaseString = strings.stream().map(String::toUpperCase).collect(Collectors.toList());
        System.out.println("Output 1:");
        System.out.println(upperCaseString);        
        //method2
        System.out.println("Output 2:");
        strings.stream().map(String::toUpperCase).collect(Collectors.toList()).
                                       forEach(System.out::println);
    }
}

输出

 [JAVA, PYTHON, REACT, JAVASCRIPT]

输出 2

JAVA
PYTHON
REACT
JAVASCRIPT

场景 8：数据过滤和排序

对于给定的元素列表，执行过滤和排序操作。编写一个 Java 8 程序来执行从列表中过滤掉奇数并将剩余的按升序排序等操作。

FilterOddNumberAndSort.java

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class FilterOddNumberAndSort {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1,34,22,13,55,4,3,87,11,22,12);
        System.out.println("Unsorted Unfiltered List = " + numbers);
        List<Integer> filteredAndSortedNumbers = numbers.stream()
                .filter(n -> n % 2 == 0).sorted()
                .collect(Collectors.toList());
        System.out.println("Sorted Filtered List = " + filteredAndSortedNumbers);
    }
}

输出

Unsorted Unfiltered List = [1, 34, 22, 13, 55, 4, 3, 87, 11, 22, 12]
Sorted Filtered List = [4, 12, 22, 22, 34]

场景 9：事务管理

对于给定的事务数据（付款人、收款人、金额），计算每个收款人收到的总金额。这里你必须使用 Java 8 的分组和求和概念。

TransactionAnalyzer.java

import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
class Transaction {
    private String payer;
    private String payee;
    private double amount;
    public Transaction(String payer, String payee, double amount) {
        this.payer = payer;
        this.payee = payee;
        this.amount = amount;
    }
    public String getPayer() {
        return payer;
    }
    public String getPayee() {
        return payee;
    }
    public double getAmount() {
        return amount;
    }
}
public class TransactionAnalyzer {
    public static void main(String[] args) {
        List<Transaction> transactions = Arrays.asList(
                new Transaction("Dom", "Mona", 120.0),
                new Transaction("Jhon", "Charlie", 150.0),
                new Transaction("Bob", "Reha", 210.0),
                new Transaction("Jhon", "Mona", 150.0)
        );
        // Method 1 using method reference
        Map<String, Double> totalAmountReceivedByPayee1 = transactions.stream()
                .collect(Collectors.groupingBy(Transaction::getPayee, Collectors.summingDouble(Transaction::getAmount)));
        System.out.println(totalAmountReceivedByPayee1);        
        // Method 2 using method reference
        Map<String, Double> totalAmountReceivedByPayee2 = transactions.stream()
                .collect(Collectors.groupingBy(t -> t.getPayee(), Collectors.summingDouble(t -> t.getAmount())));
        System.out.println(totalAmountReceivedByPayee2);        
    }
}

输出

{Mona=270.0, Charlie=150.0, Reha=210.0}
{Mona=270.0, Charlie=150.0, Reha=210.0}

场景 10：销售管理

在零售市场，不时会发生多笔交易。我们必须对收入进行数据分析。

对于给定的销售交易列表（transactionID、productID、quantity、price），我们必须找到最近 3 个月销售额排名前 N 的产品（按收入计算），使用 Java 8。

这里，N 是我们要购买的产品数量。

TopNProductsByRevenue.java

import java.time.LocalDate;
import java.util.*;
import java.util.stream.Collectors;
class Transaction {
    private String transactionID;
    private String productID;
    private int quantity;
    private double price;
    private LocalDate transactionDate;    
    public Transaction(){
    }
    public Transaction(String transactionID, String productID, int quantity, double price, LocalDate transactionDate){
        this.transactionID = transactionID;
        this.productID = productID;
        this.quantity = quantity;
        this.price = price;
        this.transactionDate = transactionDate;
    }
    public LocalDate getTransactionDate(){
        return transactionDate;
    }
    public String getTransactionID(){
        return transactionID;
    }
    public String getProductID(){
        return productID;
    }    
    public int getQuantity(){
        return quantity;
    }
    public double getPrice(){
        return price;
    }
}
public class TopNProductsByRevenue {
    public static void main(String[] args) {
        List<Transaction> salesTransactions = new ArrayList<>(); 
        salesTransactions.add(new Transaction("1","1",10,23.9,LocalDate.now()));
        salesTransactions.add(new Transaction("2","1",11,21.9,LocalDate.now()));
        salesTransactions.add(new Transaction("3","2",12,21.9,LocalDate.now()));
        salesTransactions.add(new Transaction("4","3",11,24.9,LocalDate.now()));
        salesTransactions.add(new Transaction("5","3",4,23.9,LocalDate.now()));
        salesTransactions.add(new Transaction("6","3",5,26.9,LocalDate.now()));
        salesTransactions.add(new Transaction("7","2",6,27.9,LocalDate.now()));
        salesTransactions.add(new Transaction("8","1",12,28.9,LocalDate.now()));       
        int N = 2; // Number of top products
        LocalDate threeMonthsAgo = LocalDate.now().minusMonths(3);
        Map<String, Double> productRevenueMap = salesTransactions.stream()
            .filter(transaction -> transaction.getTransactionDate().isAfter(threeMonthsAgo))
            .collect(Collectors.groupingBy(
                Transaction::getProductID,
                Collectors.summingDouble(transaction -> transaction.getPrice() * transaction.getQuantity())
            ));        
        List<Map.Entry<String, Double>> sortedProductsByRevenue = productRevenueMap.entrySet().stream()
            .sorted((entry1, entry2) -> entry2.getValue().compareTo(entry1.getValue()))
            .limit(N)
            .collect(Collectors.toList());
        System.out.println("Top " + N + " products by revenue in the last 3 months:");
        for (Map.Entry<String, Double> entry : sortedProductsByRevenue) {
            System.out.println("ProductID: " + entry.getKey() + ", Revenue: " + entry.getValue());
        }
    }
}

输出

Top 2 products by revenue in the last 3 months:
ProductID: 1, Revenue: 826.6999999999999
ProductID: 3, Revenue: 504.0

场景 12：员工管理系统

给定员工详细信息，我们必须根据员工姓名使用 Java 8 对员工详细信息进行排序。

EmployeeSorting.java

import java.util.ArrayList;
import java.util.List;
import java.util.Comparator;
import java.util.stream.Collectors;
class Employee {
    private int id;
    private String name;
    private int age;
    public Employee(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
}
public class EmployeeSorting {
    public static void main(String[] args) {
        List<Employee> employees = new ArrayList<>();
        employees.add(new Employee(1, "Mohan", 30));
        employees.add(new Employee(2, "Sohan", 25));
        employees.add(new Employee(3, "Rohan", 28));
        // Sorting employee based on names using Java 8 streams
        List<Employee> sortedEmployees = employees.stream()
                .sorted(Comparator.comparing(Employee::getName))
                .collect(Collectors.toList());
        // Printing sorted employee details
        sortedEmployees.forEach(s->System.out.println(s.getName()));
    }
}

输出

Mohan
Rohan
Sohan

下一主题了解 Java 中的静态同步

Java 中的场景题

场景 1：缓存

解决方案

场景 2：异步处理

解决方案

场景 3：正则表达式

解决方案

场景 4：并发管理

解决方案

场景 5：外部化业务规则

解决方案

场景 6：审计

解决方案

场景 6：学生成绩系统

场景 7：数据转换

场景 8：数据过滤和排序

场景 9：事务管理

场景 10：销售管理

场景 12：员工管理系统

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中的场景题

场景 1：缓存

解决方案

场景 2：异步处理

解决方案

场景 3：正则表达式

解决方案

场景 4：并发管理

解决方案

场景 5：外部化业务规则

解决方案

场景 6：审计

解决方案

场景 6：学生成绩系统

场景 7：数据转换

场景 8：数据过滤和排序

场景 9：事务管理

场景 10：销售管理

场景 12：员工管理系统

相关帖子

Java 中的“是”关系是什么

How to Clear Screen in Java

Java 中的动态变量

Difference between Error and Exception in Java

Java 启动时返回退出码 1

Java Program to Find Maximum Difference of Zeros and Ones in Binary String

Ramanujan Number or Taxicab Number in Java

Java 21 中的 Generational ZCG

Print Adjacency List for a Directed Graph in Java

Java 中构造函数重载和方法重载的区别

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器