[Collection, Lambda] forEach, removeIf : 함수형 인터페이스를 파라미터로 가지는 컬렉션 메소드

enum RANK{
    BRONZE,SILVER,GOLD,PLATINUM
}

public class User {
    private String name;
    private RANK rank;          // 등급
    private int rateOfChange;   // 점수변화 : 예제(2)에서 사용

    public User(String name, RANK rank) {
        this.name = name;
        this.rank = rank;
    }

    public String getName() {
        return name;
    }

    public RANK getRank() {
        return rank;
    }

    public User setRank(RANK rank) {
        this.rank = rank;
        return this;
    }

    public int getRateOfChange() {
        return rateOfChange;
    }

    public User setRateOfChange(int rateOfChange) {
        this.rateOfChange = rateOfChange;
        return this;
    }

    @Override
    public String toString() {
        return "[name='" + name + '\'' + ", rank=" + rank + ']';
    }
}

 

예제(1)

import java.util.*;
import java.util.function.*;

public class RemoveIfTest {
    /*
        
        forEach 파라미터 : Consumer 인터페이스 void accept (T t) 구현 
            컬렉션을 순회하면서 각 요소들에게 취할 행동을 코드로 만든다.
         
        removeIf 파라미터 : Predicate 인터페이스 boolean test(T t) 구현  
            컬렉션을 순회하면서 요소에게 적용할 조건식을 코드로 만든다.
    */

    public static void main(String[] args) {

        List<User> list = Arrays.asList(
                new User("lee",RANK.BRONZE),
                new User("hong",RANK.BRONZE),
                new User("lee",RANK.PLATINUM),
                new User("park",RANK.GOLD),
                new User("kim",RANK.GOLD),
                new User("kim",RANK.SILVER),
                new User("kim",RANK.PLATINUM)
        );
        List<User> users = new ArrayList<>(list);

        System.out.println("=========== 삭제 전 ============ ");
        users.forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                System.out.println(user);
            }
        });


        users.removeIf(new Predicate<User>() {  	
        
            @Override
            public boolean test(User user) { // true를 반환하는 컬렉션들은 모두 삭제된다. 
                return user.getRank()==RANK.GOLD; // 골드 등급 User 모두 삭제
            }
        });
        System.out.println("=========== 삭제 후 ============ ");
        users.forEach(s-> System.out.println(s));
    }
}

 

람다식 적용

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

public class RemoveIfTest {
  
    public static void main(String[] args) {

        List<User> list = Arrays.asList(
                new User("lee",RANK.BRONZE),
                new User("hong",RANK.BRONZE),
                new User("lee",RANK.PLATINUM),
                new User("park",RANK.GOLD),
                new User("kim",RANK.GOLD),
                new User("kim",RANK.SILVER),
                new User("kim",RANK.PLATINUM)
        );
        List<User> users = new ArrayList<>(list);

        System.out.println("=========== 삭제 전 ============ ");
        users.forEach(user -> System.out.println(user));


        users.removeIf(user -> user.getRank()==RANK.GOLD);
        System.out.println("=========== 삭제 후 ============ ");
        users.forEach(user-> System.out.println(user));
    }
}

 

예제(2)

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

public class ForEachTest {

    public static void main(String[] args) {
        User user1 = new User("lee",RANK.BRONZE);
        User user2 = new User("hong",RANK.BRONZE);
        User user3 = new User("ahn",RANK.PLATINUM);
        User user4 = new User("park",RANK.GOLD);
        User user5 = new User("moon",RANK.GOLD);
        User user6 = new User("yoo",RANK.SILVER);
        User user7 = new User("na",RANK.PLATINUM);

        List<User> list = Arrays.asList(user1, user2, user3, user4, user5, user6, user7);
        List<User> users = new ArrayList<>(list);

        user1.setRateOfChange(150); // 브론즈 -> 실버 등업 조건 OK
        user2.setRateOfChange(100); // 브론즈 -> 실버 등업 조건 X
        user4.setRateOfChange(320); // 골드 -> 플래티넘 등업 조건 OK
        user5.setRateOfChange(280); // 골드 -> 플래티넘 등업 조건 X
        user6.setRateOfChange(250); // 실버 -> 골드 등업 조건 OK

        users.forEach(new Consumer<User>() {
            @Override
            public void accept(User user) {
                switch (user.getRank()) {
                    case BRONZE: if (user.getRateOfChange() > 100) { user.setRank(RANK.SILVER);}
                        break;
                    case SILVER: if (user.getRateOfChange() > 200) {user.setRank(RANK.GOLD);}
                        break;
                    case GOLD: if(user.getRateOfChange()>300) {user.setRank(RANK.PLATINUM);}
                        break;
                }
            }
        });

        /*
            lee : 실버로 등업  hong : 브론즈 그대로
            park 플래티넘으로 등업  moon : 골드 그대로
            yoo 골드로 등업
        */

        users.forEach(System.out::println);
    }
}

람다

users.forEach(user -> {
	switch (user.getRank()) {
          case BRONZE: if (user.getRateOfChange() > 100) { user.setRank(RANK.SILVER);}
            break;
          case SILVER: if (user.getRateOfChange() > 200) {user.setRank(RANK.GOLD);}
            break;
          case GOLD: if(user.getRateOfChange()>300) {user.setRank(RANK.PLATINUM);}
        break;
       }
});