Java8新特性(1).Lambda表达式介绍、函数式接口和接口默认方法和静态方法

发表于   |   分类于 左手代码 java   |   阅读(147)   |   评论(0)

一、Lambda表达式

1.什么是lambda表达式

lambda表达式是一种匿名函数表达式

2.lambda表达式语法
  • 无参 : ()-> expression
  • 有参 ：(parameters)-> {statement;}
  1. /**
  2.  * 定义一个标签tag类
  3.  */
  4. class Tag {
  5.     private int tagId;
  6.     private String tagName;
  7.     private int weight;
  9.     public Tag(int tagId, String tagName, int weight) {
  10.         this.tagId = tagId;
  11.         this.tagName = tagName;
  12.         this.weight = weight;
  13.     }
  15.     public int getTagId() {
  16.         return tagId;
  17.     }
  19.     public void setTagId(int tagId) {
  20.         this.tagId = tagId;
  21.     }
  23.     public String getTagName() {
  24.         return tagName;
  25.     }
  27.     public void setTagName(String tagName) {
  28.         this.tagName = tagName;
  29.     }
  31.     public int getWeight() {
  32.         return weight;
  33.     }
  35.     public void setWeight(int weight) {
  36.         this.weight = weight;
  37.     }
  39.     @Override
  40.     public String toString() {
  41.         return "Tag{" +
  42.                 "tagId=" + tagId +
  43.                 ", tagName='" + tagName + '\'' +
  44.                 ", weight=" + weight +
  45.                 '}';
  46.     }
  47. }
  49. public class LambdaDemo {
  50.     public static void main(String[] args) {
  51.         List<Tag> tagList = new ArrayList<Tag>(10);
  52.         tagList.add(new Tag(1001, "JAVA", 15));
  53.         tagList.add(new Tag(1002, "Golang", 10));
  54.         tagList.add(new Tag(1003, "Lua", 17));
  55.         tagList.add(new Tag(1004, "PHP", 11));
  56.         tagList.add(new Tag(1005, "Node.js", 13));
  57.         /**
  58.          * 1.通过匿名函数来排序
  59.          */
  60.         Collections.sort(tagList, new Comparator<Tag>() {
  61.             @Override
  62.             public int compare(Tag o1, Tag o2) {
  63.                 if (o1.getWeight() > o2.getWeight()) {
  64.                     return -1;
  65.                 } else if (o1.getWeight() == o2.getWeight()) {
  66.                     return 0;
  67.                 } else {
  68.                     return 1;
  69.                 }
  70.             }
  71.         });
  72.         System.out.println(tagList); //[Tag{tagId=1003, tagName='Lua', weight=17}, Tag{tagId=1001, tagName='JAVA', weight=15}, Tag{tagId=1005, tagName='Node.js', weight=13}, Tag{tagId=1004, tagName='PHP', weight=11}, Tag{tagId=1002, tagName='Golang', weight=10}]
  75.         /**
  76.          * 2.通过lambda表达式来实现排序
  77.          */
  78.         Collections.sort(tagList, (t1, t2)-> t2.getWeight() - t1.getWeight());
  79.         System.out.println(tagList);
  80.     }
  81. }

二、函数式接口

1.什么是函数式接口

函数接口是一种特殊的接口，它有且仅有一个接象方法(因为java8及以后，接口可以有默认方法，因此它可以有其他的默认方法)

  1. @FunctionalInterface
  2. interface Sortable<T> {
  3.     public T sort(T obj);
  4. }

如：上例中这个Sortable接口中只有一个sort抽象方法

2.函数式接口声明

通过注解 @FunctionInterface 来声明

  1. @FunctionalInterface
  2. interface Testable<T> {
  3.     public boolean test(T obj);
  4. }
