====== Ch.15 람다식 ======

==== 람다식 개념 ====

<code java>
package chapter15;

public class LambdaFunctionEx {

	public static void main(String[] args) {
		
		InterfaceEx ie = (int x, int y) -> x+y;
		
		System.out.println(ie.sum(1, 2));

	}

}

interface InterfaceEx {
	public int sum(int x, int y);
}
</code>

==== 함수적 인터페이스 ====

=== LambdaEx ===

<code java>
package chapter15;

public class LambdaEx {

	public static void main(String[] args) {
		
		LambdaInterface li = () -> {
			String str = "메서드 출력";
			System.out.println(str);
		};
		
		li.print();

	}

}

interface LambdaInterface {
	void print();
	//void print2(); // 오류발생
}
</code>

=== LambdaEx2 ===

<code java>
package chapter15;

public class LambdaEx2 {

	public static void main(String[] args) {
		
		System.out.println("시작");
		Runnable run = () -> {
			for (int i=1; i<=10; i++) {
				System.out.println("첫번째:"+i);
			}
		};
		Runnable run2 = () -> {
			for (int i=1; i<=10; i++) {
				System.out.println("두번째:"+i);
			}
		};
		
		Thread t = new Thread(run);
		Thread t2 = new Thread(run2);
		t.start();
		t2.start();
		System.out.println("종료");
	}

}

</code>

=== LambdaEx3 ===

<code java>
package chapter15;

public class LambdaEx3 {

	public static void main(String[] args) {
		
		LambdaInterface3 li3 = (String name) -> {
			System.out.println("제 이름은 "+name+"입니다.");
		};
		
		li3.print("홍길동");

	}

}

@FunctionalInterface
interface LambdaInterface3 {
	void print(String name);
}
</code>

=== LambdaEx4 ===

<code java>
package chapter15;

public class LambdaEx4 {

	public static void main(String[] args) {
		
		LambdaInterface4 f4 = (x,y) -> {
			return x * y;
		};
		System.out.println("두 수의 곱 : " + f4.cal(3, 2));
		
		f4 = (x, y) -> x + y;
		System.out.println("두 수의 합 : " + f4.cal(3, 2));
		
		f4 = (x, y) -> { return x/y; };
		System.out.println("두 수의 몫 : " + f4.cal(5, 2));
		
		f4 = (x, y) -> x%y;
		System.out.println("두 수의 나머지 : " + f4.cal(5, 2));
		
		f4 = (x,y) -> sum(x, y);
		System.out.println("두 수의 합(sum()) : " + f4.cal(3, 2));

	}
	
	static int sum(int x, int y) {
		return x+y;
	}

}

@FunctionalInterface
interface LambdaInterface4 {
	int cal(int x, int y);
}
</code>

=== LambdaEx5 ===

<code java>
package chapter15;

public class LambdaEx5 {

	public static void main(String[] args) {
		
		Outer o = new Outer();
		o.method();

	}
	
}

@FunctionalInterface
interface LambdaInterface5 {
	void method();
}

class Outer {
	public int iv = 10;
	void method() {
		final int iv = 40;
		LambdaInterface5 f5 = () -> {
			System.out.println("Outer.this.iv:" + Outer.this.iv);
			System.out.println("this.iv:" + this.iv);
			System.out.println("iv:" + iv);
		};
		f5.method();
	}
}
</code>

=== LambdaEx6 ===

<code java>
package chapter15;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.ObjIntConsumer;

public class LambdaEx6 {

	public static void main(String[] args) {
		
		Consumer<String> c1 = name -> System.out.println("제 이름은 "+name+"입니다.");
		c1.accept("홍길동");
		
		BiConsumer<String, String> c2 = (lastname, firstname) -> {
			System.out.println("제 이름은 "+lastname+firstname+"입니다.");
		};
		c2.accept("홍", "길동");
		
		DoubleConsumer c3 = (score) -> System.out.println("제 점수는 "+score+"입니다.");
		c3.accept(95.5);
		
		ObjIntConsumer<String> c4 = (lecture, i) -> {
			System.out.println("제 "+lecture+" 점수는 "+i+"점 입니다.");
		};
		c4.accept("국어", 100);
	}
	
}
</code>

<code java>
package chapter15;

import java.util.function.DoubleSupplier;
import java.util.function.IntSupplier;
import java.util.function.Supplier;

public class LambdaEx7 {

	public static void main(String[] args) {
		
		Supplier<String> s1 = () -> {
			return "홍길동";
		};
		System.out.println(s1.get());
		
		s1 = () -> "이순신";
		System.out.println(s1.get());
		
		IntSupplier s2 = () -> {
			int num = (int)(Math.random() * 6) + 1;
			return num;
		};
		
		System.out.println("주사위 :" + s2.getAsInt());
		
		DoubleSupplier s3 = () -> Math.PI;
		System.out.println("랜덤값 :" + s3.getAsDouble());
	}
	
}


</code>

=== LambdaEx8 ===

<code java>
package chapter15;

import java.util.function.Function;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;

public class LambdaEx8 {
	
