국비지원 JAVA(자바) 프로그래밍 (람다,Operator,Predicate,andThen,compose,anyMatch)

람다 

Operator 428p

매개변수도 있고, 리턴값도 있고 그런것들을 이용해서 람다함수만듦.

Operator 실행시는 것 .apply()

 

package A;

import java.util.function.BinaryOperator;
import java.util.function.UnaryOperator;

public class A {

	public static void main(String[] args) {
		BinaryOperator<Double> bo =(a,b)->a+b;  //(제네릭을 설정해야됨)
		// 더블 대문자로 bo는 람다 저장하는 이름, ab는 매개변수 이름(이항연산자라 두개가 들어감),-> 어떤 것을 리턴 받을지 (매개변수,리턴 모두 더블로받음)
		System.out.println(bo.apply(3.5, 16.3));	
		// 단항(not 같은 것), 이항(and 나 or 같은 논리연산 사칙연산), 삼항 연산자(조건식 비교하고 참일때 거짓일 떄)
		
		UnaryOperator<Double> uo= (a)->a+10; //(제네릭을 설정해야됨)
		System.out.println(uo.apply(3.0));
	}

}

제네릭설정한경우↑

DoubleBinaryOperator dbo= (a,b)-> a*b;						//애초에 더블이라고 저장해놨으므로 제네릭 필요x
		System.out.println(dbo.applyAsDouble(1.4, 2.5));            //.applyAs~~~로 사용

제네릭설정안한경우↑

		IntUnaryOperator iuo=(x)-> {
			System.out.println("iuo람다 실행");
			return x+10;
		};
		iuo.applyAsInt(10);		// 처리 과정안에 프린트문이 있으므로  System.out.println("iuo람다 실행"); 이 실행됨
	}
}

제네릭 설정안하면서 단항연산자에 return에 전부 제대로 쓴 경우 ↑(처리 과정안에 프린트문이 있으므로  System.out.println("iuo람다 실행"); 이 실행됨

 

2개의 정수를 받아서 큰값을 출력!

	// 2개의 정수를 받아서 큰값을 출력
		IntBinaryOperator ibo= (x,y)-> {
			if(x>y) {
				return x;
			} else {
				return y;
			}
		};
		System.out.println(ibo.applyAsInt(10, 5));
	}
}

결과값: 10 

 

oprator

매개변수->값; 이상태로 끝나면 값이 리턴값이 됨

 

매개변수 -> {

구현

return 값;

}

oprator는 무조건 리턴값이 있기때문에 사용가능

 

//클래스 만들고 객체생성, 객체호출//

---

---

2교시!

oprator,람다식 이용해서 최대값 구하기

package A;

import java.util.function.IntBinaryOperator;

public class Sample01 {

	// 정적변수

	static int[] scores = { 92, 93, 78 };

	static int maxOrMin(IntBinaryOperator operator) {
		int result = scores[0]; // result의 기능은 결과 저장

		// 향상된 for문
		for (int score : scores) {
			result = operator.applyAsInt(score, result);
		}

		return result;
	}

	public static void main(String[] args) {

		int max = maxOrMin((a, b) -> {
			if (a > b) {
				return a;
			} else {
				return b;
			}
		});
		System.out.println("최대값: " + max);

		int min = maxOrMin((a, b) -> {
			if (a > b) {
				return b;
			} else {
				return a;
			}
		});
		System.out.println("최소값: " + min);

	}

}

---

3교시

 

Predicate

매개변수가 있고, 리턴값도 있는데

리턴값이 무조건 boolean 타입으로(true, false)로 정해져있음! 

package A;

import java.util.function.Predicate;

public class Sample02 {

	public static void main(String[] args) {

		// 10이상이면 True, 아니면 False
		Predicate<Integer> p = (a) -> {
			if (a >= 10) {
				return true;
			} else {
				return false;
			}
		};

		System.out.println(p.test(15)); // 이 결과를 가지고 if문 작업을 더함

		if (p.test(15))
			System.out.println("10이상임");

		else
			System.out.println("10미만임");

	}
}