3.常用的函数式接口
(1) Predicate 接口
  • 主要作用：测试输入对象是否符合某个条件
  • 主要方法：
    • 抽象方法: test
    • 默认方法
      • negate : 不符合指定条件时为true
      • and : 多个条件都满足
      • or : 多个条件有一个满足
  1.         /**
  2.          * 1.使用传统的匿名函数
  3.          */
  4.         Predicate<String> isNumber = new Predicate<String>() {
  5.             @Override
  6.             public boolean test(String s) {
  7.                 if (s == null || s.length() < 1) {
  8.                     return false;
  9.                 }
  10.                 return s.matches("\\d+");
  11.             }
  12.         };
  14.         /**
  15.          * 2.使用lambda表达式(是否为中包含数字的字符串)
  16.          */
  17.         Predicate<String> isNumberString = x -> x.matches("\\d+");
  19.         /**
  20.          * 字符串是否为5位
  21.          */
  22.         Predicate<String> isFifth = x -> x.length() == 5;
  24.         /**
  25.          * 是否只包括英文字母
  26.          */
  27.         Predicate<String> isLetter = x -> x.matches("[A-Za-z]+");
  29.         /**
  30.          * 1.直接调用Predicate接口的test方法
  31.          */
  32.         System.out.println(isNumber.test("123456"));
  33.         System.out.println(isNumberString.test("456"));
  35.         /**
  36.          * 2.使用and方法
  37.          */
  38.         System.out.println(isNumber.and(isFifth).test("12345"));  //true (是5位的数字字符串)
  40.         /**
  41.          * 3.使用or方法
  42.          */
  43.         System.out.println(isNumber.or(isLetter).test("Abcd"));        //true (数字或者英文字母)
  44.         System.out.println(isNumber.or(isLetter).test("Abcd14"));      //false
  46.         /**
  47.          * 4.使用negate方法
  48.          */
  49.         System.out.println(isNumber.negate().test("123456"));           //false (不是数字)
  50.         System.out.println(isNumber.negate().test("ABc"));              //true
(2)Supplier接口
  • 主要作用：创建对象，类似于对象工厂
  • 主要方法：get
  1. Supplier<String> strSupplier = ()->"hello supplier";
  2. System.out.println(strSupplier.get());  //hello supplier
  4. Supplier<Record> recordSupplier = () -> new Record();
  5. System.out.println(recordSupplier.get());
(3)Consumer接口
  • 主要作用：接收一个参数，对参数进行处理，但不返回(类似于一个消费的接口，只不过不需要反馈消费结果)
  • 主要方法：
    • accept : 接收参数，并进行处理
    • andThen : 接收另外一个Consumer接口，先处理当前接口的accept方法，再处理接收的Consumer接口
  1. Consumer<String> stringConsumer = s -> System.out.println("accepted:"+s);
  2. stringConsumer.accept("开奖了");    //accepted:开奖了
  4. Consumer<String> afterConsumer = s -> System.out.println("after:"+s);
  5. stringConsumer.andThen(afterConsumer).accept("中奖了");
  6. /**
  7. * accepted:中奖了
  8. * after:中奖了
  9. */
