JAVA8 in Action:行为参数化,匿名类及lambda表达式的初步认知实例整理

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

/**
 * Created by Administrator on 2017/8/19 0013.
 */
public class Test {
 /*************************************JAVA8 in Action:行为参数化,匿名类及lambda表达式的初步认知实例整理*****************************/
 /**首先了解的几个概念:
  *     1.行为参数化:就是一个方法接受多个不同的行为作为参数,并在内部是使用它们,完成不同行为的能力,是一种可以帮助你处理频繁的需求变更的一种软件开发模式;
  *     2.匿名类:与我们所熟悉的java局部类差不多,但是匿名类没有名字,它允许你同事声明并实例化一个类(随用随建);
  *     3.ambda表达式:由参数,箭头和主体组成,如:(Apple a1,Apple a2)   ->    a1.getWeight().compareTo(a2.getWeight());
  *                                               ----lambda参数------  -箭头-  -------------lambda主体---------------
  * */
  //我们以实现从一个列表中筛选出绿苹果作为例子:
    //1.基础数据
    //创建苹果实体类
    class Apple{
        private String color;
        private double weight;
        public String getColor() {
            return color;
        }
        public void setColor(String color) {
            this.color = color;
        }
        public double getWeight() {
            return weight;
        }
        public void setWeight(double weight) {
            this.weight = weight;
        }

