Scenario Based Questions in Java

Scenario 1: Caching

You need to load stock exchange security codes with price from a database and cache them for performance. The security codes need to be refreshed say every 30 minutes. This cached data needs to be populated and refreshed by a single writer thread and read by several reader threads. How will you ensure that your read/write solution is scalable and thread safe?

Solution

The java.util.concurrent.locks package provides classes that implement read/write locks where the read lock can be executed in parallel by multiple threads and the write lock can be held by only a single thread. The ReadWriteLock interface maintains a pair of associated locks, one for read-only and one for writing. The readLock( ) may be held simultaneously by multiple reader threads, while the writeLock( ) is exclusive. In general, this implementation improves performance and scalability when compared to the mutex locks (i.e. via synchronized key word) when

When There Are More Read Operations and The Duration of Each Read Is Longer Compared to Write Operations and Their Duration.
The Performance Also Depends on The Machine You Are Running the Code On, Especially If It Has Multi-Core Processors, As It Allows for Better Parallelism.

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();
    }
}

Output:

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

Scenario 2: Asynchronous Processing

If you have a requirement to generate online reports or feed files by pulling out millions of historical records from a database, what questions will you ask, and how will you go about designing it?

Solution:

Designing a system is all about asking the right questions to gather requirements.

Online Vs Offline? Should we restrict the online reports for only last 12 months of data to minimise the report size and to get better performance, and provide reports/feeds for the data older than 12 months via offline processing? For example, Bank statements for last 12 months via online & for transactions older than 12 months via offline asynchronous processing without blocking the customer from browsing rest of the website. Reports can be generated asynchronously and once ready can be emailed or downloaded via a URL at a later time.

What report generation framework to use like Jasper Reports, Open CSV, XSL-FO with Apache FOP, etc depending on the required output formats?

How to handle exceptional scenarios? send an error email, use a monitoring system like Tivoli or Nagios to raise production support tickets on failures, etc?

Security requirements. Are we sending feed/report with PII (i.e. Personally Identifiable Information) data via email? Do we need proper access control to restrict who can generate which online reports? Should we password protect the email attachments? Are there any compliance or regulatory requirements like PCI (i.e. Payment Card Industry), GDPR (i.e. General Data Protection Regulation), ACCC (i.e. Australian Competition and Consumer Commission), etc depending on the jurisdictions served by the application?

Should we schedule the offline reports to run during off peak time? For example, enter all the requests for a report into a "Request" table and then schedule a process to run at say midnight to refer to all pending requests in the "Request" table to generate and store the relevant reports in an outbox for the customers to download. An email can be sent to clients with the report URL to download the report.

Archival and purging straggles of the historical reports. What is the report retention period for the requirements relating to auditing and compliance purpose? How big are the files?

An online application with a requirement to produce time consuming reports or a business process (e.g. re-balancing accounts, aggregating hierarchical information, etc) could benefit from making these long running operations asynchronous. Once the reports or the long running business process is completed, the outcome can be communicated to the user via emails or asynchronously refreshing the web page via techniques known as "server push (JEE Async Servlet)" or "client pull (Refresh meta tag)". A typical example would be

A user makes an online request for an aggregate report or a business process like re-balancing his/her portfolios.
The user request will be saved to a database table for a separate process to periodically pick it up and process it asynchronously.
The user could now continue to perform other functionality of the website without being blocked.
A separate process running on the same machine or different machine can periodically scan the table for any entries and produce the necessary reports or execute the relevant business process. This could be a scheduled job that runs once during off-peak or every 10 minutes. This depends on the business requirement.
Once the report or the process is completed, notify the user via emails or making the report available online to be downloaded.

Scenario 3: Regular Expression

We need to find and change a text from 'Client' to 'Customer' in 350+ html files.

Solution

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.");
    }
}

Output:

All HTML files have been updated.

Scenario 4: Concurrency Management

