자바(13) - 내부 클래스, 람다식, 스트림

class Out {
    class In {
    }
}

class ABC {                   // 외부 클래스
    class In {                // 인스턴스 내부 클래스
        static class SIn      // 정적 내부 클래스
    }
    
    public void abc() {
        class Local {}        // 지역 내부 클래스
    }
}

class OutClass {
    private int num = 10;
    private static int sNum = 20;
    
    private InClass inClass;
    
    public OutClass() {
        inClass = new InClass();
    }
    
    class InClass {
        int inNum = 100;
        // static int sInNum = 200;
        
        void inTest() {
            System.out.prinln(num);
            System.out.prinln(sNum);
        }
        
        // static void sTest() // 정적 메서드 정의 불가
        
        public void usingClass() {
            inClass.inTest();
        }
    }
}

public class InnerTest {
    public static void main(String[] args) {
        OutClass outClass = new OutClass();
        outClass.usingClass(); // 외부 클래스에서 내부 클래스 기능 호출
    }
}

OutClass outClass = new OutClass();
OutClass.InClass inClass = outClass.new InClass();

class OutClass {
    private int num = 10;
    private static int sNum = 20;
    
    static class InStaticClass {
        int inNum = 100;
        static int sInNum = 200;
    }
    
    void inTest() {
        // num += 10; // 외부 클래스의 인스턴스 변수는 사용할 수 없음.
        System.out.println(inNum);
        System.out.println(sInNum);
        System.out.println(sNum);
    }
    
    static void sTest() {
        // num += 10;
        // inNum += 10; // 외부 클래스와 내부 클래스의 인스턴스 변수는 사용할 수 없음
        System.out.println(sNum);
        System.out.println(sInNum);
    }
}

public class InnerTest {
    public static void main(String[] argS) {
        OutClass.InStaticClass sInClass = new OutClass.InStaticClass();
        sInClass.inTest();
        OutClass.InStaticClass.sTest();
    }
}

class Outer {
    int outNum = 100;
    static int sNum = 200;
    
    Runnable getRunnable(int i) {
        int num = 100;
        
        class MyRunnable implements Runnable {
            int localNum = 10;
            
            @Override
            public void run() {
                // num = 200; // 지역 변수는 상수로 바뀌므로 값을 변경할 수 없어 오류 발생
                // i = 100; // 매개변수도 지역 변수처럼 상수로 바뀌어 값을 변경할 수 없어 오류 발생
                System.out.println(i);
                System.out.println(num);
                System.out.println(localNum);
                System.out.println(outNum);
                System.out.println(Outter.sNu);
            }
        }
        return new MyRunnable();
    }
}

public class LocalInnerTest {
    public static void main(String[] args) {
        Outter out = new Outter();
        Runnable runner = out.getRunnable(10);
        runner.run();
    }
}

class Outter2 {
    Runnable getRunnable(int i) {
        int num = 100;
        
        return new Runnable() {
            @Override
            public void run() {
                System.out.println(i)
                System.out.println(num)
            }
        }; // 클래스 끝에 ; 사용
    }
    
    Runnable runner = new Runnable() {
        @Override
        public void run() {
            System.out.println("Runnable이 구현된 익명 클래스 변수")
        }
    }; // 마찬가지로 ; 사용
}

public class AnonymousInnerTest {
    public static void main(String[] args) {
        Outter2 out = new Outter2();
        Runnable runnable = out.getRunnable(10);
        runnerable.run();
        out.runner.run();
    }
}

public interface MyNumber {
    int getMax(int num1, int num2); // 추상 메서드 선언
}

public class TestMyNumber {
    public static void main(String[] args) {
        MyNumber max = (x, y) -> (x >= y) ? x : y; // 람다식으로 표현
        System.out.println(max.getMax(10, 20));
    }
}

public interface MyNumber {
    int getMax(int num1, int num2);
    int add(int num1, int num2);
}