        public Apple(String color, double weight) {
            this.color = color;
            this.weight = weight;
        }
    }
    //2.由浅入深的实例:
    //初级做法:仅仅只能用于选出绿色的苹果
        public static List<Apple> chooseGreenApple(List<Apple> apples){
            List<Apple> result = new ArrayList<Apple>();//用于盛放筛选出来的绿苹果的集合
            for(Apple apple:apples){
                if("green".equals(apple.getColor())){//选出绿苹果放入到集合中
                    result.add(apple);
                }
            }
            return result;
        }
  //一级拓展:以颜色作为参数,可以根据参数选出想要的颜色的苹果
      public static List<Apple> choseAppleByColor(List<Apple> apples,String color){
          List<Apple> result = new ArrayList<Apple>();//用于盛放筛选出来的绿苹果的集合
          for(Apple apple:apples){
              if(color.equals(apple.getColor())){//根据参数选出所需要的苹果放入到集合中
                  result.add(apple);
              }
          }
            return result;
      }
  //二级拓展,对多个属性进行筛选(如颜色,重量)
        public static List<Apple> chooseApples(List<Apple> apples,String color, double weight,boolean flag){//谓词flag用于区分根据颜色还是根据重量筛选
            List<Apple> result = new ArrayList<Apple>();//用于盛放筛选出来的苹果的集合
            for(Apple apple:apples){
                //根据flag确定使用以哪个参数为依据来选出所需要的苹果放入到集合中
                if((flag && color.equals(apple.getColor())) || (!flag && apple.getWeight() > weight)){
                    result.add(apple);
                }
            }
            return result;
        }
    //三级拓展,根据抽象条件进行筛选:
        //定义一个接口来对选择标准建模:
        public interface  ApplePredicate{
            boolean test (Apple apple);
        }
        //以ApplePredicate的多个不同的实现来代表不同的选择标准
        //仅仅用来选出重的苹果
        public class AppleHeavy implements  ApplePredicate{
           public boolean test (Apple apple){
               return apple.getWeight() > 180;
           }
        }
        //如果仅仅用来选出绿色的苹果
        public class AppleColor implements  ApplePredicate{
            public boolean test (Apple apple){
                return "green".equals(apple.getColor());
            }
        }
        //在利用ApplePredicte改过之后,该方法就变成了这个样子,
        // 我们在使用的时候只需要创建不同个ApplePredicate对象,将他传递给chooseApples方法即可,大大的增加了他的灵活性
        public static List<Apple> chooseApples(List<Apple> apples, ApplePredicate predicate){
            List<Apple> result = new ArrayList<Apple>();//用于盛放筛选出来的苹果的集合
            for(Apple apple:apples){
                if(predicate.test(apple)){
                    result.add(apple);
                }
            }
            return result;
        }
    //终极超级酷炫拓展,将List类型抽象化
        public interface  predicatre<T>{
            boolean test(T t);
        }
         public static <T> List<T> chooseSomeThind(List<T> list, Predicate<T> p){
             List<T> result = new ArrayList<T>();
             for(T e:list){
                 if(p.test(e)){
                     result.add(e);
                 }
             }
            return result;
         }
    @org.junit.Test
    public void testChooseAppleByWhatYouWant(){
        //创建集合:
        List<Apple> appleList = Arrays.asList(new Apple("green",200),new Apple("red",150));
        //初级做法:仅仅只能用于选出绿色的苹果
            List<Apple> greenApples__1 = chooseGreenApple(appleList);
        //一级拓展:以颜色作为参数,可以根据参数选出想要的颜色的苹果
            //例如筛选出红苹果:
            List<Apple> greenApples__2 = choseAppleByColor(appleList,"red");
        //二级拓展,对多个属性进行筛选(如颜色,重量)
            //例如筛选出红苹果:
            List<Apple> greenApples__13 = chooseApples(appleList,"red",0,true);
            //例如筛选出重苹果:
            List<Apple> weightApples__1 = chooseApples(appleList,"",180,false);
        //三级拓展,根据抽象条件进行筛选:
            //例如筛选出绿苹果:
            List<Apple> greenApples = chooseApples(appleList,new AppleColor());
            //例如筛选出重苹果:
            List<Apple> weightApples_1 = chooseApples(appleList,new AppleHeavy());
        //四级拓展,使用匿名类同时声明和实例化一个类:(可以让你无需事先实例化,随用随建,提高效率)
            List<Apple> weightApples_2 = chooseApples(appleList, new ApplePredicate() {
                public boolean test(Apple apple) {return apple.getWeight() > 180;}
            });
        //五级拓展,使用lambda表达式:(显得更加干净整洁)
        //选出绿色的苹果
           List<Apple> weightApples_3 = chooseApples(appleList,(Apple apple) -> "green".equals(apple.getColor()));
        //终极超级酷炫拓展,将List类型抽象化:
            //类型抽象化后,你可以广泛的推广了,可以用在西瓜上,汽车上,Integer,String。。。。。。。。。。。。
             //例如:筛选出集合中包含“e”的单词集合:
             List<String> stringList = Arrays.asList("one","two","three","four");
             List<String> include_e = chooseSomeThind(stringList,(String str)-> str.contains("e"));
            //例如:筛选出集合中大于5的数字的集合:
            List<Integer> integersList = Arrays.asList(1,2,3,4,5,6,7,8,10);
            List<Integer> bigerThan_5 = chooseSomeThind(integersList,(Integer a)-> a>5);
            System.out.print("非常完美!");
    }

}

转自:https://blog.csdn.net/qq_37107280/article/details/77417500

原文地址:https://www.cnblogs.com/shundong106/p/9853126.html

时间: 2024-10-10 11:16:12

JAVA8 in Action:行为参数化,匿名类及lambda表达式的初步认知实例整理的相关文章

(转)C#中的委托,匿名方法和Lambda表达式