---

 

 

 

package A;

public class Student {

	String name;
	int eng;
	int math;
	String major;
		
	//생성자 만들기
		public Student(String name, int eng, int math, String major) {
		this.name = name;
		this.eng = eng;
		this.math = math;
		this.major = major;
	}

		// getter 만들기
		public String getName() {
			return name;
		}


		public int getEng() {
			return eng;
		}


		public int getMath() {
			return math;
		}


		public String getMajor() {
			return major;
		}

		


}

package A;

import java.util.function.Predicate;

public class Sample03 {

	// 전역에서 쓸 수 있는 변수 설정
	static Student[] list = {
			new Student("홍길동", 90, 80, "컴공"),
			new Student("이순신", 95, 70, "통계"),
			new Student("김유신", 100, 60, "컴공")
	};
	
	static double avgEng(Predicate<Student> predicate) {
	int count=0;
	int sum = 0;
	
		for (Student student :	list) {
			if (predicate.test(student)) { 
				count++;
				sum+= student.getEng();
			}
		}
		return (double)sum/count;
	}
	
	public static void main(String[] args) {

	double avg;
	
	avg=avgEng(t->t.getMajor().equals("컴공")); // .equals 같냐 다르냐 물어보는
	System.out.println(avg);
	
	}

}

결과값:95.0

---

---

4교시

이어서 합계 구하기

 

package A;

import java.util.function.Predicate;

public class Sample03 {

	// 전역에서 쓸 수 있는 변수 설정
	static Student[] list = { new Student("홍길동", 90, 80, "컴공"), new Student("이순신", 95, 70, "통계"),
			new Student("김유신", 100, 60, "컴공") };

	static int sumMath(Predicate<Student> predicate) {
		int count = 0;
		int sum = 0;

		for (Student student : list) {
			if (predicate.test(student)) {
				sum += student.getMath();
			}
		}
		return sum;
	}

	public static void main(String[] args) {

		int sum;

		sum = sumMath((t) -> t.getMajor().equals("컴공"));

		System.out.println("합계 : " + sum);

	}
}

---

전공이 컴공인 사람 구하기

 

package A;

import java.util.function.Predicate;

public class Sample03 {

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

	static int cnt(Predicate<Student> predicate) {
		
		int cnt = 0;

		for (Student student : list) {
			if (predicate.test(student)) {
				cnt++;
			}
		}
		return cnt;
	}

	public static void main(String[] args) {

		int cnt;

		cnt =cnt((t) -> t.getMajor().equals("컴공"));

		System.out.println("합계 " + cnt);

	}
}

---

---

5교시

인터페이스{ 

추상메서드;

defalut 메서드

}

default 메서드

andThen() 

Consumer, Fucntion,Operator

compose()

Function<T, R>, DoubleUnaryOperator

IntUnrayOperator, LongUnrayOperator 

(체이닝과 비슷한 개념)

---

andThen()

인터페이스A, 인터페이스B, 인터페이스AB

인터페이스AB=인터페이스A.andThen(인터페이스B);

최종결과 = 인터페이스 AB.method();

 

인터페이스AB.method() -> 인터페이스A(람다)

->인터페이스B(람다) -> 최종결과 리턴

---

compose

인터페이스A, 인터페이스B, 인터페이스AB

인터페이스AB=인터페이스A.compose(인터페이스B);

최종결과 = 인터페이스 AB.method();

 

인터페이스AB.method()-> 인터페이스B(람다)

-> 인터페이스 A(람다) -> 최종결과 리턴

---

예시 andThen() ↓ 

 

package A;

public class Member {

	String name;
	String id;
	
	public Member(String name, String id) {
		this.name=name;
		this.id=id;
	}

	public String getName() {
		return name;
	}

	public String getId() {
		return id;
	}

}

package A;

import java.util.function.Consumer;

public class Sample04 {