(4)Function接口
  • 主要作用：定义函数对象，生成一个Function对象
  • 主要方法：
    • apply : 将Function对象应用到输入的参数上，然后返回计算结果
    • andThen : 两个函数对象进行组合操作
  1. /**
  2.  * 游戏记录
  3.  */
  4. class ActivityRecord {
  5.     /**
  6.      * 记录ID
  7.      */
  8.     private Long recordId;
  9.     /**
  10.      * 用户ID
  11.      */
  12.     private Long userId;
  13.     /**
  14.      * 结果
  15.      */
  16.     private Integer result;
  17.     /**
  18.      * 时长
  19.      */
  20.     private Integer period;
  21.     /**
  22.      * 得分
  23.      */
  24.     private Integer score;
  25.     /**
  26.      * 创建时间
  27.      */
  28.     private Long createTime;
  30.     public ActivityRecord(Long recordId, Long userId, Integer result, Integer period, Integer score, Long createTime) {
  31.         this.recordId = recordId;
  32.         this.userId = userId;
  33.         this.result = result;
  34.         this.period = period;
  35.         this.score = score;
  36.         this.createTime = createTime;
  37.     }
  39.     public Long getRecordId() {
  40.         return recordId;
  41.     }
  43.     public void setRecordId(Long recordId) {
  44.         this.recordId = recordId;
  45.     }
  47.     public Long getUserId() {
  48.         return userId;
  49.     }
  51.     public void setUserId(Long userId) {
  52.         this.userId = userId;
  53.     }
  55.     public Integer getResult() {
  56.         return result;
  57.     }
  59.     public void setResult(Integer result) {
  60.         this.result = result;
  61.     }
  63.     public Integer getPeriod() {
  64.         return period;
  65.     }
  67.     public void setPeriod(Integer period) {
  68.         this.period = period;
  69.     }
  71.     public Integer getScore() {
  72.         return score;
  73.     }
  75.     public void setScore(Integer score) {
  76.         this.score = score;
  77.     }
  79.     public Long getCreateTime() {
  80.         return createTime;
  81.     }
  83.     public void setCreateTime(Long createTime) {
  84.         this.createTime = createTime;
  85.     }
  87.     @Override
  88.     public String toString() {
  89.         return "ActivityRecord{" +
  90.                 "recordId=" + recordId +
  91.                 ", userId=" + userId +
  92.                 ", result=" + result +
  93.                 ", period=" + period +
  94.                 ", score=" + score +
  95.                 ", createTime=" + createTime +
  96.                 '}';
  97.     }
  98. }
  100. /**
  101.  * 按创建时间由小到大排序
  102.  */
  103. class SortByCreateTime implements Function<List<ActivityRecord>, List<ActivityRecord>> {
  104.     @Override
  105.     public List<ActivityRecord> apply(List<ActivityRecord> activityRecordList) {
  106.         return activityRecordList.stream().sorted(Comparator.comparing(ActivityRecord::getCreateTime)).collect(Collectors.toList());
  107.     }
  108. }
  110. /**
  111.  * 按分数倒序排列
  112.  */
  113. class SortByScore implements Function<List<ActivityRecord>, List<ActivityRecord>> {
  114.     @Override
  115.     public List<ActivityRecord> apply(List<ActivityRecord> activityRecordList) {
  116.         return activityRecordList.stream().sorted(Comparator.comparing(ActivityRecord::getScore).reversed()).collect(Collectors.toList());
  117.     }
  118. }
  120. public class FunctionDemo {
  122.   public static void main(String[] args) {
  123.     List<ActivityRecord> recordList = new ArrayList<ActivityRecord>(5);
  124.         int now = LocalDateTime.now().getNano();
  125.         recordList.add(new ActivityRecord(1001L, 3500452001L, 1, 30, 1558, Long.valueOf(now)));
  126.         recordList.add(new ActivityRecord(1002L, 3500462001L, 0, 130, 3600, Long.valueOf(now - 1000)));
  127.         recordList.add(new ActivityRecord(1003L, 3501452001L, 0, 350, 12, Long.valueOf(now + 2000)));
  128.         recordList.add(new ActivityRecord(1004L, 3300452001L, 1, 10, 300, Long.valueOf(now - 5000)));
  130.         SortByCreateTime sortByCreateTime = new SortByCreateTime();
  131.         SortByScore sortByScore = new SortByScore();
  132.         System.out.println(sortByCreateTime.apply(recordList));
  133.         System.out.println(sortByScore.apply(recordList));
  135.         System.out.println(sortByCreateTime.andThen(sortByScore).apply(recordList));
  136.   }
  137. }
(5)Comparator接口
  • 主要作用：用于比较和排序等(后面和stream一起使用再详细说明)

三、接口默认方法

注：java8之前，接口只能包括抽象方法，不能包含实例方法或静态方法，如下

  1. interface TagService {
  2.     /**
  3.      * 查询标签列表
  4.      * @return
  5.      */
  6.     public List queryList();
  8.     /**
  9.      * 获取某个标签
  10.      * @param tagId
  11.      * @return
  12.      */
  13.     public Tag get(int tagId);
  15.     /**
  16.      * 添加标签
  17.      * @param tag
  18.      * @return
  19.      */
  20.     public int add(Tag tag);
  22.     /**
  23.      * 修改标签
  24.      * @param tag
  25.      * @return
  26.      */
  27.     public int update(Tag tag);
  29.     /**
  30.      * 删除标签
  31.      * @param tagId
  32.      * @return
  33.      */
  34.     public int delete(int tagId);
  35. }

java8以后，接口不仅有抽象方法，也可以有默认方法(实例方法)和静态方法

1.接口默认方法
  • 使用关键词default来修饰，在方法返回类型之前
  1. public default returnType methodName() {
  3. }
  1. interface TagVService {
  2.     public default void print() {
  3.         System.out.println("hello default method");
  4.     }
  5. }

作用：有一些默认实现的方法，不需要所有的实现都由实现类来完成

在java标准类库中有很多接口有默认方法，如比较器接口Comparator

  • thenComparing : 多个比较条件
  • reversed ： 倒序
2.接口静态方法

接口可以像普通类一样有静态方法

  1. interface TagVService {
  3.     public static String getDefault() {
  4.         return "default";
  5.     }
  6. }

在java标准类库中有很多接口有静态方法，如比较器接口Comparator

  • Comparator.comparing() : 比较
  • Comparator.comparingInt() : 比较整数
  • Comparator.comparingLong() : 比较长整数
  • Comparator.comparingDouble : 比较双精度浮点数
  • Comparator.naturalOrder() : 正序排列
  • Comparator.reverseOrder() : 倒序排列

专题 更多...

分类 更多...

展开

标签 更多...

归档 更多...

展开