lambda 사용한 Map, List foreach

람다식은 메서드를 하나의 식(expression)으로 표현한 것.

-  객체 지향 언어보다는 함수 지향 언어에 가까움.

-  함수를 간략하면서도 명확한 식으로 표현가능하다.

-  메서드를 람다식으로 표현하면 메서드의 이름 및 반환 값이 없어지므로 익명 함수 라고도 한다.

-  람다식의 형태는 매개 변수를 가진 코드 블록이지만 런타임 시에는 익명 구현 객체를 생성한다.

1. 람다의 표현방식

        /*
         * ( parameters ) -> expression body
            ( parameters ) -> { expression body }
            () -> { expression body }
            () -> expression body
         */

2. lambda 사용한 List foreach

        Map<String, Object> myMap1 = new HashMap<>();
        Map<String, Object> myMap2 = new HashMap<>();
 
        Map<Integer, Object> finalMap = new HashMap<>();
 
        myMap1.put("name", "이상현");
        myMap1.put("age", "29");
        myMap1.put("country", "KOREA");
 
        myMap2.put("name", "김철수");
        myMap2.put("age", "25");
        myMap2.put("country", "USA");
 
        List<Map<String,Object>> myList1 = new ArrayList<>();
        myList1.add(myMap1);
        myList1.add(myMap2);
 
        // List foreach 문
        for (Map<String, Object> map : myList1) {
            System.out.println(map);
        }
 
        // lambda사용한 List foreach 문
        myList1.forEach(x -> {
            System.out.println(x);
        });
 
        //    output :
        //    {country=KOREA, name=이상현, age=29}
        //    {country=USA, name=김철수, age=25}
        //    {country=KOREA, name=이상현, age=29}
        //    {country=USA, name=김철수, age=25}

3. Map 안에 List와 Map 모두 넣기

        Map<String, Object> myMap3 = new HashMap<>();
        Map<String, Object> myMap4 = new HashMap<>();
 
        myMap3.put("name", "김수르");
        myMap3.put("age", "26");
        myMap3.put("country", "CHINA");
 
        myMap4.put("name", "김영희");
        myMap4.put("age", "23");
        myMap4.put("country", "UK");
 
        // finalMap 안에 List와 Map을 담음
        finalMap.put(0, myList1);
        finalMap.put(1, myMap3);
        finalMap.put(2, myMap4);
 
        //    finalMap :
        //    {
        //        0=[{country=KOREA, name=이상현, age=29}, {country=USA, name=김철수, age=25}]
        //      , 1={country=CHINA, name=김수르, age=26}
        //      , 2={country=UK, name=김영희, age=23}
        //    }

4. lambda 사용한 Map foreach

        // for문
        for(int i=0; i< finalMap.size(); i++) {
            System.out.println(finalMap.get(0));
        }
 
        // foreach문 - keySet사용
        for ( Integer key : finalMap.keySet() ) {
            System.out.println( key );
            System.out.println(finalMap.get(key));
        }
 
        // foreach문 - entrySet사용
        for ( Map.Entry<Integer, Object> entry : finalMap.entrySet()) {
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }
 
        // lambda 사용한 foreach문
        finalMap.forEach((k,v) ->{
            System.out.println(k);
            System.out.println(v);
        });
 
        // lambda 사용한 foreach문
        finalMap.forEach((k,v) -> System.out.println(k +""+ v));
 
        // output :
        //    0[{country=KOREA, name=이상현, age=29}, {country=USA, name=김철수, age=25}]
        //    1{country=CHINA, name=김수르, age=26}
        //    2{country=UK, name=김영희, age=23

5. lambda 로 interface와 추상메소드 호출 

package myTest;
 
public class myTest2 {
 
    public static void main(String[] args) {
 
        // 람다 사용한 인터페이스 메소드 호출 1
        func1((i, j)->{
            return  i * j;
        });
        // output : 20000
 
        // 람다 사용한 인터페이스 메소드 호출 2
        myInterface2 addExp1 = (int a, int b) -> a + b;
        myInterface2 addExp2 = (int a, int b) -> { return a + b; };
        myInterface2 sub = (int a, int b) -> a - b;
 
        int result = addExp1.calc(1, 2) + addExp2.calc(1, 2) + sub.calc(-5, 5); // 6 - 10 = -4
        System.out.println(result);
        // output : -4
 
    }
 
    // 람다식을 위한 인터페이스에서 추상 메소드는 단 하나여야 한다.
    // 어노테이션을 사용함으로써 추상메소드를 1개만 선언할수 있게 제한함.
    @FunctionalInterface
    public interface myInterface1{
        public int compareMethod(int value1, int value2);
    }
 
    @FunctionalInterface
    public interface myInterface2 {
        public int calc(int a, int b);
    }
 
    public static void func1(myInterface1 myinterface1){
        int value1 = 100;
        int value2 = 200;
 
        int finalValue = myinterface1.compareMethod(value1, value2);
        System.out.println(finalValue);
    }
}
 

6. lambda 사용하여 함수 정의 및 호출 

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("As-Is Thread Runnable Define");
            }
        }).start();
 
        new Thread(()->{
            System.out.println("To-be Thread Lambda Express");
        }).start();

7. lambda 사용하여 List Stream Method

        List<Integer> myList1 = new ArrayList<>();
        for(int i=0; i<=4; i++) {
            myList1.add(i);
        }
 
        // 스트림// 스트림
        myList1.stream();                
        
        // stream 요소 반복
        myList1.stream().forEach(System.out::println);                             
        // 0 1 2 3 4
        
        // stream 요소를 연산가능하게 함
        myList1.stream().map(i -> i*i).forEach(System.out::println);      
        // 0 1 4 9 16
        
        // stream 요소의 인덱스까지 제한함
        myList1.stream().limit(1).forEach(System.out::println);                
        // 0
        
        // stream 요소의 인덱스를 생략
        myList1.stream().skip(1).forEach(System.out::println);                
        // 1 2 3 4
        
        // stream 요소를 조건문과 비교하여 필터
        myList1.stream().filter(i-> i<=1).forEach(System.out::println);     
        // 0 1
        
        // stream 단일요소 반환 0+1+2+3+4
        myList1.stream().reduce((a,b)-> a+b).get();                                
        // 10