	public static void main(String[] args) {

		Consumer<Member> conA = (x) -> {
			System.out.println("conA :" + x.getName());
		};

		Consumer<Member> conB = (x) -> {
			System.out.println("conA :" + x.getId());
		};

		Consumer<Member> conAB = conA.andThen(conB);

//		conA.accept(new Member("홍길동", "hong"));
//		conB.accept(new Member("홍길동", "hong"));

		conAB.accept(new Member("홍길동", "hong"));

	}

}

 

---

예시2 compose ↓

compose

인터페이스A, 인터페이스B, 인터페이스AB

인터페이스AB=인터페이스A.compose(인터페이스B);

최종결과 = 인터페이스 AB.method();

 

인터페이스AB.method()-> 인터페이스B(람다)

-> 인터페이스 A(람다) -> 최종결과 리턴

 

package A;

import java.util.function.Function;

public class Sample05 {

	public static void main(String[] args) {
		
		Function<Integer, Integer> conA= (x) -> {
			return x*10;
		};
	
		
		Function<Integer, Integer> conB= (x) -> {
			return x-5;
		};
		
		Function<Integer, Integer> conAB= conA.compose(conB);
		int result= conAB.apply(10);
		
		System.out.println("compose : "+result );
	}

}

차이비교 ↓

package A;

import java.util.function.Function;

public class Sample05 {

	public static void main(String[] args) {
		
		Function<Integer, Integer> conA= (x) -> {
			return x*10;
		};
	
		
		Function<Integer, Integer> conB= (x) -> {
			return x-5;
		};
		
		Function<Integer, Integer> conAB= conA.compose(conB);
		int result= conAB.apply(10);
		
		System.out.println("compose : "+result );
		
		conAB= conA.andThen(conB);
		result = conAB.apply(10);
		System.out.println("andThen: " + result);
	}

}

---

---

스트림 

 

컬렉션 프레임워크(배열) 각각의 요소를 하나씩 참조해서 람다로 처리

표준화

 

-원본을 변경하지 않음 

-for -> 외부 반복 / 스트림 -> 내부 반복

- 재사용 불가( 코드를 다시 구현해서 만들어야함, 한번 만들면 끝)

-병렬 처리 지원

 

처리 순서

1. 생성

2. 가공(중개 연산-변환)

3. 결과

 

for문,while문( 외부반복) ,forEach(내부반복 차이)  ↓

package 스트림;

import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

public class Sample01 {

	public static void main(String[] args) {

		List<String> list = Arrays.asList(new String[] { "홍", "김", "이", "유" });

		int i = 0;

		System.out.println("for문 이용");
		for (i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}

		System.out.println("외부 반복자 이용");
		Iterator<String> it = list.iterator();
		while (it.hasNext()) {
			System.out.println(it.next());
		}
		System.out.println("내부 반복자 이용");
		list.stream().forEach(s-> System.out.println(s));
	}

}

결과값: for문 이용
홍
김
이
유
외부 반복자 이용
홍
김
이
유
내부 반복자 이용
홍
김
이
유

---

6교시

 

클래스↓

package 스트림;

public class Student {

	String name;
	int score;

	public Student(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}

	public String getName() {
		return name;
	}

	public int getScore() {
		return score;
	}

}

 

메인↓

package 스트림;

public class Student {

	String name;
	int score;

	public Student(String name, int score) {
		super();
		this.name = name;
		this.score = score;
	}

	public String getName() {
		return name;
	}

	public int getScore() {
		return score;
	}

}

결과값

이름 : 홍길동 점수 : 90
이름 : 고길동 점수 : 80

---

스트림에서

 

순차처리 ↓

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Sample03 {

	static void print(String str) {
		System.out.println(str + " : " + Thread.currentThread().getName());
	}

	public static void main(String[] args) {
		List<String> list = Arrays.asList("김", "이", "박", "최", "양", "남궁");
		// 순차 처리
		Stream<String> stream = list.stream();
		stream.forEach(Sample03::print);

	}

}

김 : main
이 : main
박 : main
최 : main
양 : main
남궁 : main

 

