Strategy pattern Comparator in Java SDK
The Strategy pattern is a behavior mode that allows Selection algorithm or behaviors according to different policies. In the Java SDK, we can use the Comparator interface to implement the Strategy pattern.
The Comparator interface defines a method, compare (Object o1, Object o2), to compare the sizes of two objects. Its implementation class can determine the order of objects based on different strategies. For example, the order of objects can be determined by comparing a certain property of the object or using custom comparison logic.
The following is an example framework of Comparator based Strategy pattern:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
//Policy interface
interface SortingStrategy {
void sort(List<Integer> list);
}
//Strategy 1: Sort in natural order
class NaturalOrderSortingStrategy implements SortingStrategy {
@Override
public void sort(List<Integer> list) {
Collections. sort (list)// Natural sorting using the Java SDK
}
}
//Strategy 2: Sort in reverse order
class ReverseOrderSortingStrategy implements SortingStrategy {
@Override
public void sort(List<Integer> list) {
Collections. sort (list, Collections. reverseOrder())// Reverse sorting using the Java SDK
}
}
//Context class for using policies
class Sorter {
private SortingStrategy strategy;
public void setStrategy(SortingStrategy strategy) {
this.strategy = strategy;
}
public void sortList(List<Integer> list) {
Strategy. sort (list)// Sort using specific strategies
}
}
public class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(10);
Sorter sorter = new Sorter();
//Strategies for using natural order sorting
sorter.setStrategy(new NaturalOrderSortingStrategy());
sorter.sortList(numbers);
System. out. println ("Natural order:"+numbers)// Output: Natural order: [2, 5, 10]
//Strategy of using reverse sorting
sorter.setStrategy(new ReverseOrderSortingStrategy());
sorter.sortList(numbers);
System. out. println ("Reverse order:"+numbers)// Output: Reverse order: [10, 5, 2]
}
}
In the above code, the SortingStrategy interface defines sorting strategies, and its specific implementation classes NaturalOrderSortingStrategy and ReverseOrderSortingStrategy represent strategies sorted in natural and reverse order, respectively. The Sorter class serves as a policy context class, setting specific policies through the setStrategy method, and sorting the list using specific policies in the sortList method.
Using the Strategy pattern, you can easily change the sorting policy without changing the client code. By changing the specific implementation class of the strategy, we can achieve different sorting logic.
Summary: The Strategy pattern is a common behavior mode in the Java SDK. It encapsulates algorithms or behaviors into different policy objects so that these policies can be replaced at runtime. This design pattern provides flexibility and maintainability, making the code easier to expand and modify. In the Java SDK, the Comparator interface is a typical application of the Strategy pattern, which allows objects to be compared according to different policies.
