Java之策略模式比较器案例讲解

Java之策略模式比较器案例讲解

Comparable 比较器，内置定义的比较方法，实现比较 较简单

Comparator 策略模式，需要定义不同的策略和比较的对象，实现比较 较复杂

打个比方，狗有foot一种属性我们用Comparable比较器完成比较

猫有height和weight两种属性，我们用Comparator策略模式完成比较

一、Comparable --狗比较

缺点：自定义排序规则，规则定义好之后，再改起来就不方便，还需要重新开发Sort比较类

1、狗对象

package com.longze.guosh.strategy;

public class Dog implements Comparable {

int food; //狗的饭量

public Dog(int food){

this.food=food;

}

@Override //自定义排序规则，规则定义好之后，再改起来就不方便

public int compareTo(Dog d) {

if(this.food

elshttp://e if(this.food>d.food) return 1;

else return 0;

}

@Override

public String toString() {

return "Dog{" +

"food=" + food +

'}';

}

}

2、狗的比较类，也可以代表猫的汽车的比较类，但是比较策略无法修改（(除非改原来的方法)）

package com.longze.guosh.strategy;

import java.util.Comparator;

public class DogSorter {

//排序

public static void sort(Comparable[] arr){

for(int i=0;i< arr.length-1;i++){

int minPos=i;

for(int j=i+1;j

minPos=arr[j].compareTo(arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

//交换

static void swap(Comparable[] arr,int i,int j){

Comparable temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

3、main方法验证

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Dog[] ds= {new Dog(8),new Dog(5),new Dog(10),new Dog(1)};

//comparater

DogSorter dogsorter=new DogSorter();

dogsorter.sort(ds);

System.out.println("Dogs==="+Arrays.toString(ds));

}

}

二、Comparator 策略模式

优点，可以定义多种比较策略，不需要改sort比较类

1、猫对象

package com.longze.guosh.strategy;

public class Cat{

int weight,height;

public Cat(int weight,int height){

this.height=height;

this.weight=weight;

}

@Override

publichttp:// String toString() {

return "Cat{" +

"weight=" + weight +

", height=" + height +

'}';

}

}

2、猫的比较策略，可以有多种策略

如【CatHeightComparator.java】身高比较器  【CatWeightComparator】体重比较器

package com.longze.guosh.strategy;

import java.util.Comparator;

public class CatHeightComparator implements Comparator {

@Override

public int compare(Cat o1, Cat o2) {

if (o1.height > o2.height) {

return -1;

} else if (o1.height < o2.height) {

return 1;

}else {

return 0;

}

}

}

package com.longze.guosh.strategy;

import java.util.Comparator;

public class CatWeightComparator implements Comparator {

@Override

public int compare(Cat o1, Cat o2) {

if (o1.weight < o2.weight) {

return -1;

} else if (o1.weight > o2.weight) {

return 1;

}else {

return 0;

}

}

}

3、比较器 也可以用作狗或者其他比较类，比较策略可以重新指定不同的

package com.longze.guosh.strategy;

import java.util.Comparator;

public class Sorter {

public void sort(T[] arr, Comparator comparator){

for(int i=0;i< arr.length-1;i++){

int minPos=i;

for(int j=i+1;j

minPos=comparator.compare(arr[j],arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

void swap(T[] arr,int i,int j){

T temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

4、Main校验

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Cat[] cs={new Cat(3,3),new Cat(5,5),new Cat(1,1),new Cat(10,10)};

//comparator

Sorter catsorter=new Sorter<>();

catsorter.sort(cs,new CatHeightComparator());

System.out.println("Cat==="+Arrays.toString(cs));

}

}

综上所述 使用简单比较器直接实现Comparable类，就可以完成

当使用策略模式时，需要实现不同的Comparator策略，配合Sort可以完成比较

Git地址：https://gitee.com/feng-qingxuan/dessign-pattrns.git  strategy

elshttp://e if(this.food>d.food) return 1;

else return 0;

}

@Override

public String toString() {

return "Dog{" +

"food=" + food +

'}';

}

}

2、狗的比较类，也可以代表猫的汽车的比较类，但是比较策略无法修改（(除非改原来的方法)）

package com.longze.guosh.strategy;

import java.util.Comparator;

public class DogSorter {

//排序

public static void sort(Comparable[] arr){

for(int i=0;i< arr.length-1;i++){

int minPos=i;

for(int j=i+1;j

minPos=arr[j].compareTo(arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

//交换

static void swap(Comparable[] arr,int i,int j){

Comparable temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

3、main方法验证

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Dog[] ds= {new Dog(8),new Dog(5),new Dog(10),new Dog(1)};

//comparater

DogSorter dogsorter=new DogSorter();

dogsorter.sort(ds);

System.out.println("Dogs==="+Arrays.toString(ds));

}

}

二、Comparator 策略模式

优点，可以定义多种比较策略，不需要改sort比较类

1、猫对象

package com.longze.guosh.strategy;

public class Cat{

int weight,height;

public Cat(int weight,int height){

this.height=height;

this.weight=weight;

}

@Override

publichttp:// String toString() {

return "Cat{" +

"weight=" + weight +

", height=" + height +

'}';

}

}

2、猫的比较策略，可以有多种策略

如【CatHeightComparator.java】身高比较器  【CatWeightComparator】体重比较器

package com.longze.guosh.strategy;

import java.util.Comparator;

public class CatHeightComparator implements Comparator {

@Override

public int compare(Cat o1, Cat o2) {

if (o1.height > o2.height) {

return -1;

} else if (o1.height < o2.height) {

return 1;

}else {

return 0;

}

}

}

package com.longze.guosh.strategy;

import java.util.Comparator;

public class CatWeightComparator implements Comparator {

@Override

public int compare(Cat o1, Cat o2) {

if (o1.weight < o2.weight) {

return -1;

} else if (o1.weight > o2.weight) {

return 1;

}else {

return 0;

}

}

}

3、比较器 也可以用作狗或者其他比较类，比较策略可以重新指定不同的

package com.longze.guosh.strategy;

import java.util.Comparator;

public class Sorter {

public void sort(T[] arr, Comparator comparator){

for(int i=0;i< arr.length-1;i++){

int minPos=i;

for(int j=i+1;j

minPos=comparator.compare(arr[j],arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

void swap(T[] arr,int i,int j){

T temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

4、Main校验

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Cat[] cs={new Cat(3,3),new Cat(5,5),new Cat(1,1),new Cat(10,10)};

//comparator

Sorter catsorter=new Sorter<>();

catsorter.sort(cs,new CatHeightComparator());

System.out.println("Cat==="+Arrays.toString(cs));

}

}

综上所述 使用简单比较器直接实现Comparable类，就可以完成

当使用策略模式时，需要实现不同的Comparator策略，配合Sort可以完成比较

Git地址：https://gitee.com/feng-qingxuan/dessign-pattrns.git  strategy

minPos=arr[j].compareTo(arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

//交换

static void swap(Comparable[] arr,int i,int j){

Comparable temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

3、main方法验证

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Dog[] ds= {new Dog(8),new Dog(5),new Dog(10),new Dog(1)};

//comparater

DogSorter dogsorter=new DogSorter();

dogsorter.sort(ds);

System.out.println("Dogs==="+Arrays.toString(ds));

}

}

二、Comparator 策略模式

优点，可以定义多种比较策略，不需要改sort比较类

1、猫对象

package com.longze.guosh.strategy;

public class Cat{

int weight,height;

public Cat(int weight,int height){

this.height=height;

this.weight=weight;

}

@Override

publichttp:// String toString() {

return "Cat{" +

"weight=" + weight +

", height=" + height +

'}';

}

}

2、猫的比较策略，可以有多种策略

如【CatHeightComparator.java】身高比较器  【CatWeightComparator】体重比较器

package com.longze.guosh.strategy;

import java.util.Comparator;

public class CatHeightComparator implements Comparator {

@Override

public int compare(Cat o1, Cat o2) {

if (o1.height > o2.height) {

return -1;

} else if (o1.height < o2.height) {

return 1;

}else {

return 0;

}

}

}

package com.longze.guosh.strategy;

import java.util.Comparator;

public class CatWeightComparator implements Comparator {

@Override

public int compare(Cat o1, Cat o2) {

if (o1.weight < o2.weight) {

return -1;

} else if (o1.weight > o2.weight) {

return 1;

}else {

return 0;

}

}

}

3、比较器 也可以用作狗或者其他比较类，比较策略可以重新指定不同的

package com.longze.guosh.strategy;

import java.util.Comparator;

public class Sorter {

public void sort(T[] arr, Comparator comparator){

for(int i=0;i< arr.length-1;i++){

int minPos=i;

for(int j=i+1;j

minPos=comparator.compare(arr[j],arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

void swap(T[] arr,int i,int j){

T temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

4、Main校验

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Cat[] cs={new Cat(3,3),new Cat(5,5),new Cat(1,1),new Cat(10,10)};

//comparator

Sorter catsorter=new Sorter<>();

catsorter.sort(cs,new CatHeightComparator());

System.out.println("Cat==="+Arrays.toString(cs));

}

}

综上所述 使用简单比较器直接实现Comparable类，就可以完成

当使用策略模式时，需要实现不同的Comparator策略，配合Sort可以完成比较

Git地址：https://gitee.com/feng-qingxuan/dessign-pattrns.git  strategy

minPos=comparator.compare(arr[j],arr[minPos])==-1?j:minPos;

}

swap(arr,i,minPos);

}

}

void swap(T[] arr,int i,int j){

T temp=arr[i];

arr[i]=arr[j];

arr[j]=temp;

}

}

4、Main校验

package com.longze.guosh.strategy;

import java.util.Arrays;

public class Main {

public static void main(String[] args) {

Cat[] cs={new Cat(3,3),new Cat(5,5),new Cat(1,1),new Cat(10,10)};

//comparator

Sorter catsorter=new Sorter<>();

catsorter.sort(cs,new CatHeightComparator());

System.out.println("Cat==="+Arrays.toString(cs));

}

}

综上所述 使用简单比较器直接实现Comparable类，就可以完成

当使用策略模式时，需要实现不同的Comparator策略，配合Sort可以完成比较

Git地址：https://gitee.com/feng-qingxuan/dessign-pattrns.git  strategy

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。