Java 8 introduced numerous significant features that changed the way Java developers write code.
1. Lambda Expressions
Lambda expressions provide a clear and concise way to represent anonymous functions. They eliminate the need for boilerplate code when implementing functional interfaces.
Example:
import java.util.*;
public class LambdaExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("John", "Mary", "Peter", "Alice");
// Using lambda expression to sort the list
names.sort((s1, s2) -> s1.compareToIgnoreCase(s2));
System.out.println(names);
}
}
2. Functional Interfaces and @FunctionalInterface Annotation
A functional interface is an interface with exactly one abstract method, used as a type for lambda expressions.
Example:
@FunctionalInterface
interface MathOperation {
int operate(int a, int b);
}
public class FunctionalInterfaceExample {
public static void main(String[] args) {
MathOperation addition = (a, b) -> a + b;
System.out.println("Sum: " + addition.operate(5, 3));
}
}
3. Default and Static Methods in Interfaces
Interfaces can now contain default and static methods with implementations.
Example:
interface Vehicle {
default void print() {
System.out.println("This is a vehicle");
}
static void soundHorn() {
System.out.println("Honking...");
}
}
class Car implements Vehicle {
// Inherits default method
}
public class DefaultStaticMethodExample {
public static void main(String[] args) {
Vehicle car = new Car();
car.print();
Vehicle.soundHorn();
}
}
4. Streams API
The Streams API allows functional-style operations on collections.
Example:
import java.util.*;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");
// Filter names starting with 'A' and collect to a list
List<String> filteredNames = names.stream()
.filter(name -> name.startsWith("A"))
.collect(Collectors.toList());
System.out.println(filteredNames);
}
}
5. Method References
Method references provide a shorthand notation for calling methods.
Example:
import java.util.*;
public class MethodReferenceExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("John", "Jane", "Alex");
// Using method reference
names.forEach(System.out::println);
}
}
6. Optional Class
The Optional class helps avoid NullPointerException by wrapping values that may be null.
Example:
import java.util.Optional;
public class OptionalExample {
public static void main(String[] args) {
Optional<String> optionalValue = Optional.ofNullable(null);
// Provide a default value if null
String result = optionalValue.orElse("Default Value");
System.out.println(result);
}
}
7. New Date and Time API (java.time package)
Java 8 introduced a modern java.time API to replace the legacy java.util.Date and java.util.Calendar.
Collectors are used to accumulate elements of a stream into a collection.
Example:
import java.util.*;
import java.util.stream.Collectors;
public class CollectorsExample {
public static void main(String[] args) {
List<String> names = Arrays.asList("John", "Jane", "Alex", "Emma");
// Collect names into a comma-separated string
String result = names.stream()
.collect(Collectors.joining(", "));
System.out.println(result);
}
}
9. forEach() Method in Iterable
Java 8 introduced the forEach method for Iterable to iterate through collections.
Example:
import java.util.*;
public class ForEachExample {
public static void main(String[] args) {
List<String> items = Arrays.asList("Apple", "Banana", "Cherry");
items.forEach(item -> System.out.println(item));
}
}
10. computeIfAbsent() and computeIfPresent() in Map
Java 8 enhanced the Map interface with new methods.
Example:
map.computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)
If the specified key is not already associated with a value, this method computes a value using the given mapping function and inserts it into the map.
If the key is already present, it does nothing and returns the existing value.
Useful for lazy initialization of values in a map.
map.computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction)
If the specified key is already associated with a value, this method computes a new value using the given remapping function and updates the map.
If the function returns null, the key is removed from the map.
If the key is not present, it does nothing.
Useful for modifying existing values in a map without checking for null manually.
import java.util.*;
public class MapEnhancements {
public static void main(String[] args) {
Map<String, Integer> map = new HashMap<>();
map.put("A", 5);
map.computeIfAbsent("B", key -> 10);
map.computeIfPresent("A", (key, val) -> val * 2);
System.out.println(map);
}
}
map.computeIfAbsent("B", key -> 10);
Checks if the key "B" exists in the map.
If not present, it computes a value using the lambda function key -> 10 and puts "B" with the computed value 10 into the map.
If already present, it does nothing and keeps the existing value.
map.computeIfPresent("A", (key, val) -> val * 2);
Checks if the key "A" exists in the map.
If present, it applies the function (key, val) -> val * 2, which doubles the value of "A".
If not present, it does nothing.
11. String Joiner (java.util.StringJoiner)
The StringJoiner class is used for efficient string concatenation.
Example:
import java.util.StringJoiner;
public class StringJoinerExample {
public static void main(String[] args) {
StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("Apple").add("Banana").add("Cherry");
System.out.println(joiner.toString());
}
}
12. Base64 Encoding and Decoding
Java 8 introduced Base64 encoding and decoding.
Example:
import java.util.Base64;
public class Base64Example {
public static void main(String[] args) {
String originalString = "HelloWorld";
String encoded = Base64.getEncoder().encodeToString(originalString.getBytes());
String decoded = new String(Base64.getDecoder().decode(encoded));
System.out.println("Encoded: " + encoded);
System.out.println("Decoded: " + decoded);
}
}
13. Arrays.parallelSort()
Java 8 introduced parallelSort() to sort arrays in parallel.
Example:
import java.util.Arrays;
public class ParallelSortExample {
public static void main(String[] args) {
int[] numbers = {5, 3, 8, 1, 2};
Arrays.parallelSort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
