Guava 학습노트-Function, Predicate

먼저 실례에 필요한 실체 클래스를 도입하고 실체 클래스의 get/set 방법은 생략합니다

public class State {
    private String name;
    private String code;
    private String region;
    private Set<City> mainCities=new HashSet<City>();

    public State(){}

    public State(String name){
        this.name=name;
    }
}

public class City {
    private String name;
    private String zipCode;
    private Integer population;
    private String climate;
    private double averageRainfall;

    public City(){}
    public City(String name){
        this(name,null,null);
    }

    public City(String name,String zipCode,Integer population){
        this.name=name;
        this.zipCode=zipCode;
        this.population=population;
    }
}

하나의 Function 인터페이스 구현:

public class StateToCityString implements Function<State,String> {
    @Override
    public String apply(State input) {
        return Joiner.on(",").join(input.getMainCities());
    }
}

Function TestCase:

public class FunctionTest {
    @Test
    public void test(){
        Map<String,State> stateMap=new HashMap<String,State>();
        State s=new State("New York");
        s.addCity("new");
        s.addCity("york");
        stateMap.put("NY",s);

        //Functions.forMap  Map ， Function， Map 
        Function<String,State> lookup= Functions.forMap(stateMap);
        Function<State,String> stateFunction=new StateToCityString();

        //Function<A, C> compose(Function<B, C> g, Function<A, ? extends B> f)
        // Function ， Function 
        //f g ，g compose 
        Function<String,String> composed=Functions.compose(stateFunction,lookup);
        String str=composed.apply("NY");
        System.out.println(str);
    }
}

-----------------------------------------------------------------------------------------------------------------------------------------------------------------
Predicate
Predicate 인터페이스 구현:

public class LowRainfallPredicate implements Predicate<City> {
    @Override
    public boolean apply(City input) {
        return input.getAverageRainfall()<45.7;
    }
}

public class PopulationPredicate implements Predicate<City> {
    @Override
    public boolean apply(City input) {
        return input.getPopulation()<=50000;
    }
}

public class TemperateClimatePredicate implements Predicate<City>{
    @Override
    public boolean apply(City input) {
        return input.getClimate().equals("gogo");
    }
}

public class SouthwestOrMidwestRegionPredicate implements Predicate<State> {
    @Override
    public boolean apply(State input) {
        return input.getRegion().equals("MIDEWEST")||input.getRegion().equals("SOUTHWEST");
    }
}

Predicate TestCase:

public class PredicateDemo {
    @Test
    public void test(){
        TemperateClimatePredicate temperateClimatePredicate=new TemperateClimatePredicate();
        LowRainfallPredicate lowRainfallPredicate=new LowRainfallPredicate();

        PopulationPredicate smallPopulationPredicate=new PopulationPredicate();
        //Predicates.and
        Predicate smallAndDry= Predicates.and(smallPopulationPredicate,lowRainfallPredicate);

        //Predicates.or
        Predicate smallTemperate=Predicates.or(smallPopulationPredicate,temperateClimatePredicate);

        //Predicates.not
        Predicate largeCityPredicate=Predicates.not(smallPopulationPredicate);

        //Predicates.compose
        //Predicate<A> compose(Predicate<B> predicate, Function<A, ? extends B> function)
        // ：predicate.apply(function.apply(A))
        Map<String,State> stateMap=new HashMap<String,State>();
        State s=new State("New York");
        s.setRegion("MIDEWEST");
        s.addCity("new");
        s.addCity("york");
        stateMap.put("NY",s);
        Function<String,State> lookup= Functions.forMap(stateMap);
        SouthwestOrMidwestRegionPredicate southwestOrMidwestRegionPredicate=new SouthwestOrMidwestRegionPredicate();
        Predicate<String> predicate=Predicates.compose(southwestOrMidwestRegionPredicate,lookup);
        System.out.println(predicate.apply("NY"));
    }
}

Function과Predicate는 매우 비슷한 인터페이스로 Function과Predicate의 응용 방법을 실현할 때 입력 데이터를 수정하지 마십시오.
Function 및 Predicate에는 다음 두 가지 방법이 있습니다.
T apply(@Nullable F input);
boolean equals(@Nullable Object object);
Functions.compose(FunctionA, FunctionB) 용도: 서로 다른 함수를 조합하여 FunctionB의 출력을 FunctionA의 입력으로 재처리할 수 있습니다.중첩된 데이터 처리 조작을 실현할 수 있다.
다양한 Predicate를 구현하여 간단한 검증 작업을 복원하고 데이터 필터링 등에 사용할 수 있습니다.
Predicates.compose는 Predicate와 Function을 조합합니다.Function 결과를 Predicate 로 입력한 다음 판단 필터링 작업을 수행합니다.
이 정도만 이해합니다. 벽돌을 두드리는 것을 환영합니다!깊이 있는 학습은 원본을 보는 것을 추천합니다!
참고 자료: Getting started with google guava