简介 在.NET中,委托,匿名方法和Lambda表达式很容易发生混淆.我想下面的代码能证实这点.下面哪一个First会被编译?哪一个会返回我们需要的结果?即Customer.ID=5.答案是6个First不仅被编译,并都获得正确答案,且他们的结果一样.如果你对此感到困惑,那么请继续看这篇文章. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 class Customer {     public int ID { get; set; }     p

写的非常好的文章 C#中的委托,匿名方法和Lambda表达式

简介 在.NET中,委托,匿名方法和Lambda表达式很容易发生混淆.我想下面的代码能证实这点.下面哪一个First会被编译?哪一个会返回我们需要的结果?即Customer.ID=5.答案是6个First不仅被编译,并都获得正确答案,且他们的结果一样.如果你对此感到困惑,那么请继续看这篇文章. class Customer { public int ID { get; set; } public static bool Test(Customer x) { return x.ID == 5; }

委托学习笔记后续:泛型委托及委托中所涉及到匿名方法、Lambda表达式

引言: 最初学习c#时,感觉委托.事件这块很难,其中在学习的过程中还写了一篇学习笔记:委托.事件学习笔记.今天重新温故委托.事件,并且把最近学习到和委托相关的匿名方法.Lambda表达式及泛型委托记录下来,以备复习使用. 委托: 日常工作中,常常见到委托用在具体的项目中.而且委托使用起来相对来说也是非常简单的,下面列举一个委托实例用以说明如何使用委托,代码如下: class Program { public delegate int CalculateDelegate(int x, int y)

Fun&lt;&gt;,匿名方法,Lambda表达式 冒泡排序C#

大头文 分享,进步 冒泡排序C#实现,使用委托,包括三种方式:Fun<>,匿名方法,Lambda表达式 冒泡排序是一种简单的排序方法,适合于小量数字排序,对于大量数字(超过10个),还有更高效的排序方法.这里的实现的冒泡排序,需实现功能:不仅数字排序,还要对任意对象排序 示例: 对People对象的Age(年龄)排序 对Student对象的Score(分数)排序 People: public class People { public string Name { get; set; } pub

3 委托、匿名函数、lambda表达式

委托.匿名函数.lambda表达式 在 2.0 之前的 C# 版本中,声明委托的唯一方法是使用命名方法.C# 2.0 引入了匿名方法,而在 C# 3.0 及更高版本中,Lambda 表达式取代了匿名方法,作为编写内联代码的首选方式 // 声明一个委托 delegate void Printer(string s); class TestClass { static void Main() { //lambda表达式 Printer pp = x => { Console.WriteLine(&quo

委托、匿名委托、Lambda 表达式、Expression表达式树之刨根问底

本篇不是对标题所述之概念的入门文章,重点在阐述它们的异同点和应用场景.各位看官,这里就不啰嗦了,直接上代码. 首先定义一个泛型委托类型,如下: public delegate T Function<T>(T a, T b); 实现泛型委托的主体代码,并调用: public static string Add(string a, string b) { return string.Format("{0} #### {1}",a,b); } //实名委托方式 Function&

C#语法之匿名函数和Lambda表达式

上一篇博客主要是对委托和事件做了一小结,这篇是在上一篇博客的基础上对匿名函数和Lambda表达式小结.还是接着上一篇说起,在上一篇中也说了委托是一种数据结构,主要是解决让函数作为参数的问题.在使用委托时首先要声明代理,然后实例化,并将委托对象和已定义好的函数关联上,最后调用.这里与已定义好的函数关联的事情,如果函数是经常使用的也还好,如果不是经常使用的可能只调用一次,那这岂不是老费劲了.就是能不能在使用的时候定义下呢?于是乎有了匿名方法. 一.匿名方法的使用. 匿名方法的使用步骤和委托的使用步骤

委托,匿名函数和lambda表达式

很早之前就接触到了委托,但是一直对他用的不是太多,主要是本人是菜鸟,能写的比较高级的代码确实不多,但是最近在看MSDN微软的类库的时候,发现了微软的类库好多都用到了委托,于是决定好好的研究研究,加深一下自己对他的印象,顺便把自己的感悟和想法写出来,以便自己能有更深的理解,由于本人水平有限,也欢迎大家多多探讨,有问题大家一起解决一起进步. MSDN上面对委托的定义是:delegate 是表示对具有特定参数列表和返回类型的方法的引用的类型.在我看来委托的特性主要在: 1.把一个方法当做一个参数传递给

匿名方法,Lambda表达式,高阶函数

原文:匿名方法,Lambda表达式,高阶函数 匿名方法 c#2.0引入匿名方法,不必创建单独的方法,因此减少了所需的编码系统开销. 常用于将委托和匿名方法关联,例如 1. 使用委托和方法关联: this.btnRefresh.Click += new System.EventHandler(this.btnRefresh_Click);private void btnRefresh_Click(object sender, EventArgs e){    BindData();} 2. 使用委