策略模式在java集合中的TreeSet和TreeMap中得到了很好的应用，我们可以实现Comparator接口实现Compareto()方法来定义自己的排序规则，然后通过TreeSet,TreeMap构造方法传入实现该接口的实例，map中的顺序就会是我们自定义的顺序。我们可以完全定义自己的规则，用之极为方便。那么，什么是策略模式呢？
策略模式定义：定义一组算法，将每个算法都封装起来，并且使它们之间可以转换。策略模式使这些算法在客户端调用时能够互不影响的变化。
策略模式组成：
1.抽象的策略角色：策略类，通常由一个抽象类或者接口实现。
2.具体的策略角色：包装了相关的算法和行为。
3.环境角色：持有一个策略类的引用，以便最终给客户端调用。
策略模式的设计原则:
1. 封装变化
2.使用接口编程
策略模式的实现：
1.将每一组算法封装到具有共同接口的独立类中，这样不同的策略可以相互替换
2.算法可以在不影响客户端的情况下发生变化，把行为和环境分开。
3.环境类负责维持和查询行为类，各种算法在具体策略中提供
看文字看蒙了，举一个具体的例子吧，举什么例子呢？想到我们数据结构中的各种排序，什么冒泡排序，快速排序，堆排序...，他们完成的功能都是一样的，只是排序算法不同而已。我们就可以看成是排序的不同策略。
首先定义我们的抽象策略：
/**
* 抽象的策略类
* @author
*
*/
public interface Strategy {
public void sort(int[] array);
}
定义具体的策略,这里实现了三种策略，分别是快速排序，堆排序，归并排序。
快速排序策略代码：
public class QuickSort implements Strategy{
@Override
public void sort(int[] array) {
qpSort(array,0,array.length - 1);
}
private void qpSort(int array[], int low, int high) {
int pos = qkPass(array, low, high); //产生中间第一个确定的数
if (low < high) {
qpSort(array, low, pos - 1);//左边
qpSort(array, pos + 1, high);//右边
}
}
private int qkPass(int a[], int low, int high) {
int x = a[low];
while (low < high) {
while (low < high && a[high] > x) {
high--;
}
if (low < high) {
a[low] = a[high];
low++;
}
while (low < high && a[low] < x) {
low++;
}
if (low < high) {
a[high] = a[low];
high--;
}
}
a[low] = x;
return low;
}
}
堆排序策略代码：
public class HeapSort implements Strategy {
@Override
public void sort(int[] array) {
heapSort(array,array.length);
}
private void heapSort(int a[], int length) {
crtHeap(a, length); // 创建大根堆
for (int i = length - 1; i > 0; i--) {
int b = a[0];
a[0] = a[i]; // 堆顶跟堆尾互换
a[i] = b;
sift(a, 0, i - 1); // 使得r[0...i-1]变成堆
}
}
/**
* 建立初堆
*
* @param a
* 为带排序的数组
* @param length
* 为数组长度
*/
private void crtHeap(int a[], int length) {
int n = length - 1;
// 建出堆，从第 n/2 个记录开始进行堆筛选
for (int i = n / 2; i >= 0; i--) {
sift(a, i, n);
}
}
/**
*
* @param r
* 数组
* @param k
* 表示以r[k]为根的完全二叉树，调整r[k]，使得r[k...m]满足大根堆的性质
* @param m
* 堆尾元素下标
*/
private void sift(int r[], int k, int m) {
int temp = r[k]; // 暂存根记录
int i = k; // 记录初始根的下标
int j = i * 2 + 1; // 根的左孩子,因为下标从0开始
while (j <= m) {
// 如果存在右子树，且右子树根的关键字大，则沿右分支筛选，否则沿左分支筛选。因为目的是找一个最大的元素
if (j < m && r[j] < r[j + 1]) {
j = j + 1;
}
if (temp >= r[j]) {
break; // 结束筛选
}
else {
r[i] = r[j]; // 上移
i = j; // 从新定义根下标
j = j * 2 + 1;// 继续筛选
}
}
r[i] = temp; // 将r[k]移动到适当的位置
}
}
归并排序策略代码:
public class MergeSort implements Strategy{
@Override
public void sort(int[] array) {
int[] temp = new int[array.length];
mSort(array,0,array.length - 1, temp);
}
/**
*
* @param r1 等待排序数组
* @param low
* @param high
* @param r3 将r1排序后的结果放在r3中 r1[low...high],r3[low...high]
*/
private void mSort(int r1[],int low,int high, int r3[]){
if(low < high)
{
int mid = (low + high) /2;
//归并排序中 拆，合要一起进行
mSort(r1,low,mid,r3);
mSort(r1,mid+1,high,r3);
merge(r1,low, mid, high, r3);
}
}
private void merge(int r1[],int low, int mid, int high, int r2[]){
int i = low;
int j = mid + 1;
int k = 0;
while(i <=mid && j <= high){
if(r1[i] <= r1[j]){
r2[k] = r1[i];
i++;
}
else{
r2[k] = r1[j];
j++;
}
k++;
}
while(i <= mid){
r2[k] = r1[i];
i++;
k++;
}
while(j <= high){
r2[k] = r1[j];
j++;
k++;
}
for(int m = 0; m < k;m++){
r1[low + m] = r2[m];
}
}
}
定义环境类：
public class Environment {
private Strategy strategy; //策略类的引用
public Environment(Strategy strategy){
this.strategy = strategy;
}
//用于设置不同的策略
public void setStrategy(Strategy strategy){
this.strategy = strategy;
}
//实现排序的功能
public void sort(int array[]){
strategy.sort(array);
}
}
最后定义客户端类：
public class Client {
public static void main(String[] args) {
int[] array1 = new int[]{48,62,35,77,55,14,35,98};
int[] array2 = new int[]{48,62,35,77,55,14,35,98};
int[] array3 = new int[]{48,62,35,77,55,14,35,98};
//使用堆排序策略
Environment env = new Environment(new HeapSort());
env.sort(array1);
System.out.println("使用堆排序array1：");
print(array1);
//使用快速排序策略
env.setStrategy(new QuickSort());
env.sort(array2);
System.out.println("使用快速排序array2：");
print(array2);
//使用归并排序策略
env.setStrategy(new MergeSort());
env.sort(array3);
System.out.println("使用归并排序array3：");
print(array3);
}
static void print(int[] array){
for(int i = 0; i < array.length; i++){
System.out.print(array[i] + "\t");
}
System.out.println();
System.out.println("---------------------------------");
}
}
运行结果如下所示：
我们使用不同的排序策略分别对三个数组排序的功能已经实现了，程序非常灵活，我们想用什么策略来实现排序可以自己决定（通过environment.serStrategy(XXX)方法）。
程序中Environment类根本不知道也不用管排序到底是怎么实现的，它只是持有一个具体策略类的引用，然后调用具体策略类的方法。
策略模式用着很方便，但是本身也有缺点：
1.客户端必须知道所有的策略类，并自行决定使用哪种策略类。
2.造成很多的策略类，每一个不同的策略都需要一个策略类来实现。
对于第一点很明显，我们客户端（client类）在使用策略时必须知道具体的策略类是什么，environment.serStrategy(XXX)方法也需要知道。
对于第二点，定义了3中策略，就有3个策略类，如果策略很多的话，类也会很多。
参考资料：圣思园教学视频
