The ‘break’ statement in Java is used to terminate the execution of a loop prematurely. When encountered inside a loop (such as ‘for’, ‘while’, or ‘do-while’), the ‘break’ statement immediately exits the loop and continues executing the code after the loop. It effectively jumps out of the loop’s block, bypassing any remaining iterations.

1. for Loop:
“`java
for (int i = 0; i < 5; i++) {
if (i == 3) {
break; // Exit the loop when i equals 3
}
System.out.println(i);
}
“`

2. while Loop:
“`java
int i = 0;
while (i < 5) {
if (i == 3) {
break; // Exit the loop when i equals 3
}
System.out.println(i);
i++;
}
“`

3. do-while Loop:
“`java
int i = 0;
do {
if (i == 3) {
break; // Exit the loop when i equals 3
}
System.out.println(i);
i++;
} while (i < 5);
“`

Wrapper classes in Java are classes that encapsulate primitive data types and provide utility methods for working with them as objects. They allow primitive data types to be used in contexts that require objects, such as collections, generics, and methods that operate on objects.

1. Integer: Encapsulates the int data type.
“`java
Integer intWrapper = Integer.valueOf(10); // Creating an Integer object
int intValue = intWrapper.intValue(); // Extracting the int value
“`

2. Long: Encapsulates the long data type.
“`java
Long longWrapper = Long.valueOf(100L); // Creating a Long object
long longValue = longWrapper.longValue(); // Extracting the long value
“`

3. Float: Encapsulates the float data type.
“`java
Float floatWrapper = Float.valueOf(3.14f); // Creating a Float object
float floatValue = floatWrapper.floatValue(); // Extracting the float value
“`

4. Double: Encapsulates the double data type.
“`java
Double doubleWrapper = Double.valueOf(3.14159); // Creating a Double object
double doubleValue = doubleWrapper.doubleValue(); // Extracting the double value
“`

5. Byte: Encapsulates the byte data type.
“`java
Byte byteWrapper = Byte.valueOf((byte) 127); // Creating a Byte object
byte byteValue = byteWrapper.byteValue(); // Extracting the byte value
“`

6. Short: Encapsulates the short data type.
“`java
Short shortWrapper = Short.valueOf((short) 1000); // Creating a Short object
short shortValue = shortWrapper.shortValue(); // Extracting the short value
“`

7. Character: Encapsulates the char data type.
“`java
Character charWrapper = Character.valueOf(‘A’); // Creating a Character object
char charValue = charWrapper.charValue(); // Extracting the char value
“`

8. Boolean: Encapsulates the boolean data type.
“`java
Boolean booleanWrapper = Boolean.valueOf(true); // Creating a Boolean object
boolean booleanValue = booleanWrapper.booleanValue(); // Extracting the boolean value
“`

1. Thread Safety:
– StringBuffer is thread-safe, meaning it ensures that multiple threads can safely access and modify its contents without interference. This is achieved by synchronizing access to its methods, which introduces a performance overhead.
– StringBuilder, on the other hand, is not thread-safe. It does not provide any synchronization mechanisms, making it faster but unsuitable for concurrent access from multiple threads.

2. Performance:
– StringBuffer has slightly slower performance compared to StringBuilder due to the overhead of synchronization. This makes it preferable for scenarios where thread safety is required, such as in multi-threaded environments.
– StringBuilder is faster because it does not incur the synchronization overhead of StringBuffer. It is suitable for use in single-threaded or non-concurrent environments where maximum performance is desired.

The ‘enum’ keyword in Java is used to declare an enumerated (or enumerated type) type, which represents a fixed set of named constants. Enums provide a way to define a group of related constants in a more organized and type-safe manner.

The main purpose of the ‘enum’ keyword is to improve code readability, maintainability, and type safety by allowing developers to define a clear and concise list of allowed values for a particular data type. Enums make code more self-documenting and reduce the likelihood of errors caused by using incorrect or invalid values.

Enums can also be used to represent finite sets of related values, such as days of the week, months of the year, or states of an object. They can have methods, constructors, and fields just like regular classes, allowing for additional functionality to be associated with each constant.