Top Java Quiz Questions ☕️

   class MyCustomError(Exception):
       pass
   

   def risky_operation():
       raise MyCustomError("Something went wrong!")
   

   try:
       risky_operation()
   except MyCustomError as e:
       print(f"Caught an error: {e}")
   

interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer {
    @Override
    public void update(String message) {
        System.out.println("Received message: " + message);
    }
}

class ConcreteSubject {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.10</version>
</dependency>

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

  List<String> myList = myStream.collect(Collectors.toList());
  

  Map<Integer, String> myMap = myStream.collect(Collectors.toMap(String::length, Function.identity()));
  

  List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
  Stream<String> nameStream = names.stream();
  

  List<String> filteredNames = names.stream()
                                    .filter(name -> name.startsWith("A"))
                                    .collect(Collectors.toList());
  

DynamoDbEnhancedClient enhancedClient = DynamoDbEnhancedClient.create();
DynamoDbTable<YourItemClass> table = enhancedClient.table("YourTableName", TableSchema.fromBean(YourItemClass.class));

QueryConditional query = QueryConditional.keyEqualTo(Key.builder().partitionValue("yourHashKeyValue").sortValue("yourSortKeyValue").build());

Page<YourItemClass> result = table.query(query);

def greet(name: str) -> str:
    return f'Hello, {name}!'

from typing import Optional

def find_item(index: int) -> Optional[str]:
    return items[index] if index < len(items) else None

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "Diana");
List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .collect(Collectors.toList());

def count_up_to(max):
    count = 1
    while count <= max:
        yield count
        count += 1

counter = count_up_to(5)
for number in counter:
    print(number)

1
2
3
4
5

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyServiceTests {

    @Autowired
    private MyService myService;

    @Test
    public void testServiceMethod() {
        assertEquals("Expected Output", myService.serviceMethod());
    }
}

public class RequestHandler implements Runnable {
    @Override
    public void run() {
        // Handle the request
    }
}

  String regex = "^-?\\d+(\\.\\d+)?$";
  

  Pattern pattern = Pattern.compile(regex);
  Matcher matcher = pattern.matcher(expression);
  
  if (matcher.matches()) {
      // The expression is valid
  } else {
      // Invalid expression
  }
  

   class Product:
       def use(self):
           pass
   

   class ConcreteProductA(Product):
       def use(self):
           return "Using Product A"

   class ConcreteProductB(Product):
       def use(self):
           return "Using Product B"
   

   class Factory:
       @staticmethod
       def create_product(product_type):
           if product_type == 'A':
               return ConcreteProductA()
           elif product_type == 'B':
               return ConcreteProductB()
           else:
               raise ValueError("Unknown product type")
   

   product = Factory.create_product('A')
   print(product.use())  # Output: Using Product A
   

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class FileCounter {
    public static void main(String[] args) {
        try {
            long count = Files.walk(Paths.get("your/directory/path"))
                    .filter(Files::isRegularFile)
                    .count();

            System.out.println("Total files: " + count);
        } catch (IOException e) {
            System.err.println("An error occurred: " + e.getMessage());
        }
    }
}

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");

List<String> filteredNames = names.stream()
                                  .filter(name -> name.startsWith("A"))
                                  .collect(Collectors.toList());

   FileInputStream fis = new FileInputStream("file.txt");
   int data = fis.read();
   

   FileOutputStream fos = new FileOutputStream("file.txt");
   fos.write(data);
   

   <dependency>
       <groupId>com.ibm.db2</groupId>
       <artifactId>jcc</artifactId>
       <version>your-version-here</version>
   </dependency>
   

   spring.datasource.url=jdbc:db2://localhost:50000/YOUR_DB
   spring.datasource.username=YOUR_USER
   spring.datasource.password=YOUR_PASSWORD
   spring.datasource.driver-class-name=com.ibm.db2.jcc.DB2Driver
   

   @Entity
   public class User {
       @Id
       @GeneratedValue(strategy = GenerationType.IDENTITY)
       private Long id;
       private String name;
   }