-병렬 처리 지원 ↓

	Stream<String> stream2 = list.parallelStream();
		stream2.forEach(Sample03::print);
	}

}

=========================
최 : main
남궁 : ForkJoinPool.commonPool-worker-2
김 : ForkJoinPool.commonPool-worker-11
양 : ForkJoinPool.commonPool-worker-2
박 : ForkJoinPool.commonPool-worker-11
이 : ForkJoinPool.commonPool-worker-9

---

package 스트림;

import java.util.Arrays;
import java.util.List;

public class Sample04 {

	public static void main(String[] args) {

	List<Student> list = Arrays.asList(
			new Student("홍길동", 90),
			new Student("고길동", 70),
			new Student("고기동", 88)
			);
		
		double avg = list.stream()
				.mapToInt(Student::getScore)
				.average()
				.getAsDouble();
		
		System.out.println("평균 : "+ avg);
	}

}

결과값: 평균 : 82.66666666666667

---

package 스트림;

import java.util.Arrays;
import java.util.stream.Stream;

public class Sample05 {

   public static void main(String[] args) {

      String[] arr = { "김", "박", "이", "최" };
         
      Stream<String> s1 = Arrays.stream(arr);   //배열을 스트림으로 만드는 작업
      //Stream<String> stream = list.stream():
      s1.forEach(a->System.out.print(a + " "));
      
     System.out.println();
     
      Stream<String> s2= Arrays.stream(arr, 1, 4);
      s2.forEach(a->System.out.print(a + " ")); // 범위만 정해지게 끔 

   }
}

결과값: 

김 박 이 최 

박 이 최 (1번방 부터 4번방 전까지!!)  

 

 

---

package 스트림;

import java.util.Arrays;
import java.util.stream.IntStream;
import java.util.stream.Stream;

public class Sample05 {
   
   static int sum = 0;

   public static void main(String[] args) {


      String[] arr = {"김", "박", "이", "최", "남"};
      
      Stream<String> na = Arrays.stream(arr);
      na.forEach(a -> System.out.print(a + " "));
      
      System.out.println();
      
      //                      배열 index 1번 방 부터 4번 방 전!까지
      Stream<String> na2 = Arrays.stream(arr, 1, 4);
      na2.forEach(a -> System.out.print(a + " "));
      
      
      
      IntStream na3 = IntStream.rangeClosed(1,  100);
      na3.forEach(n -> sum += n); // 1부터 100까지 누적 합계
         
      System.out.println("합 : " + sum);
      
   }

}

---

---

7교시

가공(중개 연산)

중복제거

 

package 스트림;

import java.util.Arrays;
import java.util.List;

public class Sample06 {

	public static void main(String[] args) {

	List<String>list = Arrays.asList("홍길동","김유신","홍길동","김유신","홍길동","유관순");
		
	// 중복제거
	list.stream().distinct().forEach(n->System.out.println(n));
	
	}
}

	//filter
    list.stream().filter(n->n.startsWith("홍")).forEach(n->System.out.println(n));
	
	}
}

홍으로 시작하는것 (중복포함)

결과값

홍길동
홍길동
홍길동

	list.stream().filter(n->n.startsWith("홍")).distinct().forEach(n->System.out.println(n));
	
	}
}

홍으로 시작하는것 (중복제거)

결과값

홍길동

---

필터 이용해서 홀수에 해당하는 것만 추출하기

 

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

public class Sample06 {

	public static void main(String[] args) {

	List<String>list = Arrays.asList("홍길동","김유신","홍길동","김유신","홍길동","유관순");
		
	// 중복제거
//	list.stream().distinct().forEach(n->System.out.println(n));
	
	//filter
//	list.stream().filter(n->n.startsWith("홍")).distinct().forEach(n->System.out.println(n));
	
	IntStream s= IntStream.of(1,2,3,4,5,6,7,8,9,10);
	
	s.filter(n-> n%2==1).forEach(n->System.out.println(n));
	}
}

결과값: 1 3 5 7 9

---

