Java8defaultmethods默认方法的概念与代码解析

一、基本概念  

创新互联建站专注于都昌企业网站建设,成都响应式网站建设公司,商城系统网站开发。都昌网站建设公司,为都昌等地区提供建站服务。全流程按需策划，专业设计，全程项目跟踪，创新互联建站专业和态度为您提供的服务

Default methods enable you to add new functionality to the interfaces of your libraries and ensure binary compatibility with code written for older versions of those interfaces.

默认方法使您能够添加新的功能到你现有库的接口中，并确保与采用老版本接口编写的代码的二进制兼容性。

什么是默认方法(default methods)

即接口可以有实现方法，而且不需要实现类去实现其方法。只需在方法名前面加个default关键字即可，这些方法默认是

为什么要有默认方法

为什么要有这个特性?首先，之前的接口是个双刃剑，好处是面向抽象而不是面向具体编程，缺陷是，当需要修改接口时候，需要修改全部实现该接口的类，目前的java 8之前的集合框架没有foreach方法，通常能想到的解决办法是在JDK里给相关的接口添加新的方法及实现。然而，对于已经发布的版本，是没法在给接口添加新方法的同时不影响已有的实现。所以引进的默认方法。他们的目的是为了解决接口的修改与现有的实现不兼容的问题

二、 java 8抽象类与接口的区别

相同点：

1.都是抽象类型;

2.都可以有实现方法（java8才可以）

3.都可以不需要实现类或者继承者去实现所有方法

不同点

1.抽象类不可以多重继承，接口可以(无论是多重类型继承还是多重行为继承);

2.抽象类和接口所反映出的设计理念不同。其实抽象类表示的是"is-a"关系，接口表示的是"like-a"关系;

3.接口中定义的变量默认是public static final 型，且必须给其初值，所以实现类中不能重新定义，也不能改变其值;抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。

三、多重继承的冲突说明

由于同一个方法可以从不同接口引入，自然而然的会有冲突的现象，默认方法判断冲突的规则如下：

1.一个声明在类里面的方法优先于任何默认方法(classes always win)

2.否则，则会优先选取***体的实现，比如下面的例子 B重写了A的hello方法。

四、如何扩展或实现带有默认方法的接口？

当前扩展一个默认方法的接口时，你可以采用以下三种方式：

1：让扩展类继承默认方法，根据不管是否存在默认方法

2：重新声明默认方法，使其变为一个抽象方法（注意，扩展类的实现类必须实现此方法）

3：重新定义默认方法，覆盖(override)父类的默认方法

