10 Java Written Test Interview Questions and Answers

Java remains a cornerstone in the world of programming, known for its portability, robustness, and extensive use in enterprise environments. Its platform-independent nature and strong community support make it a preferred choice for developing large-scale applications, web services, and Android apps. Java’s object-oriented principles and comprehensive standard libraries provide a solid foundation for building scalable and maintainable software solutions.

This article offers a curated selection of questions and answers designed to help you prepare for a Java written test. By familiarizing yourself with these questions, you can enhance your understanding of key Java concepts and improve your problem-solving skills, ensuring you are well-prepared for your upcoming interview.

Java Written Test Interview Questions and Answers

1. Write a simple Java program that demonstrates the use of a for loop to print numbers from 1 to 10.

To demonstrate the use of a for loop in Java, you can write a simple program that prints numbers from 1 to 10. The for loop is a control flow statement that allows code to be executed repeatedly based on a given boolean condition. Here is a basic example:

public class Main {
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            System.out.println(i);
        }
    }
}

In this example, the for loop initializes the variable i to 1, checks if i is less than or equal to 10, and increments i by 1 after each iteration. The System.out.println(i); statement inside the loop prints the current value of i to the console.

2. Implement a Java program that uses an ArrayList to store and retrieve a list of strings.

To implement a Java program that uses an ArrayList to store and retrieve a list of strings, you can follow these steps:

1. Import the ArrayList class.
2. Create an instance of ArrayList.
3. Add strings to the ArrayList.
4. Retrieve and iterate over the strings.

Here is a concise example:

import java.util.ArrayList;

public class StringListExample {
    public static void main(String[] args) {
        ArrayList<String> stringList = new ArrayList<>();

        stringList.add("Hello");
        stringList.add("World");
        stringList.add("Java");

        for (String str : stringList) {
            System.out.println(str);
        }
    }
}

3. Write a generic method in Java that takes an array of any type and prints its elements.

Generics in Java enable methods and classes to operate on objects of various types while providing compile-time type safety. This is useful for creating methods that can handle different data types without the need for multiple method overloads.

Here is a simple example of a generic method that takes an array of any type and prints its elements:

public class GenericPrinter {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }

    public static void main(String[] args) {
        Integer[] intArray = {1, 2, 3, 4, 5};
        String[] strArray = {"Hello", "World"};

        printArray(intArray);
        printArray(strArray);
    }
}

4. Write a Java program that uses a lambda expression to sort a list of integers in descending order.

Lambda expressions in Java provide a concise way to represent one method interface using an expression. They simplify the implementation of functional interfaces, such as the Comparator interface, which is commonly used for sorting collections.

To sort a list of integers in descending order using a lambda expression, you can use the sort method from the Collections class or the List interface, along with a lambda expression that defines the sorting logic.

import java.util.Arrays;
import java.util.List;

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

        numbers.sort((a, b) -> b - a);

        System.out.println(numbers);
    }
}

In this example, the lambda expression (a, b) -> b - a is used to define the sorting logic. The sort method sorts the list in place, and the lambda expression specifies that the list should be sorted in descending order by subtracting a from b.

5. Implement a Java program that uses the Stream API to filter and collect even numbers from a list of integers.

To filter and collect even numbers from a list of integers using the Stream API in Java, you can utilize the filter and collect methods. The filter method allows you to specify a condition (in this case, checking if a number is even), and the collect method gathers the filtered elements into a new list.

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

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

        List<Integer> evenNumbers = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .collect(Collectors.toList());

        System.out.println(evenNumbers);
    }
}

6. Describe the Singleton design pattern and write a Java implementation of it.

The Singleton design pattern restricts the instantiation of a class to one instance. This is useful when exactly one object is needed to coordinate actions across the system. The Singleton pattern is often used in scenarios where a single point of control is required, such as in logging, configuration settings, or managing a connection to a database.

Here is a simple implementation of the Singleton pattern in Java:

public class Singleton {
    private static Singleton singleInstance = null;

    private Singleton() {}

    public static Singleton getInstance() {
        if (singleInstance == null) {
            singleInstance = new Singleton();
        }
        return singleInstance;
    }
}

7. Implement a Java program that reads a text file line by line and prints each line to the console.

To implement a Java program that reads a text file line by line and prints each line to the console, you can use the BufferedReader class along with FileReader. This approach ensures efficient reading of the file.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class FilePrinter {
    public static void main(String[] args) {
        String fileName = "example.txt"; // Replace with your file path

        try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

8. Write a Java program that establishes a socket connection to a server and sends a simple message.

To establish a socket connection to a server and send a simple message in Java, you can use the Socket class from the java.net package. This class provides a client-side TCP socket. Below is an example of how to achieve this:

import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class SimpleSocketClient {
    public static void main(String[] args) {
        String serverAddress = "localhost";
        int port = 12345;
        String message = "Hello, Server!";

        try (Socket socket = new Socket(serverAddress, port);
             OutputStream outputStream = socket.getOutputStream();
             PrintWriter writer = new PrintWriter(outputStream, true)) {
            
            writer.println(message);
            System.out.println("Message sent to the server: " + message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

9. Describe the Java Collections Framework and explain the differences between ArrayList, LinkedList, HashSet, and TreeSet.

The Java Collections Framework provides a set of interfaces and classes to handle collections of objects. The main interfaces include List, Set, Queue, and Map. Each of these interfaces has multiple implementations, each with its own characteristics and use cases.

• ArrayList
  • Implements the List interface.
  • Uses a dynamic array to store elements.
  • Provides fast random access (O(1) time complexity).
  • Insertion and deletion operations can be slow (O(n) time complexity) as they may require shifting elements.
• LinkedList
  • Implements the List and Deque interfaces.
  • Uses a doubly linked list to store elements.
  • Provides fast insertion and deletion (O(1) time complexity) as it only requires updating pointers.
  • Random access is slow (O(n) time complexity) as it requires traversing the list.
• HashSet
  • Implements the Set interface.
  • Uses a hash table to store elements.
  • Provides fast insertion, deletion, and lookup (O(1) time complexity).
  • Does not maintain any order of elements.
• TreeSet
  • Implements the NavigableSet interface.
  • Uses a Red-Black tree to store elements.
  • Provides fast insertion, deletion, and lookup (O(log n) time complexity).
  • Maintains elements in sorted order.

10. Explain the concepts of functional programming in Java and provide examples using lambdas and streams.

Functional programming in Java focuses on using functions as first-class citizens, meaning functions can be passed as arguments, returned from other functions, and assigned to variables. This paradigm emphasizes immutability and the use of pure functions, which do not have side effects.

Java 8 introduced lambdas and streams to facilitate functional programming. Lambdas provide a concise way to represent instances of single-method interfaces (functional interfaces). Streams provide a powerful way to process sequences of elements in a functional style.

Example using lambdas and streams:

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

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

        List<Integer> evenSquares = numbers.stream()
                                           .filter(n -> n % 2 == 0)
                                           .map(n -> n * n)
                                           .collect(Collectors.toList());

        System.out.println(evenSquares); // Output: [4, 16, 36]
    }
}

In this example, the filter method uses a lambda expression to select even numbers, and the map method uses another lambda to square each selected number. The collect method then gathers the results into a list.