flatmap 메서드 

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Sample07 {

	public static void main(String[] args) {

		List<String> list1 = Arrays.asList("동해 물과", "백두 산이", "마르고 닳도록");

		list1.stream().flatMap(data -> Arrays.stream(data.split(" ")))
										.forEach(System.out::println);

		System.out.println();
		list1.stream().flatMap(data->Stream.of(data.split(" ")))
		.forEach(System.out::println);
	}

}

결과값

 

동해
물과
백두
산이
마르고
닳도록

동해
물과
백두
산이
마르고
닳도록

(딱딱 잘린 형태로 나옴)

---

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

public class Sample07 {

	public static void main(String[] args) {

		List<String> list1 = Arrays.asList("동해 물과", "백두 산이", "마르고 닳도록");


		list1.stream().map(data->data.length())
		.forEach(System.out::println);
	}
}

결과값(정수로 리턴시켜줌)

5
5
7

---

문자열이었던 것을 실수(정수도 똑같음) 로 변환하는 법

trim 기능

package 스트림;

import java.util.Arrays;
import java.util.List;
import java.util.stream.DoubleStream;
import java.util.stream.Stream;

import sun.java2d.d3d.D3DSurfaceData;

public class Sample07 {

	public static void main(String[] args) {

		List<String> list2= Arrays.asList("1.1,2.2,3.3,4.4,5.5,6.6");
		DoubleStream ds=list2.stream().flatMapToDouble(data->{
		
			String [] arr = data.split(",");
		double[] darr = new double [arr.length];
		
			for (int i = 0; i < darr.length; i++) {			//trim메서드를 통해서 공백(space바)제거 한뒤 
				darr[i] = Double.parseDouble(arr[i].trim()); // Double.parseDouble 실수 형태로 형변환 하는 메서드
															
			}
			return Arrays.stream(darr);
		});
		ds.forEach(System.out::println);
	}
}

---

---

skip 기능

4개를 스킵시켜라-> 0,1,2,3 이 넘어가고 4부터 나타나게 됨 ↓

package 스트림;

import java.util.stream.IntStream;

public class Sample08 {

	public static void main(String[] args) {

	IntStream s = IntStream.range(0,10);
	
	s.skip(4).forEach(n->System.out.print(n));
	
	}

}

limit 기능

4개까지만 limit시켜라-> 4개까지만 나오고 더 안나옴(한계치 지정할 때 쓰임)

package 스트림;

import java.util.stream.IntStream;

public class Sample08 {

	public static void main(String[] args) {

	IntStream s = IntStream.range(0,10);
	
	s.limit(4).forEach(n->System.out.print(n));
	
	}

}

 

skip, limit 순서대로 사용할 때 ↓

package 스트림;

import java.util.stream.IntStream;

public class Sample08 {

	public static void main(String[] args) {

	IntStream s = IntStream.range(0,10);
	
	s.skip(3).limit(4).forEach(n->System.out.print(n));
	
	}

}

 결과값: 3 4 5 6

imit,skip순서대로 사용할 때 ↓

package 스트림;

import java.util.stream.IntStream;

public class Sample08 {

	public static void main(String[] args) {

	IntStream s = IntStream.range(0,10);
	
	s.limit(4).skip(3).forEach(n->System.out.print(n));
	
	}

}

결과값:3 

 

---

---

마지막교시!!

package 스트림;

import java.util.Arrays;
import java.util.List;

public class Sample09 {

	public static void main(String[] args) {

		List<String> list = Arrays.asList("홍길동","김유신","이순신","유관순");
		
		list.stream().sorted().forEach(System.out::println);
		
	}

}

결과값

김유신
유관순
이순신
홍길동

---

package 스트림;

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

public class Sample09 {

   public static void main(String[] args) {
      
      List<String> list = Arrays.asList("홍길동", "김유신", "이순신", "유관순");
      
      //.sorted() <-- 오름차순 정렬 메서드
      list.stream().sorted(Comparator.reverseOrder()).forEach(System.out::println);

   }

}

결과값: 역순으로 나옴

---

long

package 스트림;

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

