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는 아래와 같은 자기자신
비전공자 독학러. 일단 쌔린다. 개발 공부👊