	static Student[] list = { 
			new Student("홍길동", 90, 80, "컴공"), 
			new Student("이순신", 95, 70, "통계 ")
	};
	

	public static void main(String[] args) {
		
		System.out.print("학생명 : ");
		printString(t -> t.getName());
		System.out.print("전공 : ");
		printString(t -> t.getMajor());
		System.out.print("영어 점수 :");
		printInt(t -> t.getEng());
		System.out.print("수학 점수 :");
		printInt(t -> t.getMath());
		System.out.print("영어 점수 합계 :");
		printTot(t -> t.getEng());
		System.out.print("수학 점수 합계 :");
		printTot(t -> t.getMath());
		System.out.print("영어 점수 평균 :");
		printAvg(t -> t.getEng());
		System.out.print("수학 점수 평균 :");
		printAvg(t -> t.getMath());
		
	}
	
	static void printAvg(ToDoubleFunction<Student> f) {
		double sum = 0;
		for (Student s : list) {
			sum += f.applyAsDouble(s);
		}
		System.out.println(sum / list.length);
	}
	
	static void printTot(ToIntFunction<Student> f) {
		int sum = 0;
		for (Student s : list) {
			sum += f.applyAsInt(s);
		}
		System.out.println(sum);
	}
	
	static void printInt(Function<Student, Integer> f) {
		for (Student s : list) {
			System.out.print(f.apply(s) + " ");
		}
		System.out.println();
	}
	
	static void printString(Function<Student, String> f) {
		for (Student s : list) {
			System.out.print(f.apply(s) + " ");
		}
		System.out.println();
	}
	
}

class Student {
	private String name;
	private int eng;
	private int math;
	private String major;
		
	public Student(String name, int eng, int math, String major) {
		this.name = name;
		this.eng = eng;
		this.math = math;
		this.major = major;
	}
	public String getName() {
		return name;
	}
	public int getEng() {
		return eng;
	}
	public int getMath() {
		return math;
	}
	public String getMajor() {
		return major;
	}
}
</code>

=== LambdaEx9 ===

<code java>
package chapter15;

import java.util.function.DoubleBinaryOperator;
import java.util.function.IntBinaryOperator;

public class LambdaEx9 {
	
	// 앞 예제에서 작성한 Student 클래스의 배열
	static Student[] list = { 
			new Student("홍길동", 90, 80, "컴공"), 
			new Student("이순신", 95, 70, "통계 "),
			new Student("김유신", 100, 60, "빅데이터 ")
	};
	

	public static void main(String[] args) {
		
		System.out.print("최대 수학 점수 : ");
		int max = maxOrMinMath( (a,b) -> {
			if(a>=b) return a;
			else return b;
		});
		System.out.println(max);
		
		System.out.print("최소 수학점수 : ");
		System.out.println(maxOrMinMath((a,b) -> (a<=b?a:b)));
		
		System.out.print("최대 평균점수 : ");
		System.out.println(maxOrMinAvg((a, b) -> (a>=b?a:b)));
		
		System.out.print("최소 평균점수 : ");
		System.out.println(maxOrMinAvg((a,b) -> (a<=b?a:b)));
		
	}
	
	// 두 개의 int 값을 연산하여 int값을 리턴
	private static int maxOrMinMath(IntBinaryOperator op) {
		int result = list[0].getMath();
		for(Student s : list) {
			result = op.applyAsInt(result, s.getMath());
		}
		return result;
	}
	
	// 두개의 double 값을 연산하여 double값을 리턴
	private static double maxOrMinAvg(DoubleBinaryOperator op) {
		double result = (list[0].getMath() + list[0].getEng()) / 2.0;
		for(Student s : list) {
			result = op.applyAsDouble(result, (s.getMath()+s.getEng())/2.0);
		}
		return result;
	}
	
}
</code>

<code java>
package chapter15;

import java.util.function.Predicate;

public class LambdaEx10 {
	
	// 앞 예제에서 작성한 Student 클래스의 배열
	static Student[] list = { 
			new Student("홍길동", 90, 80, "컴공"), 
			new Student("이순신", 95, 70, "통계 "),
			new Student("김유신", 100, 60, "컴공")
	};
	

	public static void main(String[] args) {
		
		// 과가 컴공인 학생의 영어점수 평균
		double avg = avgEng(t -> t.getMajor().equals("컴공"));
		System.out.println("컴공과 평균 영어점수 : "+avg);
		
		// 과가 컴공인 학생의 수학점수 평균
		double avg2 = avgMath(t -> t.getMajor().equals("컴공"));
		System.out.println("컴공과 평균 수학점수 : "+avg2);
		
	}
	
	private static double avgEng(Predicate<Student> predicate) {
		int count = 0;
		int sum = 0;
		for (Student student : list) {
			// equals 비교
			if (predicate.test(student)) {
				count++;
				sum += student.getEng();
			}
		}
		return (double)sum/count;
	}
	
	private static double avgMath(Predicate<Student> predicate) {
		int count = 0;
		int sum = 0;
		for (Student student : list) {
			// equals() 비교
			if (predicate.test(student)) {
				count++;
				sum += student.getMath();
			}
		}
		return (double)sum/count;
	}
	
}
</code>