Java 람다식

https://makecodework.tistory.com/entry/Java-%EB%9E%8C%EB%8B%A4%EC%8B%9DLambda-%EC%9D%B5%ED%9E%88%EA%B8%B0

1. 기초: comparable를 이용한 정렬 (sort)

package day5;

import java.util.Arrays;

class Rectangle implements Comparable<Rectangle> {
	private int width, height;
	public Rectangle( int width, int height){
		super();
		this.width = width ;
		this.height = height ;
	}
	public int findArea() {
		return width*height;
	}
	@Override
	public String toString() {
		return "Rectangle [width=" + width + ", height=" + height + "]";
	}
	@Override
	public int compareTo(Rectangle o) {
		return this.findArea() - o.findArea();
	}
	
}

public class ComparableDemo {

	public static void main(String[] args) {
		Rectangle[] r = {
				new Rectangle(10,5),
				new Rectangle(2,5),
				new Rectangle(4,3)
		};
		Arrays.sort(r);
		for (Rectangle rectangle : r) {
			System.out.println(rectangle);
			
		}
	}

}

// 1. Arrays.sort(r); 하면 ClassCastException 오류가 발생하게 됨
// 2. 클래스가 comparable 이어야 한다고 하니 rectangle 클래스에 그걸 implements를 해주면 되겠지 (추가 상식: ~able은 옛날거라 인터페이스 implements일 것이다.)

2. 람다 연습 1

package day5;

import java.util.Arrays;
import java.util.Comparator;

class Rectangle implements Comparable<Rectangle> {
	private int width, height;
	public Rectangle( int width, int height){
		super();
		this.width = width ;
		this.height = height ;
	}
	public int findArea() {
		return width*height;
	}
	@Override
	public String toString() {
		return "Rectangle [width=" + width + ", height=" + height + "]";
	}
	@Override
	public int compareTo(Rectangle o) {
		return -( this.findArea() - o.findArea()) ;
	}
	
}

public class ComparableDemo {

	public static void main(String[] args) {
		Rectangle[] r = {
				new Rectangle(10,5),
				new Rectangle(2,5),
				new Rectangle(4,3)
		};
		
		System.out.println("----------------------------------------");
//		// 방법1. 클래스 내부에 정렬 기능을 내장
//		Arrays.sort(r);
//		for (Rectangle rectangle : r) {
//			System.out.println(rectangle);
//			
//		}
//		
//		// 방법2. 정렬을 수행하는 익명 클래스 객체를 바로 생성해서 사용
//		// -- 근데 이것도 길다? => 람다!
//		Arrays.sort( r, new  Comparator<Rectangle>() {
//			@Override
//			public int compare(Rectangle o1, Rectangle o2) {
//				return o1.findArea() - o1.findArea();
//			}
//		}
//		);
		
		Arrays.sort(r, ( a,b ) ->  a.findArea() - b.findArea() );
		for (Rectangle rectangle : r) {
			System.out.println(rectangle);
			
		}
		
	}

}

// 1. Arrays.sort(r); 하면 ClassCastException 오류가 발생하게 됨
// 2. 클래스가 comparable 이어야 한다고 하니 rectangle 클래스에 그걸 상속 해주면 되겠지 (추가 상식: ~able은 옛날거라 인터페이스 implements일 것이다.)

// @1. 람다
// @2. compare 기능만 하는 함수만 필요했던 거라
// @3. a.만 해도 얘가 랙탱글 클래스 객체라는 걸 안다.

2-2. 람다 연습 2

interface Printable{
	void print();
}

public class LamdaDemo2 {

	public static void main(String[] args) {

		Printable p;
		p = () ->{ System.out.println("print");} ;
		p.print();
	}

}
// 실행결과
print

3. 람다 응용 참조

package day5;

interface Mathmatical{
	double calculate(double b);
}

interface Pickable{
	char pick (String s, int i);
}

interface Computeble{
	int compute (int x , int y);
}

class Utils{
	int add( int a, int b) {
		return a+b;
	}
}



public class LamdaDemo3 {
	public static double my(double b) {
		return Math.abs(b);
	}

	public static void main(String[] args) {
		
		
		Mathmatical m ; 
		Pickable p;
		Computeble c ; 
		
		// 람다식 기능을 구현 ( - 도 +로 만들어주는 함수로 만들어서 )
		m = ( double b ) -> { return (b>0)? b : -b ; };
		m = b -> (b>0)? b : -b ;
		m.calculate(-5.5);
		System.out.println(m.calculate(-5.5));
		
		
		// 람다식 기능을 구현 ( 기존 math.abs를 이용한 )
		m = b -> Math.abs(b);
		m.calculate(-50.2);
		System.out.println(m.calculate(-50.2));
		
		
		// 기존 math 클래스의 abs 함수를 m으로 참조
		m = Math::abs;
		m.calculate(-53.2);
		System.out.println(m.calculate(-53.2));
		
//		String a = "abc";
//		a.charAt(0);
		p = (String s, int i) -> { return s.charAt(i) ;};
		p = (String s, int i) ->   s.charAt(i) ;
		p = (s, i) ->   s.charAt(i) ;
		p = String::charAt;
		p.pick("abc", 0);
		
//		c = Math.addExact(2, 3)
		c = Math::addExact;
		c.compute(2, 3);
		System.out.println(c.compute(2, 3));
		
		// 클래스도 Math 방법으로 부를 수 있음
		Utils u = new Utils();
		c = (a,b) -> u.add(a, b);
		c = u::add;
	}
	
}

// 삼항연산자

// 직접 구현해도 되고 
// 기존 math의 abs 기능을 써도 되고, 
// 속해있는 위에거::쓸 함수, 메소드

4. 람다 응용

package day5;
//@@ 와 어렵다 다 다시 쳐봐야겠다
interface NewObject<T> {
	T getObject(T o);
}

interface NewArray<T> {
	T [] getArray(int size);
}

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

		NewObject<String> s;
		NewArray<Integer> i;

		s = (String str) -> { return str; };
		s = str -> new String(str);
		s = String::new;
		String str = s.getObject("hello");
		
		i = size -> new Integer [size] ;
		i = Integer[]::new;
		System.out.println(i.getArray(10));
		
		
//		s = (String o) -> { return o + "?" ;};
//		s.getObject("d");
//		System.out.println(s.getObject("d"));
//		
//		i = (int size) -> { return  ;};

	}
}

5. 람다와 익명클래스가 가리키는 대상의 차이

package day5;

interface Usethis{
	void use();
}


public class LamdaDemo5 {
	
	public void lamda() {
		String hi = "hi";
		
		Usethis u1 = new Usethis() {
			@Override
			public void use() {
				System.out.println(this);
			}
		} ;
		u1.use();
		
		Usethis u2 = () -> System.out.println(this);
		u2.use();
	}

	public static void main(String[] args) {
		LamdaDemo5 demo = new LamdaDemo5();
		demo.lamda();
		System.out.println(demo);
	}
}


// 위 u1의 this는 새로 만들어진 애라 자기자신이 아님
// lamda의 this는 아래와 같은 자기자신