WikiGalaxy
Chaining Methods: StringBuilder
Understanding StringBuilder Chaining:
StringBuilder allows for efficient string manipulation. Using method chaining, you can perform multiple operations in a single statement.
Example: Appending and Reversing Strings
In this example, we'll append strings and then reverse the final result using method chaining.
public class StringBuilderExample {
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World").reverse();
System.out.println(sb.toString());
}
}
Console Output:
dlroW olleH
Chaining Methods: Java Streams
Utilizing Java Streams:
Java Streams provide a powerful way to process collections of objects. Method chaining is often used to filter, map, and collect data in a streamlined manner.
Example: Filtering and Mapping
We'll filter a list of numbers to get even numbers and then square each number using method chaining.
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class StreamExample {
public static void main(String[] args) {
List numbers = Arrays.asList(1, 2, 3, 4, 5, 6);
List result = numbers.stream()
.filter(n -> n % 2 == 0)
.map(n -> n * n)
.collect(Collectors.toList());
System.out.println(result);
}
}
Console Output:
[4, 16, 36]
Chaining Methods: Optional
Working with Optional:
The Optional class is a container object which may or may not contain a non-null value. Method chaining with Optional can help avoid null checks.
Example: Using map and orElse
We will use method chaining to transform the value and provide a default if it's absent.
import java.util.Optional;
public class OptionalExample {
public static void main(String[] args) {
Optional optionalValue = Optional.of("Hello");
String result = optionalValue.map(String::toUpperCase)
.orElse("Default");
System.out.println(result);
}
}
Console Output:
HELLO
Chaining Methods: Fluent Interface
Implementing Fluent Interface:
A fluent interface provides a way to chain method calls to improve readability and flow of code.
Example: Building a Query
We'll demonstrate a simple query builder using a fluent interface pattern.
public class QueryBuilder {
private StringBuilder query;
public QueryBuilder() {
query = new StringBuilder();
}
public QueryBuilder select(String fields) {
query.append("SELECT ").append(fields).append(" ");
return this;
}
public QueryBuilder from(String table) {
query.append("FROM ").append(table).append(" ");
return this;
}
public QueryBuilder where(String condition) {
query.append("WHERE ").append(condition).append(" ");
return this;
}
public String build() {
return query.toString();
}
public static void main(String[] args) {
String sqlQuery = new QueryBuilder()
.select("*")
.from("users")
.where("age > 18")
.build();
System.out.println(sqlQuery);
}
}
Console Output:
SELECT * FROM users WHERE age > 18
Chaining Methods: Builder Pattern
Utilizing the Builder Pattern:
The Builder Pattern is used to construct a complex object step by step. Method chaining enhances readability and usability.
Example: Building a Car Object
We'll create a Car object using the Builder Pattern with method chaining.
public class Car {
private String color;
private String engine;
private int seats;
public static class Builder {
private String color;
private String engine;
private int seats;
public Builder setColor(String color) {
this.color = color;
return this;
}
public Builder setEngine(String engine) {
this.engine = engine;
return this;
}
public Builder setSeats(int seats) {
this.seats = seats;
return this;
}
public Car build() {
Car car = new Car();
car.color = this.color;
car.engine = this.engine;
car.seats = this.seats;
return car;
}
}
@Override
public String toString() {
return "Car [color=" + color + ", engine=" + engine + ", seats=" + seats + "]";
}
public static void main(String[] args) {
Car car = new Car.Builder()
.setColor("Red")
.setEngine("V8")
.setSeats(4)
.build();
System.out.println(car);
}
}
Console Output:
Car [color=Red, engine=V8, seats=4]
