java接口默认方法，静态方法的应用

在前面介绍了接口的默认方法，静态方法是java1.8新增特性之一。

下面就看一看典型应用，比较器comparator。

在java1.8之前，comparator接口只定义了2个抽象方法。

public interface Comparator<T> {

    int compare(T o1, T o2);

  
    boolean equals(Object obj);
}

而在1.8的时候，给comparator接口增加了很多静态方法和默认方法。（如： 表一）

这些方法不仅增强了接口的功能，而且可以对多种数据结构，多种数据类型进行精确的排序控制。

生活中，玩扑克牌的时候，就会经常需要洗牌，发牌，然后重新排序。

扑克牌有4种花色，13种点数，当然还有大小王。可以定义一个Card接口：

public interface Card extends Comparable<Card> {
	public enum Suit {
		DIAMONDS(1, "方块"), CLUBS(2, "黑桃"), HEARTS(3, "红桃"), SPADES(4, "梅花");

		private final int value;
		private final String text;

		Suit(int value, String text) {
			this.value = value;
			this.text = text;
		}

		public int value() {
			return value;
		}

		public String text() {
			return text;
		}

	}

	public enum Rank {

		THREE (3, "3"),
		FOUR (4, "4"),
		FIVE (5, "5"),
		SIX (6, "6"),
		SEVEN (7, "7"),
		EIGHT (8, "8"),
		NINE (9, "9"),
		TEN (10, "10"),
		JACK (11, "J"),
		QUEEN (12, "Q"),
		KING (13, "K"),
		ACE (14, "A"),
		DEVCE (15, "2");
		//BLACK_JOKER (16, "小王"),
		//RED_JOKER (17, "大王");

		private final int value;

		private final String text;

		Rank(int value, String text) {
			this.value = value;
			this.text = text;
		}

		public int value() {
			return value;
		}

		public String text() {
			return text;
		}
	}

	public enum Joker {
		BLACK_JOKER (16, "小王"),
		RED_JOKER (17, "大王");

		private final int value;

		private final String text;

		Joker(int value, String text) {
			this.value = value;
			this.text = text;
		}

		public int value() {
			return value;
		}

		public String text() {
			return text;
		}
	}

		public Card.Suit getSuit();
		public Card.Rank getRank();
		public Card.Joker getJoker();
}

定义一个实现类：

public class PlayingCard implements Card {

	private Card.Suit suit;

	private Card.Rank rank;

	private Card.Joker joker;

	public Card.Suit getSuit() {
		return suit;
	}

	public Card.Rank getRank() {
		return rank;
	}

	public Joker getJoker() {
		return joker;
	}

	public PlayingCard(Card.Suit suit, Card.Rank rank) {
		this.suit = suit;
		this.rank = rank;
	}

	public PlayingCard(Card.Joker joker) {
		this.joker = joker;
	}

	@Override
	public int compareTo(Card o) {
		return this.hashCode() - o.hashCode();
	}

	public int hashCode() {
		if (null != joker) {
			return joker.value();
		}
		return rank.value();
	}

	public boolean equals(Object o) {

		if(o instanceof Card) {
			if(((Card)o).getRank() == this.rank) {
				return true;
			}
		}
		return false;
	}

	public String toString() {
		if (null != joker) {
			return this.joker.text();
		}
		return this.suit.text() + this.rank.text();
	}

}

一副牌可能需要洗牌，发牌，出牌，可以定义一个Deck接口：

public interface Deck {
	
	Deck deckFactory();
	
	int size();
	
	List<Card> getCards();
	
	void addCard(Card card);
	
	void addCards(List<Card> list);
	
	/**
	 * 洗牌
	 */
	void shuffle();
	
	/**
	 * 排序
	 */
	void sort();
	
	/**
	 * 发牌
	 * @param players
	 * @param numberOfCards
	 * @return
	 */
	Map<Integer, Deck> deal(int players, int numberOfCards);
}

它的实现类：

public class StandardDeck implements Deck {

	private List<Card> entireDeck;

	public StandardDeck(List<Card> list) {
		this.entireDeck = list;
	}