public class Sample09 {

	public static void main(String[] args) {

		int[] arr = new int[100];

		for (int i = 0; i < 100; i++) {
			arr[i] = i + 1;
		}
		long c = Arrays.stream(arr).count();
	
		System.out.println("count : "+ c);
	
	}

}

결과값: count : 100

 

 

int 고정은 아니지만(double도 될수도 있고 등등) sum 관련 

		int s = Arrays.stream(arr).sum();
		System.out.println("sum :"+ s);
	}

}

결과값: sum :5050

 

findFirst 첫번쨰 타입 찾기

		OptionalInt fisrt= Arrays.stream(arr).findFirst();
		System.out.println("first : " + fisrt.getAsInt());
	}

}

결과값: 1

---

Optional 이란

Optional클래스  NPE(null point exception) 예외 빈칸(공백)에 관련된 예외처리!

 

Optional클래스 널값(null)  감싸는 wrapper 클래스 

 

 

최대값 구하기(max를 min으로 바꾸면 최소값) 

OptionalInt max= Arrays.stream(arr).max();
		System.out.println("최대값: " + max);
	}

}

 

---

.anyMatch (true or false 밖에 안됨)

.allMatch(true or false 밖에 안됨)

package 스트림;

import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.OptionalInt;

public class Sample09 {

	public static void main(String[] args) {

		int[] arr = new int[100];

		for (int i = 0; i < 100; i++) {
			arr[i] = i + 1;
		}
		long c = Arrays.stream(arr).count();
		System.out.println("count : "+ c);
	
	
		int s = Arrays.stream(arr).sum();
		System.out.println("sum :"+ s);
	
		OptionalInt fisrt= Arrays.stream(arr).findFirst();
		System.out.println("first : " + fisrt.getAsInt());
		
		OptionalInt max= Arrays.stream(arr).max();
		System.out.println("최대값: " + max);
	
		System.out.println(Arrays.stream(arr).anyMatch(n-> n> 80));
		System.out.println(Arrays.stream(arr).allMatch(n-> n>= 1));
	
	}

}

 

결과값~~~~~

true

true

---

---

짝수만 중복 제거해서 내림차순 정렬 출력(Stream 사용해서) 스트림 사용안해서

package 스트림;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Set;

public class Sample10 {

	public static void main(String[] args) {

		int[] data = { 5, 6, 4, 2, 3, 1, 1, 2, 2, 4, 8 };

		ArrayList<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < data.length; i++) {
			if (data[i] % 2 == 0) {
				list.add(data[i]); // 짝수 추출
			}
		}
		System.out.println(list);

		HashSet<Integer> set = new HashSet<>(list); // 중복 제거
		System.out.println(set);

		ArrayList<Integer> dlist = new ArrayList<>(set);
		dlist.sort(Comparator.reverseOrder()); // 역순으로 정렬
		System.out.println(dlist);

		int[] result = new int[dlist.size()]; //

		for (int i = 0; i < result.length; i++) {
			result[i] = dlist.get(i);
		}
		for (int i = 0; i < result.length; i++) {
			System.out.print(result[i]);
		}
	}
}

짝수만 중복 제거해서 내림차순 정렬 출력(Stream 사용해서) 스트림 사용해서

package 스트림;

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

public class Sample11 {

	public static void main(String[] args) {

		int[] data = { 5, 6, 4, 2, 3, 1, 1, 2, 2, 4, 8 };
		int[] result = Arrays.stream(data).	// IntStream 생성 
				boxed()						// IntStream -> Stream<Integer>
				.filter(n -> n % 2 == 0)	//짝수
				.distinct()					// 중복제거
				.sorted(Comparator.reverseOrder()) // int로 작업을 못하고 Integer로만 가능 
				.mapToInt(Integer::intValue)	// Integer를 다시 int로 변환
				.toArray(); // 배열로 변환

		for (int i = 0; i < result.length; i++) { // 배열 출력할 때는 for문사용
			System.out.println(result[i]);
		}
	}

}

 

---