五、默认方法样例代码

 
 
    
  
  
  1. import java.time.DateTimeException; 
    2. 
  
  
  2. import java.time.LocalDateTime; 
    3. 
  
  
  3. import java.time.ZoneId; 
    4. 
  
  
  4. import java.time.ZonedDateTime; 
    5. 
  
  
  5. 
  
  
  6. public interface TimeClient { 
    7. 
  
  
  7.     void setTime(int hour, int minute, int second); 
    8. 
  
  
  8. 
  
  
  9.     void setDate(int day, int month, int year); 
    10. 
  
  
  10. 
  
  
  11.     void setDateAndTime(int day, int month, int year, int hour, int minute, 
    12. 
  
  
  12.             int second); 
    13. 
  
  
  13. 
  
  
  14.     LocalDateTime getLocalDateTime(); 
    15. 
  
  
  15. 
  
  
  16.     static ZoneId getZoneId(String zoneString) { 
    17. 
  
  
  17.         try { 
    18. 
  
  
  18.             return ZoneId.of(zoneString); 
    19. 
  
  
  19.         } catch (DateTimeException e) { 
    20. 
  
  
  20.             System.err.println("Invalid time zone: " + zoneString 
    21. 
  
  
  21.                     + "; using default time zone instead."); 
    22. 
  
  
  22.             return ZoneId.systemDefault(); 
    23. 
  
  
  23.         } 
    24. 
  
  
  24.     } 
    25. 
  
  
  25. 
  
  
  26.     default ZonedDateTime getZonedDateTime(String zoneString) { 
    27. 
  
  
  27.         return ZonedDateTime.of(getLocalDateTime(), getZoneId(zoneString)); 
    28. 
  
  
  28.     } 
    29. 
  
  
  29. } 
    30. 
 
 
 
 
    
  
  
  1. import java.time.LocalDate; 
    2. 
  
  
  2. import java.time.LocalDateTime; 
    3. 
  
  
  3. import java.time.LocalTime; 
    4. 
  
  
  4. import java.util.ArrayList; 
    5. 
  
  
  5. import java.util.Collections; 
    6. 
  
  
  6. import java.util.Comparator; 
    7. 
  
  
  7. import java.util.List; 
    8. 
  
  
  8. 
  
  
  9. public class SimpleTimeClient implements TimeClient { 
    10. 
  
  
  10. 
  
  
  11.     private LocalDateTime dateAndTime; 
    12. 
  
  
  12. 
  
  
  13.     public SimpleTimeClient() { 
    14. 
  
  
  14.         dateAndTime = LocalDateTime.now(); 
    15. 
  
  
  15.     } 
    16. 
  
  
  16. 
  
  
  17.     public void setTime(int hour, int minute, int second) { 
    18. 
  
  
  18.         LocalDate currentDate = LocalDate.from(dateAndTime); 
    19. 
  
  
  19.         LocalTime timeToSet = LocalTime.of(hour, minute, second); 
    20. 
  
  
  20.         dateAndTime = LocalDateTime.of(currentDate, timeToSet); 
    21. 
  
  
  21.     } 
    22. 
  
  
  22. 
  
  
  23.     public void setDate(int year, int month, int day) { 
    24. 
  
  
  24.         LocalDate dateToSet = LocalDate.of(year, month, day); 
    25. 
  
  
  25.         LocalTime currentTime = LocalTime.from(dateAndTime); 
    26. 
  
  
  26.         dateAndTime = LocalDateTime.of(dateToSet, currentTime); 
    27. 
  
  
  27.     } 
    28. 
  
  
  28. 
  
  
  29.     public void setDateAndTime(int year, int month, int day, int hour, 
    30. 
  
  
  30.             int minute, int second) { 
    31. 
  
  
  31.         LocalDate dateToSet = LocalDate.of(year, month, day); 
    32. 
  
  
  32.         LocalTime timeToSet = LocalTime.of(hour, minute, second); 
    33. 
  
  
  33.         dateAndTime = LocalDateTime.of(dateToSet, timeToSet); 
    34. 
  
  
  34.     } 
    35. 
  
  
  35. 
  
  
  36.     public LocalDateTime getLocalDateTime() { 
    37. 
  
  
  37.         return dateAndTime; 
    38. 
  
  
  38.     } 
    39. 
  
  
  39. 
  
  
  40.     public String toString() { 
    41. 
  
  
  41.         return dateAndTime.toString(); 
    42. 
  
  
  42.     } 
    43. 
  
  
  43. 
  
  
  44.     public static void main(String... args) { 
    45. 
  
  
  45.         TimeClient client = new SimpleTimeClient(); 
    46. 
  
  
  46.         // 显示当前日期时间 
    47. 
  
  
  47.         System.out.println(client.toString()); 
    48. 
  
  
  48.         // 设置日期 
    49. 
  
  
  49.         client.setTime(11, 12, 22); 
    50. 
  
  
  50.         System.out.println(client); 
    51. 
  
  
  51.         // 设置时间 
    52. 
  
  
  52.         client.setDate(2012, 11, 12); 
    53. 
  
  
  53.         System.out.println(client); 
    54. 
  
  
  54. 
  
  
  55.         System.out.println("Time in Asia/Shanghai: "
    56. 
  
  
  56.                 + client.getZonedDateTime("Asia/Shanghai").toString()); 
    57. 
  
  
  57.     } 
    58. 
  
  
  58. } 
    59.

六、整合默认方法、静态方法到已经存在的接口

默认方法使您能够添加新的功能到已经存在的接口，确保与采用老版本这些接口编写的代码的二进制兼容性。特别是，默认的方法使您能够在已经存在的接口中添加使用lambda表达式作为参数的方法。下面的样例代码说明通过默认方法和静态方法，Comparator 接口是如何提供丰富的功能的。

在java8中，Compartor接口提供了丰富的功能，提供了差不多近20个默认或静态方法，在以前的版本中仅仅提供了compare(T o1, T o2)一个比较接口方法

