o
onedotdot

概述

``````/**
* @author HansChen
*/
public class Sorter {

/**
* 冒泡排序
*/
public int sort(int[] array) {
int operations = 0;
if (array.length <= 1) {
return operations;
}

for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - i - 1; j++) {
operations++;
if (needSwap(array, j)) {
swap(array, j);
}
}
}

return operations;
}

/**
* @return 是否需要交换数组中 index 和 index+1 元素
*/
private boolean needSwap(int[] array, int index) {
return array[index] > array[index + 1];
}

/**
* 交换array数组中的 index 和 index+1 元素
*/
private void swap(int[] array, int index) {
int temp = array[index];
array[index] = array[index + 1];
array[index + 1] = temp;
}
}``````
•

模板方法模式

``````/**
* @author HansChen
*/
public abstract class BubbleSorter<T> {

/**
* 冒泡排序
*/
public int sort(T array) {

setArray(array);
int length = getLength();

int operations = 0;
if (length <= 1) {
return operations;
}

for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - i - 1; j++) {
operations++;
if (needSwap(j)) {
swap(j);
}
}
}

return operations;
}

/**
* 初始化排序数组
*/
protected abstract void setArray(T array);

/**
* @return 返回数组长度
*/
protected abstract int getLength();

/**
* @return 是否需要交换数组中 index 和 index+1 元素
*/
protected abstract boolean needSwap(int index);

/**
* 交换array数组中的 index 和 index+1 元素
*/
protected abstract void swap(int index);
}``````
•

``````public class IntBubbleSorter extends BubbleSorter<int[]> {

private int[] array;

@Override
protected void setArray(int[] array) {
this.array = array;
}

@Override
protected int getLength() {
return array == null ? 0 : array.length;
}

@Override
protected boolean needSwap(int index) {
return array != null && (array[index] > array[index + 1]);
}

@Override
protected void swap(int index) {
int temp = array[index];
array[index] = array[index + 1];
array[index + 1] = temp;
}
}``````
•

``````public class DoubleBubbleSorter extends BubbleSorter<double[]> {

private double[] array;

@Override
protected void setArray(double[] array) {
this.array = array;
}

@Override
protected int getLength() {
return array == null ? 0 : array.length;
}

@Override
protected boolean needSwap(int index) {
return array != null && (array[index] > array[index + 1]);
}

@Override
protected void swap(int index) {
double temp = array[index];
array[index] = array[index + 1];
array[index + 1] = temp;
}
}``````
•

``````public class IntegerListBubbleSorter extends BubbleSorter<List<Integer>> {

private List<Integer> list;

@Override
protected void setArray(List<Integer> list) {
this.list = list;
}

@Override
protected int getLength() {
return list == null ? 0 : list.size();
}

@Override
protected boolean needSwap(int index) {
return list != null && (list.get(index) > list.get(index + 1));
}

@Override
protected void swap(int index) {
int temp = list.get(index);
list.set(index, list.get(index + 1));
list.set(index + 1, temp);
}
}``````
•
• 26

``````public class Test {

public static void main(String[] args) {

//对整型数组排序
int[] intArray = {9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
int operations = new IntBubbleSorter().sort(intArray);
System.out.println("[Template Method] operations:" + operations + ", array:" + Arrays.toString(intArray));

//对double数组排序
double[] doubleArray = {9.9, 8.8, 7.7, 6.6, 5.5, 4.4, 3.3, 2.2, 1.1, 0.0};
operations = new DoubleBubbleSorter().sort(doubleArray);
System.out.println("[Template Method] operations:" + operations + ", array:" + Arrays.toString(doubleArray));

//对List集合排序
List<Integer> list = Arrays.asList(9, 8, 7, 6, 5, 4, 3, 2, 1, 0);
operations = new IntegerListBubbleSorter().sort(list);
System.out.println("[Template Method] operations:" + operations + ", list:" + list.toString());
}
}``````
•

策略模式

``````public class BubbleSorter<T> {

/**
* 抽象策略接口，可以有不同的实现
*/
private SortHandler<T> sortHandler;

public BubbleSorter(SortHandler<T> sortHandler) {
this.sortHandler = sortHandler;
}

/**
* 冒泡排序
*/
public int sort(T array) {

sortHandler.setArray(array);
int length = sortHandler.getLength();

int operations = 0;
if (length <= 1) {
return operations;
}

for (int i = 0; i < length - 1; i++) {
for (int j = 0; j < length - i - 1; j++) {
operations++;
if (sortHandler.needSwap(j)) {
sortHandler.swap(j);
}
}
}

return operations;
}
}``````
• 1

``````public interface SortHandler<T> {

/**
* 初始化排序数组
*/
void setArray(T array);

/**
* @return 返回数组长度
*/
int getLength();

/**
* @return 是否需要交换数组中 index 和 index+1 元素
*/
boolean needSwap(int index);

/**
* 交换array数组中的 index 和 index+1 元素
*/
void swap(int index);
}``````
• 1

``````public class IntSortHandler implements SortHandler<int[]> {

private int[] array;

@Override
public void setArray(int[] array) {
this.array = array;
}

@Override
public int getLength() {
return array == null ? 0 : array.length;
}

@Override
public boolean needSwap(int index) {
return array != null && (array[index] > array[index + 1]);
}

@Override
public void swap(int index) {
int temp = array[index];
array[index] = array[index + 1];
array[index + 1] = temp;
}
}``````
• 1

•

•

总结

o

onedotdot

Template Method模板方法设计模式定义一个操作中算法的骨架，将具体步骤的执行延迟到子类中实现。Java中的抽象类就是使用了模板方法设计模式。模板方法设计模式结构如下： 以文档处理为例，T...

2014/01/24
0
0
【设计模式笔记】（十六）- 代理模式

MrTrying
2018/06/24
0
0

2018/03/22
0
0

book: 阎宏《JAVA与模式》 架构设计栏目 http://blog.csdn.net/enterprise/column.html 概要： http://bbs.csdn.net/forums/Embeddeddriver 23种设计模式分别是： 1.单例模式　2.工厂方法模式...

jayronwang
2014/12/19
0
0
PHP设计模式(一)：简介及创建型模式

juhenj
2014/05/15
228
2

MySQL查询执行

44分钟前
0
0
CDH5动静态资源池配置与回滚

hblt-j
48分钟前
3
0
WordPress仿站实战教程

51分钟前
3
0

https://github.com/nothings/stb 目前一般主流的图像格式也就是bmp，jpg，png，tga，dds，除了DDS一般是给DX用的，虽然一堆OpenGL程序也有用的，但是我一般只用png和tga， png不用说了，带a...

robslove

1
0
Spring 事务提交回滚源码解析

TSMYK

2
0