@FunctionalInterface
public interface MyNumber {
    int getMax(int num1, int num2);
    int add(int num1, int num2); // 오류 발생
}

public interface StringConcat {
    public void makeString(String s1, String s2);
}

// 기존 객체지향
public class StringConCatImpl implements StringConcat {
    @Override
    public void makeString(String s1, String s2) {
        System.out.println(s1 + ", " + s2);
    }
}

// 람다식
public class TestStringConcat {
    public static void main(String[] args) {
        String s1 = "Hello";
        String s2 = "World";
        StringConCatImpl concat1 = new StringConCatImpl();
        concat1.makeString(s1, s2);
        StringConcat concat2 = (s, v) -> System.out.println(s + ", " + v);
        concat2.makeString(s1, s2);
    }
}

StringConcat concat3 = new StringConcat() {
    @Override
    public void makeString(String s1, String s2) {
        System.out.println(s1 + ", " + s2);
    }
};

public class TestStringConcat {
    public static void main(String[] args) {
        int i = 100;
        
        StringConcat concat2 = (s, v) -> {
            // i = 200; // 람다식 내부에서 변경하면 오류 발생         
        };
    }
}

interface PrintString {
    void showString(String str);
}

PrintString lambdaStr = s -> System.out.println(s)
lambdaStr.showString("hello lambda");

interface PrintString {
    void showString(String str);
}

public class TestLambda {
    public static void main(String[] args) {
        PrintString lambdaStr = s -> System.out.println(s);
        lambdaStr.showString("hello lambda");
        showMyString(lambdaStr);
    }
    
    public static void showMyString(PrintString p) {
        p.showString("hello lambda2");
    }
}

public static PrintString returnString() {
    PrintString str = s -> System.out.println(s + "world");
    return str;
}

// 또는

public static PrintString returnString() {
    return s -> System.out.println(s + "world");;
}

// 테스트
interface PrintString {
    void showString(String str);
}

public class TestLambda {
    public static void main(String[] args) {
        PrintString reStr = returnString();
        reStr.showString("hello ");
    }
    
    public static void showMyString(PrintString p) {
        p.showString("hello lambda2");
    }
    
    public static PrintString returnString() {
        return s -> System.out.println(s + "world");
    }
}

// 기존 방식
int[] arr = {1, 2, 3, 4, 5};
for(int i=0; i<arr.length; i++) {
    System.out.println(arr[i]);
}

// 스트림 사용
int[] arr = {1, 2, 3, 4, 5};
Arrays.stream(arr).forEach(n -> System.out.println(n));

sList.stream().filter(s -> s.length() >= 5).forEach(s -> System.out.println(s));

customerList.stream().map(c -> c.getName()).forEach(s -> System.out.println(s));

public class IntArrayTest {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        
        int sumVal = Arrays.stream(arr).sum();
        int count = (int)Arrays.stream(arr).count(); // long 으로 반환해주어 형 변환
    }
}

List<String> sList = new ArrayList<String>();
sList.add("Tomas");
sList.add("Edward");
sList.add("Jack");

Stream<String> stream = sList.stream();
stream.forEach(s -> System.out.println(s));

Stream<String> stream2 = sList.stream();
stream2.sorted().forEach(s -> System.out.println(s));

Arrays.stream(arr).reduce(0, (a, b) -> a + b);    

import java.util.function.BinaryOperator;
    
class CompareString implements BinaryOperator<String> {
    @Override
    public String apply(String s1, String s2) {
        if(s1.getBytes().length >= s2.getBytes().length) return s1;
        else return s2;
    }
}

public class ReduceTest {
    public static void main(String[] args) {
        String[] greetings = {"asdfdsaf", "bb", "aaaaa"};
        System.out.println(Arrays.stream(greetings).reduce("", (s1, s2) -> {
                            if(s1.getBytes().length >= s2.getBytes().length)
                                return s1;
                            else return s2;}));
        
        String str = Arrays.stream(greetings).reduce(new CompareString()).get();
        System.out.println(str);
    }
}