Reference counting where a shared resource is incremented or decremented. The increment/decrement operations must be thread safe. For example, a counter that keeps track of the number of active logged in users by incrementing the count when users log in and decrementing the count when the users log out. Sometimes you want to allow a finite number of concurrent accesses say 3 users at a time.

Solution:

Mutex: is a single key to an object (E.g. a toilet). One person can have the key and occupy the toilet at the time. When finished, the person gives (or releases) the key to the next person in the queue. In Java, every object has a mutex and only a single thread can get hold of a mutex.

Semaphore: Is a number of free identical toilet keys. For example, having 3 toilets with identical locks and keys. The semaphore count is set to 3 at beginning and then the count is decremented as people are acquiring the key to the toilets. If all toilets are full, i.e. there are no free keys left, the semaphore count is 0. Now, when one person leaves the toilet, semaphore is increased to 1 (one free key), and given to the next person in the queue.

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();
    }
}

Output:

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

Scenario 5: Externalize Business Rules

We are asked to design an application, which validates data with 100+ rules to comply with the government compliance requirements and tax laws. These compliance requirements can change and the application need to quickly and easily adapt to changing requirements.

Solution:

Harness the power of Rules Engines like Drools. Drools is a popular open source business rules and work flow engine. It helps you externalise the rules in database tables or excel spreadsheets as opposed to embedding within the Java code. The rules are executed in the form of when given a ($condition) then execute the ($consequence). The business will be the custodian of these rules that can be easily viewed on an excel spreadsheet or via querying the database tables. A GUI could be built to maintain these rules that reside in a database.

Scenario 6: Auditing

We have a requirement to maintain a history of insertion, modification, and deletion to the "Customer" table. How will you go about accomplishing this?

Solution:

Create an ETL (i.e. Extract Transform & Load) batch job that periodically extracts all the changes to batch files and send those files to a Data warehouse system, which loads these batch files to a SCD Type 2 history table. SCD Type 2 means maintain each change. This is discussed in detail at 13 Data Warehouse interview Q&As - Fact Vs Dimension, CDC, SCD, etc.
Asynchronously via publish & subscription paradigm. Publish each change as an event to a message oriented middle-ware like Apache Kafka, Rabbit MQ, Websphere MQ, etc & separate subscriber application will save each event to a SQL or NoSQL history table.
Create database table triggers to insert superseded records to a separate history table. A database trigger is procedural code that is automatically executed in response to certain events like insert, update, etc on a particular table or view in a database. Care must be taken in using or writing triggers as incorrectly written or used triggers can significantly impact performance of your database.

Scenario 6: Student Grades System

There is a list of students with their (name, grades). We have to find the name of the student who has the highest grade.

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.");
        }
    }
}

Output:

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

Scenario 7: Data Transformation

We have Given a list of strings and we have to convert them to uppercase using Java 8 streams.

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);
    }
}

Output:

 [JAVA, PYTHON, REACT, JAVASCRIPT]

Output 2:

JAVA
PYTHON
REACT
JAVASCRIPT

Scenario 8: Filtering and Sorting on Data

For the given list of elements, perform Filtering and Sorting on the elements. Write a Java 8 program to perform operations like filter out the odd numbers from list and sort the remaining ones in ascending order.

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);
    }
}

Output:

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

Scenario 9: Transaction Management

For the given transaction data with (payer, payee, amount), calculate the total amount received by each payee. Here you have to use the grouping and Summing concept of 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);        
    }
}

Output:

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

Scenario 10: Sales Management

In the retail marketplace, there are multiple transactions that happen from time to time. We have to perform the data analysis over the revenue.

For the Given list of sales transactions (transactionID, productID, quantity, price), we have to find the top N products (by revenue) sold in the last 3 months using Java 8.

Here, N is the number of products that we want.

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());
        }
    }
}

Output:

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

Scenario 12: Employee Management System

Given Employee details, we have to sort the employee details on basis of employee's name using 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()));
    }
}

Output: