Java利用策略设计模式写一个个人信息排序程序

要求：若干个Person对象存储在一个list中，包含id，name和age三个属性，类型分别为int，String，int，分别按三个属性从小到大排序，名字相同时或年龄相同时按id从小到大的顺序排序，要运用策略模式

设计：抽象策略角色：PersonStrategy（提供抽象方法）

           具体策略角色：IdSortStrategy(实现抽象方法，按id排序)，NameSortStrategy（按Name排序），AgeSortStrategy（按Age排序）

           环境角色：PersonEnvironment，调用策略角色

           Person:内有三个属性和对应的getter和setter，重载构造方法

           IdComparator:比较器：定义按三种方法排序的比较器，用在具体抽象角色的Collections.sort(list,comparator)中

           PersonClient:客户端，用来调用环境角色，实现输出

           PrintList：用于打印list

           代码如下：

PersonStrategy(抽象策略角色):

package PersonSortTest;

import java.util.LinkedList;
import java.util.List;
import java.util.TreeSet;

public interface PersonStrategy {
    public List<Person> sort(List<Person> p);
}

IdComparator(比较器):

package PersonSortTest;

import java.util.Comparator;

public class IdComparator implements Comparator<Person> {

    @Override
    public int compare(Person p1, Person p2) {
        return p1.getId()-p2.getId();
    }
}
class NameComparator implements  Comparator<Person>{

    @Override
    public int compare(Person p1, Person p2) {  //如果名字相同，按id排序
        String str1 = p1.getName();
        String str2 = p2.getName();
        if(str1.equals(str2))
        {
            return p1.getId()-p2.getId();
        }
        return str1.compareTo(str2);
    }
}

class AgeComparator implements Comparator<Person>{

    @Override
    public int compare(Person p1, Person p2) {//如果年龄相同，按id排序

        if(p1.getAge() == p2.getAge())
        {
            return p1.getId()-p2.getId();
        }
        return p1.getAge()-p2.getAge();
    }
}

IdSortStrategy(具体策略角色：按id排序)

package PersonSortTest;

import java.util.Collections;
import java.util.List;

public class IdSortStrategy implements PersonStrategy{
    IdComparator ic = new IdComparator();
    public List<Person> sort(List<Person> p )
    {
        Collections.sort(p,ic);
        return  p;
    }
}

NameSortStrategy(具体策略角色：按name排序)

package PersonSortTest;

import java.util.Collections;
import java.util.List;


public class NameSortStrategy implements PersonStrategy{
    NameComparator nc = new NameComparator();
    public List<Person> sort(List<Person> p )
    {
        Collections.sort(p,nc);
        return  p;
    }

}

AgeSortStrategy(具体策略角色：按age排序)

package PersonSortTest;

import java.util.Collections;
import java.util.List;

public class AgeSortStrategy implements PersonStrategy{
    AgeComparator ac = new AgeComparator();
    public List<Person> sort(List<Person> p )
    {
        Collections.sort(p,ac);
        return  p;
    }
}

PersonEnvironment(环境角色，含有策略角色的引用)

package PersonSortTest;

import java.util.List;

public class PersonEnvironment {
    public PersonStrategy getPs() {
        return ps;
    }

    public void setPs(PersonStrategy ps) {
        this.ps = ps;
    }

    private PersonStrategy ps;
    public PersonEnvironment(PersonStrategy ps)
    {
        this.ps = ps;
    }
    public List<Person> sort(List<Person> list)
    {
        return ps.sort(list);
    }
}

Person(Person对象的类，含有三个属性及其get，set方法)

package PersonSortTest;

import StrategyTest.Strategy;

public class Person {

    private int id;
    private String name;
    private int age;
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    public Person(int id,String name,int age)
    {
        this.id = id;
        this.name = name;
        this.age = age;
    }

}

PrintList(用来打印list的方法)

package PersonSortTest;

import java.util.Iterator;
import java.util.List;

public class PrintList {
    public void outputList(List<Person> list)
    {
        Iterator<Person> i = list.iterator();
        while(i.hasNext())
        {
            Person p = i.next();
            System.out.println(p.getId()+","+p.getName()+","+p.getAge());
        }
    }
}

PersonClient(客户端，实现具体的结果)

package PersonSortTest;

import java.util.ArrayList;
import java.util.List;

public class PersonClient {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person(10001,"xiaoming",18));
        list.add(new Person(10002,"xiaohong",20));
        list.add(new Person(10004,"xiaogang",17));
        list.add(new Person(10003,"xiaoqiang",24));
        list.add(new Person(10006,"xiaoming",19));
        list.add(new Person(10005,"xiaofang",20));
        PrintList pl = new PrintList();
        System.out.println("----按ID排序---");
        IdSortStrategy is = new IdSortStrategy();
        PersonEnvironment pe1 = new PersonEnvironment(is);
        pe1.sort(list);
        pl.outputList(list);
        System.out.println("----按名字排序---");
        NameSortStrategy ns = new NameSortStrategy();
        PersonEnvironment pe2 = new PersonEnvironment(ns);
        pe2.sort(list);
        pl.outputList(list);
        System.out.println("----按年龄排序---");
        AgeSortStrategy ac = new AgeSortStrategy();
        PersonEnvironment pe3 = new PersonEnvironment(ac);
        pe3.sort(list);
        pl.outputList(list);

    }
}

程序运行结果

----按ID排序---
10001,xiaoming,18
10002,xiaohong,20
10003,xiaoqiang,24
10004,xiaogang,17
10005,xiaofang,20
10006,xiaoming,19
----按名字排序---
10005,xiaofang,20
10004,xiaogang,17
10002,xiaohong,20
10001,xiaoming,18
10006,xiaoming,19
10003,xiaoqiang,24
----按年龄排序---
10004,xiaogang,17
10001,xiaoming,18
10006,xiaoming,19
10002,xiaohong,20
10005,xiaofang,20
10003,xiaoqiang,24