策略模式定义了算法族，这些算法被分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的客户。（此定义来源于《深入浅出设计模式》）
下面举一个根据这模式设计并实现有序数组的例子。
算法族是几个排序算法，它们都继承自Sort接口：
package sort;
public interface Sort {
/**
* 这是需要变化的地方。将它独立处理，和不需要变化的部分分开。
* @param a
*/
public <T extends Comparable<T>> void sort(T[] a);
}
这里贴出这个接口的两个实现类的代码，第一个是插入排序实现类：
package sort;
public class InsertSort implements Sort {
@Override
public <T extends Comparable<T>> void sort(T[] a) {
// TODO Auto-generated method stub
int length = a.length;
for(int i = 0; i < length; i++) {
T key = a[i];
// 需要与key比较的元素的位置
int j = i - 1;
/**
* j >= 0保证a[j]存在；
* a[j].compareTo(key) > 0保证a[j] > key, a[j]的位置需要后移，
* 这时（a[j]后移之后，j自减1之前），j就是key的候选位置；
* 如果是因为j < 0而退出while循环的，说明子数组中没有小于key的元素，
* 也就是说，0是key的正确位置。
*/
while (j >= 0 && a[j].compareTo(key) > 0) {
// 元素后移一个位置
a[j+1] = a[j];
// 需要比较的元素的位置前移
j--;
}
// j+1就是key的正确位置
a[j+1] = key;
}
}
}
插入排序算法的讲解见Java实现插入排序
第二个是合并排序实现类：
package sort;
import java.lang.reflect.Array;
public class MergeSort implements Sort {
@SuppressWarnings("unchecked")
private <T extends Comparable<T>> void merge(T[] a, int p, int q, int r) {
// 获得数组left的长度
int n1 = q - p + 1;
// 获得数组right的长度
int n2 = r - q;
// 创建数组left
T[] left = (T[]) Array.newInstance(a.getClass().getComponentType(), n1);
// 创建数组right
T[] right = (T[]) Array.newInstance(a.getClass().getComponentType(), n2);
// 把数组a的相应值赋给left
for(int i = 0; i < n1; i++){
left[i] = a[p + i];
}
// 把数组a的相应值赋给right
for(int i = 0; i < n2; i++){
right[i] = a[q + 1 + i];
}
// left数组当前待处理元素的位置
int i = 0;
// left结束标识
boolean endLeft = false;
// right数组当前待处理元素的位置
int j = 0;
// right结束标识
boolean engRight = false;
int k = p;
while(k <= r){
if (left[i].compareTo(right[j]) < 0) {
a[k] = left[i];
// 说明left的最后一个元素已被处理
if (i == (n1 - 1)) {
endLeft = true;
k++;
break;
}
i++;
} else {
a[k] = right[j];
// 说明right的最后一个元素已被处理
if (j == (n2 - 1)) {
engRight = true;
k++;
break;
}
j++;
}
k++;
}
// 把还没处理完的数组的剩余元素放进a中
if (endLeft) {
while(k <= r){
a[k] = right[j];
k++;
j++;
}
} else {
while(k <= r){
a[k] = left[i];
k++;
i++;
}
}
}
@Override
public <T extends Comparable<T>> void sort(T[] a) {
// TODO Auto-generated method stub
// 默认情况下，对数组从头到尾排序
int p = 0;
int r = a.length - 1;
sort(a, p, r);
}
private <T extends Comparable<T>> void sort(T[] a, int p, int r) {
// TODO Auto-generated method stub
if (p < r) {
int q = (p + r) / 2;
sort(a, p, q);
sort(a, q + 1, r);
merge(a, p, q, r);
}
}
@SuppressWarnings("unchecked")
public <T extends Comparable<T>> void test(T[] a) {
T[] b = (T[]) Array.newInstance(a.getClass().getComponentType(),
a.length);
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}
T min = null;
boolean flag = true;
for (int i = 0; i < b.length; i++) {
if (flag) {
min = b[i];
flag = false;
}
if (b[i].compareTo(min) < 0) {
min = b[i];
}
}
System.out.println(min);
}
@SuppressWarnings("unchecked")
public <T> void test2(T[] a) {
T[] b = (T[]) new Object[a.length];
for (int i = 0; i < a.length; i++) {
b[i] = a[i];
}
for (int i = 0; i < b.length; i++) {
System.out.println(b[i]);
}
}
}
合并排序算法的具体讲解见Java实现归并排序
这个算法族的客户是有序数组：
package sort;
import java.util.Arrays;
/**
* 使用算法的客户
* @author yuncong
*
* @param <T>
*/
public abstract class SortArray<T extends Comparable<T>> {
T[] a;
// 组合SortArray和Sort
Sort sort;
public T[] getA() {
return a;
}
public abstract void setA(T[] a);
@Override
public String toString() {
return "SortArray [a=" + Arrays.toString(a) + "]";
}
}具体有序数组类型有插入排序有序数组和合并排序有序数组：
package sort;
public class InsertSortArray<T extends Comparable<T>> extends SortArray<T> {
public InsertSortArray() {
this.sort = new InsertSort();
}
@Override
public void setA(T[] a) {
// TODO Auto-generated method stub
sort.sort(a);
this.a = a;
}
}
package sort;
public class MergeSortArray<T extends Comparable<T>> extends SortArray<T> {
public MergeSortArray() {
// TODO Auto-generated constructor stub
this.sort = new MergeSort();
}
@Override
public void setA(T[] a) {
// TODO Auto-generated method stub
this.sort.sort(a);
this.a = a;
}
}
package sort;
import java.util.Arrays;
public class TestSort {
public static void main(String[] args) {
// TODO Auto-generated method stub
// InsertSort
// SortArray<Integer> sortArray = new InsertSortArray<Integer>();
// Integer[] a = new Integer[]{14, 2, 7, 9, 10};
// sortArray.setA(a);
// Integer[] arrIntegers = sortArray.getA();
// System.out.println(Arrays.toString(arrIntegers));
// MergeSort
SortArray<Integer> sortArray = new MergeSortArray<>();
Integer[] a = new Integer[] { 14, 2, 7, 9, 10 };
sortArray.setA(a);
Integer[] arrIntegers = sortArray.getA();
System.out.println(Arrays.toString(arrIntegers));
}
}原文地址：http://blog.csdn.net/l294265421/article/details/46287821
