Home  >  Article  >  Java  >  A brief discussion on the evolution of behavioral parameterization in JAVA8

A brief discussion on the evolution of behavioral parameterization in JAVA8

无忌哥哥
无忌哥哥Original
2018-07-19 10:05:552352browse

1. Behavior parameterization is the ability of a method to accept multiple different behaviors as parameters and use them internally to complete different behaviors

2. Behavior parameterization allows the code to be personalized Adapt well to changing requirements and reduce workload

3. Lambda expressions make this application simpler

4. Master analytical predicates and define appropriate interfaces and implementation methods

 public static class Apple{        
 private String color;        
 private Integer weight;        
 private String sm;        
 public String getSm() {            
     return sm;
        }        
  public void setSm(String sm) {            
        this.sm = sm;
        }        
 public Apple(String color, int weight) {            
                 this.color = color;            
                 this.weight = weight;
        }

        @Override        
 public String toString() {            
        return "Apple{" +                    
        "color='" + color + '\'' +", 
        weight=" + weight +", 
        sm='" + sm + '\'' +'}';
        }        
 public String getColor() {            
               return color;
        }        
 public void setColor(String color) {            
        this.color = color;
        }        
 public Integer getWeight() {            
        return weight;
        }        
 public void setWeight(Integer weight) {            
        this.weight = weight;
        }
    }    
    //从列表中筛选出绿色的苹果
 public static List<Apple> filterGreenApple(List<Apple>inventory){
        List<Apple>result=new ArrayList<>();        
        for (Apple apple : inventory) {            
            if ("green".equals(apple.getColor())) {
                result.add(apple);
            }
        }        
        return result;
    }    
    //从列表中根据参数筛选出绿色的苹果
    public static List<Apple>filerAppleByColor(List<Apple>appleList,String color){
        List<Apple> apples=new ArrayList<>();        
        for (Apple apple : appleList) {            
            if (apple.getColor().equals(color)) {
                apples.add(apple);
            }

        }        
        return apples;
    }    
    //统一定义行为参数接口类,这个行为的主体是apple
    public interface ApplePredicate{
        boolean test(Apple apple);
    }    
    public interface PredicateFormat{
        String accept(Apple apple);
    }    
    //定义泛型类的行为参数接口类,这个行为的主体不在局限某一个实物
    public interface AbstratPredicate<T>{
        boolean test(T t);
    }    
    //参数行为化多实现类写法,实现按重量和颜色挑选苹果
    public static class filterGreenWeightApple implements ApplePredicate{

        @Override        
        public boolean test(Apple apple) {            
            return apple.getColor().equals("green")&&apple.getWeight()>100;
        }
    }    
    public static class filteFannyApple implements PredicateFormat{

        @Override        
        public String accept(Apple apple) {
           String ss= apple.getWeight()>100? "light":"heavy";            
           return "A"+ ss+apple.getColor()+"Apple";
        }
    }    
    public static List<Apple>filterApplePredicate(List<Apple> appleList,ApplePredicate p){
        List<Apple> apples=new ArrayList<>();        
        for (Apple apple : appleList) {            
            if (p.test(apple)) {
                apples.add(apple);
            }

        }        
        return apples;
    }    
    public static List<Apple>filterFannyApple(List<Apple>appleList,PredicateFormat p){
        List<Apple>apples=new ArrayList<>();        
        for (Apple apple : appleList) {
           apple.setSm(p.accept(apple));
            apples.add(apple);
        }        
        return apples;
    }    
    //集成泛型接口的泛型类型方法
    public static <T> List<T> filter(List<T>list,AbstratPredicate<T> pa){
        List<T>lists=new ArrayList<>();        
        for (T t : list) {            
            if (pa.test(t)) {
                lists.add(t);
            }
        }        
        return lists;
    }    
    //匿名类的笨重感
    public static class MeaningOfThis{        
        public final int value=4;        
        public void doIt(){            
                int value=6;
            Runnable r=new Runnable() {                
                public final int value=5;
                @Override                
                public void run() {                    
                    int value=10;
                    System.out.println(this.value);
                }

            };
            r.run();
        }
    }    
    public static void main(String[] args) {
        List<Apple> appleList=Arrays.asList(new Apple("yellow",150),new Apple("green",150),new Apple("green",100));        
        //过滤绿色的苹果
        List<Apple>result=filterGreenApple(appleList);
        result.stream().forEach((Apple a)->System.out.println(a));        
        //根据颜色参数过滤苹果
        List<Apple>colorResult=filerAppleByColor(appleList,"yellow");
        colorResult.stream().forEach(c->System.out.println(c));        
        //参数行为化多实现类写法,实现按重量和颜色挑选苹果
        List<Apple>colorWeightApple=filterApplePredicate(appleList,new filterGreenWeightApple() );
        colorWeightApple.stream().forEach(cw->System.out.println(cw));
        List<Apple>fannyApple=filterFannyApple(appleList,new filteFannyApple());
        fannyApple.stream().forEach(f->System.out.println(f));
        System.out.println("-----------------------------");        
        //参数行为化匿名类实现
        List<Apple>niming=filterApplePredicate(appleList, new ApplePredicate() {
            @Override            public boolean test(Apple apple) {                return apple.getColor().equals("green");
            }
        });
        niming.stream().forEach(n->System.out.println(n));        
        //匿名类的笨重感
        MeaningOfThis mo=new MeaningOfThis();
        mo.doIt();        //lambda表达式改写
        System.out.println("-------我是lambda---------");
        List<Apple>lamApples=filterApplePredicate(appleList,(Apple a)->a.getWeight()>100);
        lamApples.stream().forEach(la->System.out.println(la));
        System.out.println("---------------");
        List<Apple>lamApples1= filterFannyApple(appleList,(Apple a)->{
            String ss=a.getWeight()>100?"lighter":"heavyer";            
            return  "A"+ss+a.getColor()+"Apple";
        });
        lamApples1.sort((Apple a,Apple a1)->{            
        if (!a1.getWeight().equals(a.getWeight())) {              
            return   a1.getWeight().compareTo(a.getWeight());
            }else {              
                return   a1.getColor().compareTo(a.getColor());
            }
        });
        lamApples1.stream().forEach(la1->System.out.println(la1));        
        //集成泛型接口的泛型类型方法
        List<Integer>nums= Arrays.asList(1,2,3,4,5,6);
        List<Integer>numlist=filter(nums,(Integer i)->i%2==0);
        numlist.sort((Integer a,Integer a1)->a.compareTo(a1));
        numlist.stream().forEach(i->System.out.println(i));        
        //自带的排序行为参数化的排序
        Thread t=new Thread(()->System.out.println(new Apple("red",100)));
        t.start();
    }

The above is the detailed content of A brief discussion on the evolution of behavioral parameterization in JAVA8. For more information, please follow other related articles on the PHP Chinese website!

Statement:
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn