Eine kurze Diskussion über die Entwicklung der Verhaltensparametrisierung in JAVA8

1. Verhaltensparametrisierung ist die Fähigkeit einer Methode, mehrere unterschiedliche Verhaltensweisen als Parameter zu akzeptieren und sie intern zu verwenden, um unterschiedliche Verhaltensweisen zu vervollständigen

2. Verhaltensparametrisierung ermöglicht eine individuelle Anpassung des Codes sich ändernde Anforderungen und reduzieren den Arbeitsaufwand

3. Lambda-Ausdrücke erleichtern diese Anwendung

4. Beherrschen Sie analytische Prädikate und definieren Sie geeignete Schnittstellen und Implementierungsmethoden

 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();
    }

Das obige ist der detaillierte Inhalt vonEine kurze Diskussion über die Entwicklung der Verhaltensparametrisierung in JAVA8. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!