	public StandardDeck() {  //先不考虑大小王
		this.entireDeck = new ArrayList();
		for (Card.Suit suit : Card.Suit.values()) {
			for (Card.Rank rank : Card.Rank.values()) {
				this.entireDeck.add(new PlayingCard(suit, rank));
			}
		}
	}

	@Override
	public Deck deckFactory() {
		return new StandardDeck(new ArrayList<Card>());
	}

	@Override
	public int size() {
		return entireDeck.size();
	}

	@Override
	public List<Card> getCards() {
		return entireDeck;
	}

	@Override
	public void addCard(Card card) {
		entireDeck.add(card);
	}

	@Override
	public void addCards(List<Card> list) {
		entireDeck.addAll(list);
	}

	@Override
	public void shuffle() {
		Collections.shuffle(entireDeck);
	}

	@Override
	public void sort() {
		Collections.sort(entireDeck);
	}

	public void sort(Comparator<Card> c) {
		Collections.sort(entireDeck, c);
	}

	public Map<Integer, Deck> deal(int players, int numberOfCards) {
		//TODO
		return null;
	}

}

测试一下，

	public static void main(String[] args) {
		
		StandardDeck standardDeck = new StandardDeck();
		standardDeck.shuffle();
		standardDeck.sort();
		System.out.println(standardDeck.getCards().toString());
		
	}

运行结果：

[黑桃3, 方块3, 梅花3, 红桃3, 方块4, 梅花4, 红桃4, 黑桃4, 方块5, 红桃5, 黑桃5, 梅花5, 黑桃6, 方块6, 梅花6, 红桃6, 方块7, 红桃7, 梅花7, 黑桃7, 红桃8, 黑桃8, 梅花8, 方块8, 红桃9, 方块9, 梅花9, 黑桃9, 方块10, 梅花10, 黑桃10, 红桃10, 红桃J, 黑桃J, 方块J, 梅花J, 黑桃Q, 方块Q, 红桃Q, 梅花Q, 方块K, 黑桃K, 梅花K, 红桃K, 黑桃A, 红桃A, 梅花A, 方块A, 梅花2, 红桃2, 方块2, 黑桃2]

	public static void main(String[] args) {
		
		StandardDeck standardDeck = new StandardDeck();
		standardDeck.shuffle();
		standardDeck.sort();
		System.out.println(standardDeck.getCards().toString());
		
		standardDeck.shuffle();
		standardDeck.sort(Comparator.comparing(Card :: gerRank));
		System.out.println(standardDeck.getCards().toString());
		
		
	}

运行结果：

[黑桃3, 方块3, 梅花3, 红桃3, 方块4, 梅花4, 红桃4, 黑桃4, 方块5, 红桃5, 黑桃5, 梅花5, 黑桃6, 方块6, 梅花6, 红桃6, 方块7, 红桃7, 梅花7, 黑桃7, 红桃8, 黑桃8, 梅花8, 方块8, 红桃9, 方块9, 梅花9, 黑桃9, 方块10, 梅花10, 黑桃10, 红桃10, 红桃J, 黑桃J, 方块J, 梅花J, 黑桃Q, 方块Q, 红桃Q, 梅花Q, 方块K, 黑桃K, 梅花K, 红桃K, 黑桃A, 红桃A, 梅花A, 方块A, 梅花2, 红桃2, 方块2, 黑桃2]

[黑桃3, 方块3, 梅花3, 红桃3, 方块4, 梅花4, 红桃4, 黑桃4, 方块5, 红桃5, 黑桃5, 梅花5, 黑桃6, 方块6, 梅花6, 红桃6, 方块7, 红桃7, 梅花7, 黑桃7, 红桃8, 黑桃8, 梅花8, 方块8, 红桃9, 方块9, 梅花9, 黑桃9, 方块10, 梅花10, 黑桃10, 红桃10, 红桃J, 黑桃J, 方块J, 梅花J, 黑桃Q, 方块Q, 红桃Q, 梅花Q, 方块K, 黑桃K, 梅花K, 红桃K, 黑桃A, 红桃A, 梅花A, 方块A, 梅花2, 红桃2, 方块2, 黑桃2]

如果想要排序不仅按点数排序，还要按花色进行排序。就需要先按点数排序，再按花色进行排序。

	public static void main(String[] args) {
		
		StandardDeck standardDeck = new StandardDeck();
		standardDeck.shuffle();
		standardDeck.sort();
		System.out.println(standardDeck.getCards().toString());
		
		
		standardDeck.shuffle();
		standardDeck.sort(Comparator.comparing(Card :: gerRank)
				.thenComparing(Comparator.comparing(Card :: gerSuit)));
		System.out.println(standardDeck.getCards().toString());
	}

运行结果：

[黑桃3, 方块3, 梅花3, 红桃3, 方块4, 梅花4, 红桃4, 黑桃4, 方块5, 红桃5, 黑桃5, 梅花5, 黑桃6, 方块6, 梅花6, 红桃6, 方块7, 红桃7, 梅花7, 黑桃7, 红桃8, 黑桃8, 梅花8, 方块8, 红桃9, 方块9, 梅花9, 黑桃9, 方块10, 梅花10, 黑桃10, 红桃10, 红桃J, 黑桃J, 方块J, 梅花J, 黑桃Q, 方块Q, 红桃Q, 梅花Q, 方块K, 黑桃K, 梅花K, 红桃K, 黑桃A, 红桃A, 梅花A, 方块A, 梅花2, 红桃2, 方块2, 黑桃2]

表一：

int	compare(T o1, T o2) 比较其两个参数的顺序。
static <T,U extends Comparable<? super U>> Comparator<T>	comparing(Function<? super T,? extends U> keyExtractor) 接受从类型T中提取Comparable排序键的功能，并返回按该排序键进行比较的Comparator<T> 。
static <T,U> Comparator<T>	comparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator) 接受提取从一个类型排序键的功能T ，并返回一个Comparator<T> ，通过使用指定的排序关键字进行比较Comparator 。
static <T> Comparator<T>	comparingDouble(ToDoubleFunction<? super T> keyExtractor) 接受从类型 T中提取 double排序键的功能，并返回一个 Comparator<T> ，该数据按该排序键进行比较。
static <T> Comparator<T>	comparingInt(ToIntFunction<? super T> keyExtractor) 接受从类型 T中提取 int排序键的功能，并返回与该排序键进行比较的 Comparator<T> 。
static <T> Comparator<T>	comparingLong(ToLongFunction<? super T> keyExtractor) 接受提取功能 long从类型排序键 T ，并返回一个 Comparator<T>通过那种关键的。
boolean	equals(Object obj) 指示某个其他对象是否等于此比较器。
static <T extends Comparable<? super T>> Comparator<T>	naturalOrder() 返回一个以自然顺序比较Comparable对象的比较器 。
static <T> Comparator<T>	nullsFirst(Comparator<? super T> comparator) 返回一个空友好的比较是认为 null小于非空。
static <T> Comparator<T>	nullsLast(Comparator<? super T> comparator) 返回一个比较容易的比较器，它将 null设置为大于非空值。
default Comparator<T>	reversed() 返回一个比较器，强制该比较器的相反顺序。
static <T extends Comparable<? super T>> Comparator<T>	reverseOrder() 返回一个与 自然排序相反的比较器。
default Comparator<T>	thenComparing(Comparator<? super T> other) 用另一个比较器返回一个字典顺序比较器。
default <U extends Comparable<? super U>> Comparator<T>	thenComparing(Function<? super T,? extends U> keyExtractor) 返回具有提取 Comparable排序键的功能的 Comparable顺序比较器。
default <U> Comparator<T>	thenComparing(Function<? super T,? extends U> keyExtractor, Comparator<? super U> keyComparator) 返回具有提取要与给定 Comparator进行比较的键的功能的字典顺序比较 Comparator 。
default Comparator<T>	thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) 返回具有提取 double排序键的功能的 double顺序比较器。
default Comparator<T>	thenComparingInt(ToIntFunction<? super T> keyExtractor) 返回具有提取 int排序键的功能的 int顺序比较器。
default Comparator<T>	thenComparingLong(ToLongFunction<? super T> keyExtractor) 返回具有提取 long排序键的功能的 long顺序比较器。