下面的代码是有关扑克牌游戏中的洗牌，针对牌排序，打散，发牌的部分源代码

 
 
    
  
  
  1. package defaultmethods; 
    2. 
  
  
  2. 
  
  
  3. //扑克牌接口类 
    4. 
  
  
  4. public interface Card extends Comparable { 
    5. 
  
  
  5.      
    6. 
  
  
  6.     public enum Suit {  
    7. 
  
  
  7.         DIAMONDS (1, "Diamonds"),  
    8. 
  
  
  8.         CLUBS    (2, "Clubs"   ),  
    9. 
  
  
  9.         HEARTS   (3, "Hearts"  ),  
    10. 
  
  
  10.         SPADES   (4, "Spades"  ); 
    11. 
  
  
  11.          
    12. 
  
  
  12.         private final int value; 
    13. 
  
  
  13.         private final String text; 
    14. 
  
  
  14.         Suit(int value, String text) { 
    15. 
  
  
  15.             this.value = value; 
    16. 
  
  
  16.             this.text = text; 
    17. 
  
  
  17.         } 
    18. 
  
  
  18.         public int value() {return value;} 
    19. 
  
  
  19.         public String text() {return text;} 
    20. 
  
  
  20.     } 
    21. 
  
  
  21.      
    22. 
  
  
  22.     public enum Rank {  
    23. 
  
  
  23.         DEUCE  (2 , "Two"  ), 
    24. 
  
  
  24.         THREE  (3 , "Three"),  
    25. 
  
  
  25.         FOUR   (4 , "Four" ),  
    26. 
  
  
  26.         FIVE   (5 , "Five" ),  
    27. 
  
  
  27.         SIX    (6 , "Six"  ),  
    28. 
  
  
  28.         SEVEN  (7 , "Seven"), 
    29. 
  
  
  29.         EIGHT  (8 , "Eight"),  
    30. 
  
  
  30.         NINE   (9 , "Nine" ),  
    31. 
  
  
  31.         TEN    (10, "Ten"  ),  
    32. 
  
  
  32.         JACK   (11, "Jack" ), 
    33. 
  
  
  33.         QUEEN  (12, "Queen"),  
    34. 
  
  
  34.         KING   (13, "King" ), 
    35. 
  
  
  35.         ACE    (14, "Ace"  ); 
    36. 
  
  
  36.         private final int value; 
    37. 
  
  
  37.         private final String text; 
    38. 
  
  
  38.         Rank(int value, String text) { 
    39. 
  
  
  39.             this.value = value; 
    40. 
  
  
  40.             this.text = text; 
    41. 
  
  
  41.         } 
    42. 
  
  
  42.         public int value() {return value;} 
    43. 
  
  
  43.         public String text() {return text;} 
    44. 
  
  
  44.     } 
    45. 
  
  
  45.      
    46. 
  
  
  46.     public Card.Suit getSuit(); 
    47. 
  
  
  47.     public Card.Rank getRank(); 
    48. 
  
  
  48. } 
    49. 
 
 
 
 
    
  
  
  1. package defaultmethods; 
    2. 
  
  
  2. 
  
  
  3. import java.util.Comparator; 
    4. 
  
  
  4. import java.util.List; 
    5. 
  
  
  5. import java.util.Map; 
    6. 
  
  
  6. 
  
  
  7. //牌桌接口类 
    8. 
  
  
  8. public interface Deck { 
    9. 
  
  
  9.      
    10. 
  
  
  10.     List getCards(); 
    11. 
  
  
  11.     Deck deckFactory(); 
    12. 
  
  
  12.     int size(); 
    13. 
  
  
  13.     void addCard(Card card); 
    14. 
  
  
  14.     void addCards(List cards); 
    15. 
  
  
  15.     void addDeck(Deck deck); 
    16. 
  
  
  16.     void shuffle(); 
    17. 
  
  
  17.     void sort(); 
    18. 
  
  
  18.     void sort(Comparator c); 
    19. 
  
  
  19.     String deckToString(); 
    20. 
  
  
  20. 
  
  
  21.     Map deal(int players, int numberOfCards) 
    22. 
  
  
  22.         throws IllegalArgumentException; 
    23. 
  
  
  23. 
  
  
  24. } 
    25. 
  
  
  25. 
 
 
 
 
    
  
  
  1. package defaultmethods; 
    2. 
  
  
  2. 
  
  
  3. import java.util.Comparator; 
    4. 
  
  
  4. 
  
  
  5. //先根据rank,再根据suit进行比较 
    6. 
  
  
  6. public class SortByRankThenSuit implements Comparator { 
    7. 
  
  
  7.     public int compare(Card firstCard, Card secondCard) { 
    8. 
  
  
  8.         int compVal = firstCard.getRank().value() 
    9. 
  
  
  9.                 - secondCard.getRank().value(); 
    10. 
  
  
  10.         if (compVal != 0) 
    11. 
  
  
  11.             return compVal; 
    12. 
  
  
  12.         else
    13. 
  
  
  13.             return firstCard.getSuit().value() - secondCard.getSuit().value(); 
    14. 
  
  
  14.     } 
    15. 
  
  
  15. } 
    16. 
 
 
 
 
    
  
  
  1. package defaultmethods; 
    2. 
  
  
  2. 
  
  
  3. //扑克牌实现类 
    4. 
  
  
  4. public class PlayingCard implements Card { 
    5. 
  
  
  5. 
  
  
  6.     private Card.Rank rank; 
    7. 
  
  
  7.     private Card.Suit suit; 
    8. 
  
  
  8. 
  
  
  9.     public PlayingCard(Card.Rank rank, Card.Suit suit) { 
    10. 
  
  
  10.         this.rank = rank; 
    11. 
  
  
  11.         this.suit = suit; 
    12. 
  
  
  12.     } 
    13. 
  
  
  13. 
  
  
  14.     public Card.Suit getSuit() { 
    15. 
  
  
  15.         return suit; 
    16. 
  
  
  16.     } 
    17. 
  
  
  17. 
  
  
  18.     public Card.Rank getRank() { 
    19. 
  
  
  19.         return rank; 
    20. 
  
  
  20.     } 
    21. 
  
  
  21. 
  
  
  22.     public boolean equals(Object obj) { 
    23. 
  
  
  23.         if (obj instanceof Card) { 
    24. 
  
  
  24.             if (((Card) obj).getRank() == this.rank 
    25. 
  
  
  25.                     && ((Card) obj).getSuit() == this.suit) { 
    26. 
  
  
  26.                 return true; 
    27. 
  
  
  27.             } else { 
    28. 
  
  
  28.                 return false; 
    29. 
  
  
  29.             } 
    30. 
  
  
  30.         } else { 
    31. 
  
  
  31.             return false; 
    32. 
  
  
  32.         } 
    33. 
  
  
  33.     } 
    34. 
  
  
  34. 
  
  
  35.     public int hashCode() { 
    36. 
  
  
  36.         return ((suit.value() - 1) * 13) + rank.value(); 
    37. 
  
  
  37.     } 
    38. 
  
  
  38. 
  
  
  39.     //实现比较接口 
    40. 
  
  
  40.     public int compareTo(Card o) { 
    41. 
  
  
  41.         return this.hashCode() - o.hashCode(); 
    42. 
  
  
  42.     } 
    43. 
  
  
  43. 
  
  
  44.     //重载toString 
    45. 
  
  
  45.     public String toString() { 
    46. 
  
  
  46.         return this.rank.text() + " of " + this.suit.text(); 
    47. 
  
  
  47.     } 
    48. 
  
  
  48. 
  
  
  49.     public static void main(String... args) { 
    50. 
  
  
  50.         new PlayingCard(Rank.ACE, Suit.DIAMONDS); 
    51. 
  
  
  51.         new PlayingCard(Rank.KING, Suit.SPADES); 
    52. 
  
  
  52.     } 
    53. 
  
  
  53. } 
    54. 
 
 
 
 
    
  
  
  1. package defaultmethods; 
    2. 
  
  
  2. 
  
  
  3. import java.util.ArrayList; 
    4. 
  
  
  4. import java.util.Collections; 
    5. 
  
  
  5. import java.util.Comparator; 
    6. 
  
  
  6. import java.util.HashMap; 
    7. 
  
  
  7. import java.util.List; 
    8. 
  
  
  8. import java.util.Map; 
    9. 
  
  
  9. import java.util.stream.Collectors; 
    10. 
  
  
  10. 
  
  
  11. //牌桌实现类 
    12. 
  
  
  12. public class StandardDeck implements Deck { 
    13. 
  
  
  13. 
  
  
  14.     //扑克牌列表 
    15. 
  
  
  15.     private List entireDeck; 
    16. 
  
  
  16. 
  
  
  17.     public StandardDeck(List existingList) { 
    18. 
  
  
  18.         this.entireDeck = existingList; 
    19. 
  
  
  19.     } 
    20. 
  
  
  20. 
  
  
  21.     public StandardDeck() { 
    22. 
  
  
  22.         this.entireDeck = new ArrayList<>(); 
    23. 
  
  
  23.         for (Card.Suit s : Card.Suit.values()) { 
    24. 
  
  
  24.             for (Card.Rank r : Card.Rank.values()) { 
    25. 
  
  
  25.                 this.entireDeck.add(new PlayingCard(r, s)); 
    26. 
  
  
  26.             } 
    27. 
  
  
  27.         } 
    28. 
  
  
  28.     } 
    29. 
  
  
  29. 
  
  
  30.     public Deck deckFactory() { 
    31. 
  
  
  31.         return new StandardDeck(new ArrayList()); 
    32. 
  
  
  32.     } 
    33. 
  
  
  33. 
  
  
  34.     public int size() { 
    35. 
  
  
  35.         return entireDeck.size(); 
    36. 
  
  
  36.     } 
    37. 
  
  
  37. 
  
  
  38.     public List getCards() { 
    39. 
  
  
  39.         return entireDeck; 
    40. 
  
  
  40.     } 
    41. 
  
  
  41. 
  
  
  42.     public void addCard(Card card) { 
    43. 
  
  
  43.         entireDeck.add(card); 
    44. 
  
  
  44.     } 
    45. 
  
  
  45. 
  
  
  46.     public void addCards(List cards) { 
    47. 
  
  
  47.         entireDeck.addAll(cards); 
    48. 
  
  
  48.     } 
    49. 
  
  
  49. 
  
  
  50.     public void addDeck(Deck deck) { 
    51. 
  
  
  51.         List listToAdd = deck.getCards(); 
    52. 
  
  
  52.         entireDeck.addAll(listToAdd); 
    53. 
  
  
  53.     } 
    54. 
  
  
  54. 
  
  
  55.     public void sort() { 
    56. 
  
  
  56.         Collections.sort(entireDeck); 
    57. 
  
  
  57.     } 
    58. 
  
  
  58. 
  
  
  59.     public void sort(Comparator c) { 
    60. 
  
  
  60.         Collections.sort(entireDeck, c); 
    61. 
  
  
  61.     } 
    62. 
  
  
  62. 
  
  
  63.     public void shuffle() { 
    64. 
  
  
  64.         Collections.shuffle(entireDeck); 
    65. 
  
  
  65.     } 
    66. 
  
  
  66. 
  
  
  67.     //为每位玩家分牌 
    68. 
  
  
  68.     public Map deal(int players, int numberOfCards) 
    69. 
  
  
  69.             throws IllegalArgumentException { 
    70. 
  
  
  70.         int cardsDealt = players * numberOfCards; 
    71. 
  
  
  71.         int sizeOfDeck = entireDeck.size(); 
    72. 
  
  
  72.          
    73. 
  
  
  73.         if (cardsDealt > sizeOfDeck) { 
    74. 
  
  
  74.             throw new IllegalArgumentException("Number of players (" + players 
    75. 
  
  
  75.                     + ") times number of cards to be dealt (" + numberOfCards 
    76. 
  
  
  76.                     + ") is greater than the number of cards in the deck ("
    77. 
  
  
  77.                     + sizeOfDeck + ")."); 
    78. 
  
  
  78.         } 
    79. 
  
  
  79.         //把牌分成几份 
    80. 
  
  
  80.         int slices=players+1; 
    81. 
  
  
  81.         if(cardsDealt == sizeOfDeck) 
    82. 
  
  
  82.             slices=players; 
    83. 
  
  
  83. 
  
  
  84.         //根据玩家的个数，每个玩家分到的扑克牌数进行分牌 
    85. 
  
  
  85.         Map> dealtDeck = entireDeck.stream().collect( 
    86. 
  
  
  86.                 Collectors.groupingBy(card -> { 
    87. 
  
  
  87.                     int cardIndex = entireDeck.indexOf(card); 
    88. 
  
  
  88.                     if (cardIndex >= cardsDealt) 
    89. 
  
  
  89.                         return (players + 1); 
    90. 
  
  
  90.                     else
    91. 
  
  
  91.                         return (cardIndex % players) + 1; 
    92. 
  
  
  92.                 })); 
    93. 
  
  
  93.         System.out.println(dealtDeck); 
    94. 
  
  
  94.         // Convert Map> to Map 
    95. 
  
  
  95.         Map mapToReturn = new HashMap<>(); 
    96. 
  
  
  96. 
  
  
  97.         for (int i = 1; i < (slices + 1); i++) { 
    98. 
  
  
  98.             Deck currentDeck = deckFactory(); 
    99. 
  
  
  99.             currentDeck.addCards(dealtDeck.get(i)); 
    100. 
  
  
  100.             mapToReturn.put(i, currentDeck); 
    101. 
  
  
  101.         } 
    102. 
  
  
  102.         return mapToReturn; 
    103. 
  
  
  103.     } 
    104. 
  
  
  104. 
  
  
  105.     public String deckToString() { 
    106. 
  
  
  106.         return this.entireDeck.stream().map(Card::toString) 
    107. 
  
  
  107.                 .collect(Collectors.joining("\n")); 
    108. 
  
  
  108.     } 
    109. 
  
  
  109.      
    110. 
  
  
  110.     public String toString(){ 
    111. 
  
  
  111.         return deckToString(); 
    112. 
  
  
  112.     } 
    113. 
  
  
  113. 
  
  
  114.     public static void main(String... args) { 
    115. 
  
  
  115.         System.out.println("Creating deck:"); 
    116. 
  
  
  116.         StandardDeck myDeck = new StandardDeck(); 
    117. 
  
  
  117.          
    118. 
  
  
  118.         myDeck.sort(); 
    119. 
  
  
  119.         System.out.println("Sorted deck"); 
    120. 
  
  
  120.         System.out.println(myDeck.deckToString()); 
    121. 
  
  
  121.          
    122. 
  
  
  122.         myDeck.shuffle(); 
    123. 
  
  
  123.         myDeck.sort(new SortByRankThenSuit()); 
    124. 
  
  
  124.         System.out.println("Sorted by rank, then by suit"); 
    125. 
  
  
  125.         System.out.println(myDeck.deckToString()); 
    126. 
  
  
  126.          
    127. 
  
  
  127.         myDeck.shuffle(); 
    128. 
  
  
  128.         myDeck.sort(Comparator.comparing(Card::getRank).thenComparing( 
    129. 
  
  
  129.                 Comparator.comparing(Card::getSuit))); 
    130. 
  
  
  130.         System.out.println("Sorted by rank, then by suit "
    131. 
  
  
  131.                 + "with static and default methods"); 
    132. 
  
  
  132.         System.out.println(myDeck.deckToString()); 
    133. 
  
  
  133. 
  
  
  134.         myDeck.sort(Comparator.comparing(Card::getRank).reversed() 
    135. 
  
  
  135.                 .thenComparing(Comparator.comparing(Card::getSuit).reversed())); 
    136. 
  
  
  136.         System.out.println("Sorted by rank reversed, then by suit "
    137. 
  
  
  137.                 + "with static and default methods"); 
    138. 
  
  
  138.         System.out.println(myDeck.deckToString()); 
    139. 
  
  
  139.          
    140. 
  
  
  140.         myDeck.shuffle(); 
    141. 
  
  
  141.         myDeck.sort( 
    142. 
  
  
  142.             (firstCard, secondCard) -> 
    143. 
  
  
  143.                 firstCard.getRank().value() - secondCard.getRank().value() 
    144. 
  
  
  144.         );  
    145. 
  
  
  145.         System.out.println(myDeck.deckToString()); 
    146. 
  
  
  146.          
    147. 
  
  
  147.         myDeck.shuffle(); 
    148. 
  
  
  148.         myDeck.sort(Comparator.comparing(Card::getRank)); 
    149. 
  
  
  149.         System.out.println(myDeck.deckToString()); 
    150. 
  
  
  150.          
    151. 
  
  
  151.         Map map=myDeck.deal(4, 11); 
    152. 
  
  
  152.         for(Map.Entry item:map.entrySet()){ 
    153. 
  
  
  153.             System.out.println(item.getKey()); 
    154. 
  
  
  154.             System.out.println(item.getValue()); 
    155. 
  
  
  155.             System.out.println("-------------------------------"); 
    156. 
  
  
  156.         } 
    157. 
  
  
  157.     } 
    158. 
  
  
  158. } 
    159.

七、参考

http://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html

http://docs.oracle.com/javase/tutorial/java/IandI/defaultmethods.html

http://docs.oracle.com/javase/tutorial/java/TOC.html

标题名称：Java8defaultmethods默认方法的概念与代码解析
当前路径：http://www.shufengxianlan.com/qtweb/news1/276751.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站收录知识

行业网站建设

服务器租凭　　 　成都橡塑保温板　　 　温江网站建设　　 　华泰海航　　 　成都全屋定制　　 　成都网站建设　　 　达州主机托管　　 　香港云主机　　 　成都做网站　　 　成都外贸网站建设　　 　绵阳服务器托管　　 　上市集团网站建设　　 　云主机　　 　成都网站建设　　 　成都微信二次开发公司　　 　精灵网　　 　乐山网站建设　　 　网站seo优化　　 　java虚拟主机　　 　买链接