자바/스프링 부트캠프 19일차(람다식과 스트림 )

1) 람다식

 

1-1) Consumer

1-2)Supplier

1-3) Function

1-4) Operator

1-5) Predicate

1-6) 정리

 

2) 스트림

 

---

1-1) Consumer

 

* java ApI에서 제공되는 인터페이스

* - java.util.function 패키지에 속한 인터페이스

* - 랃다를 이용하기위한 인터페이스 ( 함수적인터페이스)

*

* Consumer 인터페이스

* void accept (매개변수) : 매개변수가있고 리턴값은 없는 메서드

* Consumer<T> : void accept(T)

* BioConsumer<T,U> : void accept(T,U)

* IntConsumer : void accept(int)

* doubleConsumer : void accept(double)

* longConsumer : void accept(long)

* ObjIntConsumer : void accept(T,int)

* ObjLongConsumer : void accept(T,long)

* ObjDoubleConsumer : void accept(T,double)

* 이들 모두 리턴값은 없음

 

package ex1_conumer;

import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.IntConsumer;
import java.util.function.ObjDoubleConsumer;

public class ConsumerEx1 {
	public static void main(String[] args) {
							//여기서t는 제네릭을 따라가므로 String
		Consumer<String> c1 = t->System.out.println(t+8);
		c1.accept("Java");//t값을 정해준거임
		
		Consumer<Integer> c1_1 = t->System.out.println(t*10);
		c1_1.accept(10);//10*10
		
		//제네릭을 두개를 가진다.
		BiConsumer<String, String> c2 = (t,c)->System.out.println(t+c);
		c2.accept("Java", "8.0");//둘이 합침
		c2=(t,c)->System.out.println(t.substring(0,1)+c.substring(0,1));
		c2.accept("Java", "8.0");//각 첫번째문자만 출력
		
		IntConsumer c3 = t->System.out.println(t*100);
		c3.accept(10);//10*100
		
		c3=t->{//블럭문이 한줄 이상일경우 {...}; 이용
			int sum = 0;
			for (int i = 1; i <= t; i++) {
				sum+=i;
			}
			System.out.println("1에서"+t+"까지의 합 : "+sum);
		};
		c3.accept(100);//100까지의합
		c3.accept(10);
		
		ObjDoubleConsumer<Integer> c4 = (t,u)->{
			System.out.println(t*u);
		};
		c4.accept(10, 3.24);
	}
}

/*
출력
Java8
100
Java8.0
J8
1000
1에서100까지의 합 : 5050
1에서10까지의 합 : 55
32.400000000000006
*/

 

---

1-2) Supplier

 

Supplier 관련 인터페이스

* T getXXX() : 매개변수가없고 리턴값 존재

* Supplier<T> : T get()

* IntSupplier : int getAsInt()

* DoubleSupplier : double getAsDouble()

* BooleanSupplier : boolean getAsBoolean()

 

package ex2_Supplier;

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

public class SupplierEx1 {
	public static void main(String[] args) {
		Supplier<String> s1 = ()->{
			return "java";
		};
		System.out.println(s1.get());
		IntSupplier s2 = ()->new Random().nextInt(6)+1;//1~6 랜덤한정수
		System.out.println(s2.getAsInt());
		double[] arr = {1,1.2,2.4, 5.3 ,10 ,3};//double형배열
		DoubleSupplier s3 = () ->{
			double sum=0;
			for (double d : arr) {
				sum+=d;
			}
			return sum;//double형 sum 반환(
		};
		System.out.println(s3.getAsDouble());
	}
}

/*
출력
java
6
22.0

*/

---

간단한 예제

배열의합이 짝수인지 홀수인지 BooleanSupplier를 이용해

람다식이용해서 판별해보자

package ex2_Supplier;

import java.util.function.BooleanSupplier;

public class Exam1 {

	
	public static void main(String[] args) {
		int[] data= {1,2,5,78,4,6,8,12,10};
		BooleanSupplier b = ()->{
			int sum=0;
			for (int i : data) {
				sum+=i;
			}
			System.out.println(sum);
			return sum%2==0?true:false;
			//sum이짝수이면 true 아니면 false를 반환하게될것
		};
		
		if(b.getAsBoolean()) {//true
			System.out.println("짝수");
		}
		else {//false
			System.out.println("홀수");
		}	
	}
}
/*
126
짝수
*/

---

@@ 1-3) Function 인터페이스  @@

* Function 계열 인터페이스

* R applyXXX(T) : 매개변수 존재 , 리턴값 존재

 

* Function<T,R> :     R apply(T);

T를넣어 R을반환함

T - 함수에 대한 입력의 유형

R - 함수 결과의 유형

 

 BiFunction<T,U,R> : R apply(T,U);

 T,U 두가지의 매개변수를 받아 R을 반환

 

 IntFunction<R> : R apply(int)

 

 DoubleFunction<R> : R apply(double)

 

 ToIntFunction<T> :      int applyAsInt(T)

T를 넣어 int를 반환함

 

 

 

 

예시

package ex3_Function;

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

class Student{
	private String name;
	private int eng;
	private int math;
	private String major;
	public Student(String name, int eng, int math, String major) {
		super();
		this.name = name;
		this.eng = eng;
		this.math = math;
		this.major = major;
	}
	//getter : 멤버변수값 리턴 String getName() -> nameGet Property
	//setter : 멤버변수값 세팅 void setName(String name)->nameSet property
	public String getName() {
		return name;
	}

	public int getEng() {
		return eng;
	}

	public int getMath() {
		return math;
	}

	public String getMajor() {
		return major;
	}
}
public class FunctionEx1 {
	private static Student[] list = {
			new Student("홍길동", 90, 80, "경영"),
			new Student("김삿갓", 70, 70, "수학"),
			new Student("이몽룡", 80, 60, "통계")
	};
	public static void main(String[] args) {
		System.out.print("학생의이름 : ");
		for (Student s : list) {
			System.out.print(s.getName()+",,");
		}
		System.out.println();
		
		System.out.printf("학생의 이름 :");
		//s는 Student타입이므로 getName호출이가능하며
		//반환값이 String이므로 return getName()!!!
		Function<Student, String> f1 = s->s.getName();
		for (Student s : list) {
			System.out.print(f1.apply(s)+",");
		}
		System.out.println();
		System.out.printf("학생이름 : ");
		//s:Student , return값 : String
		printString(s->s.getName());
		
		
		System.out.println();
		System.out.printf("전공명 : ");
		printString(s->s.getMajor());
		
		//함수변경!!!
		//반환값을 Integer로 변경했다
		System.out.println();
		System.out.printf("수학점수 : ");
		printInt(s->s.getMath());
		
		System.out.println();
		System.out.printf("영어점수 : ");
		//s:Student , return값 : String
		printInt(s->s.getEng());
		
		System.out.println();
		System.out.printf("학생이름(영어점수):");
		printString(s->s.getName()+"("+s.getEng()+")");
		
		System.out.println();
		System.out.print("학생이름(수학점수) : ");
		printString(s->s.getName()+"("+s.getMath()+")");

	}
	static void printString(Function<Student, String> f) {
		for(Student s : list) {
			System.out.print(f.apply(s)+",");
		}
	}
	static void printInt(ToIntFunction<Student> f) {
		for(Student s : list) {
			System.out.print(f.applyAsInt(s)+",");
            //applyAsInt에 s.getEng()등의 int형값이 들어갈수있음
		}
	}
}

---

ToIntFunction 활용한 예제

 

package ex3_Function;

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

public class Exam {
	private static Student[] list = {
			new Student("홍길동", 92, 81, "경영"),
			new Student("김삿갓", 72, 72, "수학"),
			new Student("이몽룡", 83, 67, "통계")
	};
	public static void main(String[] args) {
		System.out.println("학생들의 영어점수 합계 : ");
		printTot(s->s.getEng());
		System.out.println("학생들의 수학점수합계");
		printTot(s->s.getMath());//Student타입이며 int로반환되는 값만 넣을수있음
		
		System.out.println("학생들의 영어점수 합계  :"+getTot(s->s.getEng()));
		System.out.println("학생들의 수학점수 합계  :"+getTot(s->s.getMath()));
		System.out.println("학생들의 영어점수 평균  :"+getAvg(s->s.getEng()));
		System.out.println("학생들의 수학점수 평균  :"+getAvg(s->s.getMath()));
	}
	
	private static Double getAvg(ToDoubleFunction<Student> f) {
		double sum=0;
		for(Student s : list) {
			sum+=f.applyAsDouble(s);
		}
		return sum/list.length;
	}

	private static int getTot(ToIntFunction<Student> f) {
		int sum=0;
		for (Student s : list) {
			sum+=f.applyAsInt(s);
		}
		return sum;
	}
    
	private static void  printTot(ToIntFunction<Student> f ) {
		int sum=0;
		for (Student s : list) {
			sum+=f.applyAsInt(s);
			//밖에서 람다식을 통해 applyAsInt()메서드를 이용가능
			//즉 f.applyAsInt(s)는 무조건Student타입만 받을수있으며
			// s->s.getEng()가 들어온다면 int형으로 반환해준다
			// f.applyAsInt(s) == s.getEng()
		}
		System.out.println(sum);	
	}
}

학생들의 영어점수 합계 :

247

학생들의 수학점수합계

220

학생들의 영어점수 합계 :247

학생들의 수학점수 합계 :220

학생들의 영어점수 평균 :82.33333333333333

학생들의 수학점수 평균 :73.33333333333333

---

@@ 1-4)Operator 인터페이스 @@

 Operator 인터페이스

 Function 인터페이스의 하위인터페이스

 매개변수,리턴값 모두존재

 T applyXXXX(T)

 

 

- 종류

* UnaryOperator<T> : T apply(T)

* DoubleUnaryOperator : double apply(double)

* IntUnaryOperator : int apply(int)

* LongUnaryOperator : long apply(long)

* BinaryOperator<T> : T apply(T t1, T t2) => BiFunction인터페이스의 하위

* DoubleBinaryOperator : double apply(double,double)

* IntBinaryOperator : int apply(int,int)

* LongBinaryOperator : long apply(long,long)

 

package ex4_operator;

import java.util.function.BinaryOperator;
import java.util.function.IntBinaryOperator;

public class OperatorEx1 {
	private static int[] score= {92,95,76};
	public static void main(String[] args) {
		System.out.print("최대값 : ");
		int max=score[0],min = score[0];
		for (int i : score) {
			max= i<max?max:i;
		}
		System.out.println(max);
		System.out.print("최솟값");
		for (int i : score) {
			min= min<i?min:i;
		}
		System.out.println(min);//원래사용했던방법들
		
		
        //IntBinaryOprator를 이용한 메서드 활용
		System.out.println("최대값 : "+maxOrMin((a,b)->a>b?a:b));
		System.out.println("최소값 : "+maxOrMin((a,b)->a<b?a:b));
	}
	private static int maxOrMin(IntBinaryOperator op) {
		int num=score[0];
		for (int i : score) {
			num= op.applyAsInt(num, i);
			//(a,b)->a>b?a:b 의경우 : num과 i중 num이 크면 num반환 아니라면 i 반환
			//배열의 크기만큼 루프를돌림
		}
		return num;
	}
}

최대값 : 95

최솟값76

최대값 : 95

최소값 : 76

 

---

예제) BinaryOperator 활용

 

BinaryOperator <T> f = f.apply(T t1,T t2)

package ex4_operator;

import java.util.Arrays;
import java.util.List;
import java.util.function.BinaryOperator;
import java.util.function.IntBinaryOperator;

class Student{
	private String name;
	private int eng;
	private int math;
	public Student(String name, int eng, int math) {
		super();
		this.name = name;
		this.eng = eng;
		this.math = math;
	}
	public String getName() {
		return name;
	}
	public int getEng() {
		return eng;
	}
	public int getMath() {
		return math;
	}
	@Override
	public String toString() {
		return "[name=" + name + ", eng=" + eng + ", math=" + math + "]";
	}

}
public class OperatorEx2 {
	public static void main(String[] args) {
		List<Student> list = Arrays.asList(new Student("유재석", 100, 90),
				new Student("하하", 70, 60),
				new Student("광수", 55, 100));
		System.out.println("영어점수 최고자 : "+minOrMax(list,(a,b)->a.getEng()>b.getEng()?a:b));
		System.out.println("수학점수 최고자 : "+minOrMax(list,(a,b)->a.getMath()>b.getMath()?a:b));
		System.out.println("영어점수 최저자 : "+minOrMax(list,(a,b)->a.getEng()<b.getEng()?a:b));
		System.out.println("수학점수 최저자 : "+minOrMax(list,(a,b)->a.getMath()<b.getMath()?a:b));
		System.out.println("합계점수 최고자 : "+minOrMax(list,(a,b)->a.getMath()+a.getEng()>b.getMath()+b.getEng()?a:b));
		System.out.println("합계점수 최저자 : "+minOrMax(list,(a,b)->a.getMath()+a.getEng()<b.getMath()+b.getEng()?a:b));
		
	}


private static Student minOrMax(List<Student> list,BinaryOperator<Student> f ) {
	Student result =list.get(0);
	for (Student s : list) {
		result = f.apply(result, s);
        //				a      ,  b   라고생각하자
		}
	return result;
	}

}

영어점수 최고자 : [name=유재석, eng=100, math=90]

수학점수 최고자 : [name=광수, eng=55, math=100]

영어점수 최저자 : [name=광수, eng=55, math=100]

수학점수 최저자 : [name=하하, eng=70, math=60]

합계점수 최고자 : [name=유재석, eng=100, math=90]

합계점수 최저자 : [name=하하, eng=70, math=60]

 

---

1-5)  @@ Predicate 인터페이스  @@

 

 Predicate 인터페이스
 *  boolean test(T) : 매개변수존재, 리턴타입은 boolean
 * 
 * Predicate<T> :   boolean test(T)
 * IntPredicate :   boolean test(int)
 * LongPredicate :   boolean test(long)
 * DoublePredicate :   boolean test(double)

package ex5_Predicate;

import java.util.Arrays;
import java.util.List;
import java.util.function.DoubleBinaryOperator;
import java.util.function.DoublePredicate;
import java.util.function.DoubleUnaryOperator;import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;


class Student{
	private String name;
	private String gendar;
	private int eng;
	private int math;
	public Student(String name, String gendar, int eng, int math) {
		super();
		this.name = name;
		this.gendar = gendar;
		this.eng = eng;
		this.math = math;
	}
	public String getName() {
		return name;
	}
	public String getGendar() {
		return gendar;
	}
	public int getEng() {
		return eng;
	}
	public int getMath() {
		return math;
	}
	@Override
	public String toString() {
		return  "["+name + ", gendar=" + gendar + ", eng=" + eng + ", math=" + math + "]";
	}
	
	
}
public class PredicateEx1 {
	public static void main(String[] args) {
		List<Student> list = Arrays.asList(new Student("유재석", "남", 89, 99),
				new Student("유나", "여", 56, 78),
				new Student("원영", "여", 100, 100),
				new Student("이술인", "남", 55, 50));
		System.out.println("영어점수가 60이상인 학생의 영어평균 : "+avg(list,s->s.getEng()>=60));
		
		System.out.println("영어점수가 60이상인 학생의 영어평균 : "+
		avg(list,s->{
			return s.getEng()>=60;}));
		System.out.println("영어점수60이상의평균(ToDoubleFunction활용) : "+avgFun(list, s->{
			return s.getEng();
		}));
		System.out.println("수학점수60이상의평균(ToDoubleFunction활용) : "+avgFun(list, s->{
			return s.getMath();
		}));
		
		System.out.println("여학생 영어평균 : "+avg(list,s->s.getGendar().equals("여")));
		System.out.println("남학생 영어평균 : "+avg(list,s->s.getGendar().equals("남")));
		
	}

	private static double avg(List<Student>list, Predicate<Student> p) {
							//p : s.getEng() >=60
		double sum=0;
		int count=0;
		for (Student s : list) {
			//
			if(p.test(s)) {
				//f.test(s) : s.getEng() >=60 인경우에만 true
				sum+=s.getEng();
				count++;//60점이상의경우에만 count를올려줌
			}
		}
		return sum/count;
	}
	
	private static double avgFun(List<Student> list ,ToDoubleFunction<Student>f ) {
		double sum=0;
		int count=0;
		for (Student s : list) {
			if(s.getEng()>=60) {
			sum+= f.applyAsDouble(s);
			count++;
			}
		}return sum/count;
	}
}

영어점수가 60이상인 학생의 영어평균 : 94.5

영어점수가 60이상인 학생의 영어평균 : 94.5

영어점수60이상의평균(ToDoubleFunction활용) : 94.5

수학점수60이상의평균(ToDoubleFunction활용) : 99.5

여학생 영어평균 : 78.0

남학생 영어평균 : 72.0

 

 

---

1-6) @@ 총 정리 @@ 

 

인터페이스	메서드동작방식	메서드
Consumer	* void accept (매개변수) : 매개변수가있고 리턴값은 없는 메서드	* Consumer<T> : void accept(T) * BioConsumer<T,U> : void accept(T,U) * IntConsumer : void accept(int) * doubleConsumer : void accept(double) * longConsumer : void accept(long) * ObjIntConsumer : void accept(T,int) * ObjLongConsumer : void accept(T,long) * ObjDoubleConsumer : void accept(T,double)
Supplier	T getXXX() : 매개변수가없고 리턴값 존재	* Supplier<T> : T get() * IntSupplier : int getAsInt() * DoubleSupplier : double getAsDouble() * BooleanSupplier : boolean getAsBoolean()
Function	* R applyXXX(T) : 매개변수 존재 , 리턴값 존재	* Function<T,R> :     R apply(T); T를넣어 R을반환함 T - 함수에 대한 입력의 유형 R - 함수 결과의 유형  BiFunction<T,U,R> : R apply(T,U);  T,U 두가지의 매개변수를 받아 R을 반환  IntFunction<R> : R apply(int)  DoubleFunction<R> : R apply(double)  ToIntFunction<T> :      int applyAsInt(T) T를 넣어 int를 반환함
Operator	Function 인터페이스의 하위인터페이스  매개변수,리턴값 모두존재  T applyXXXX(T)	* UnaryOperator<T> : T apply(T) * DoubleUnaryOperator : double apply(double) * IntUnaryOperator : int apply(int) * LongUnaryOperator : long apply(long) * BinaryOperator<T> : T apply(T t1, T t2) => BiFunction인터페이스의 하위 * DoubleBinaryOperator : double apply(double,double) * IntBinaryOperator : int apply(int,int) * LongBinaryOperator : long apply(long,long)
Predicate	*  boolean test(T) : 매개변수존재, 리턴타입은 boolean	*   * Predicate<T> :   boolean test(T)  * IntPredicate :   boolean test(int)  * LongPredicate :   boolean test(long)  * DoublePredicate :   boolean test(double)

---

 

@@ 2) 스트림 @@

스트림 맛보기

package ex1_iterator;

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

public class IteratorEx1 {
	public static void main(String[] args) {
		List<String> list = Arrays.asList(new String[]{"홍길동","임춘향","김삿갓","임꺽정","향단이"});
		System.out.println("외부반복자 이용");
		Iterator<String> it = list.iterator();
        
        //다음요소가 존재하면true
		while(it.hasNext()) {
			System.out.println(it.next());
			//요소가있다면 출력!!
		}
        
		//list.stream() : Stream 객체 리턴
		System.out.println("\n 내부반복자(stream)이용");
		list.stream().forEach(s->System.out.println(s));
		//forEach는 Consumer타입임
	}
}

/*
외부반복자 이용
홍길동
임춘향
김삿갓
임꺽정
향단이

 내부반복자(stream)이용
홍길동
임춘향
김삿갓
임꺽정
향단이

*/

 

2-1) Stream<T> 과 IntStream 생성 및 사용

package ex2_array;

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

/*
 * 배열객체 이용해 stream객체 생성
 */
public class ArraysEx1 {

	public static void main(String[] args) {
		
//----------------------------------Stream<T>-----------------------------
		String[] arr = new String[] {"a","b","c"};
		Stream<String> stream1 = Arrays.stream(arr);
		stream1.forEach(s->System.out.print(s+"\t"));
		System.out.println();
		Stream<String> stream2 = Arrays.stream(arr,1,3);//1번2번 배열만.!
		stream2.forEach(s->System.out.print(s+"\t"));
		System.out.println();
		//Collection.stream()
		List<Object> list = Arrays.asList(1,2,4,5,"하하","안녕");
		Stream<Object> stream3 = list.stream();
		stream3.forEach(s->System.out.printf(s+"\t"));
		
//-----------------------------IntStream-----------------------------------
		int[] intArr = {1,2,3,4,5};
		System.out.println("\nArrays.stream메서드 이용-->IntStream 생성");
		IntStream intSt1 = Arrays.stream(intArr);
		intSt1.forEach(s->System.out.print(s+"\t"));
		System.out.println();
		
		IntStream intSt2 = IntStream.of(intArr);
		intSt2.forEach(s->System.out.printf(s+"\t"));
		System.out.println();
		
		//rangeClosed(1,5) :1~5까지의숫자를 IntStream으로생성
		IntStream intSt3 = IntStream.rangeClosed(1, 5);
		intSt3.forEach(s->System.out.print(s+"\t"));
		System.out.println();
	}
}

a b c

b c

1 2 4 5 하하 안녕

Arrays.stream메서드 이용-->IntStream 생성

1 2 3 4 5

1 2 3 4 5

1 2 3 4 5

---

2-2) filter  ( 데이터를 걸러준다)

 * distinct() 중복요소제거
 * filter(Predicate p) : p가 true인경우에만 실행이계속된다.

package ex3_filter;

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

public class FilterStreamEx1 {
	public static void main(String[] args) {
		List<String> list = Arrays.asList("홍길동","김삿갓","홍길동","임꺽정","홍길동");
		list.stream().forEach(s->System.out.print(s+"\t"));
		System.out.println();
		System.out.println("==중복제거 출력== ");
		//중복내용제거출력
		list.stream().distinct().forEach(s->System.out.print(s+"\t"));
		System.out.println();
		
		System.out.println("==\"홍\" 으로시작하는 문자열 모두출력==");
		list.stream().filter(n->n.startsWith("홍")).forEach(s->System.out.printf(s+"\t"));
		System.out.println();
		
		System.out.println("==\"홍\" 으로시작하는 문자열 모두출력(중복제거)==");
		list.stream().
		filter(n->n.startsWith("홍")).distinct().forEach(s->{
			System.out.println("index : "+list.indexOf(s));//해당요소인덱스반환
			System.out.print(s+"\t");
		});
		//filter()로 stream의 데이터를 걸러준다 
	}
}

홍길동 김삿갓 홍길동 임꺽정 홍길동

==중복제거 출력==

홍길동 김삿갓 임꺽정

=="홍" 으로시작하는 문자열 모두출력==

홍길동 홍길동 홍길동

=="홍" 으로시작하는 문자열 모두출력(중복제거)==

index : 0

홍길동

---

2-3) map함수 (컬렉션프레임워크map과 다른것)

 * map : 스트림의요소를 다른요소로 변경할수있는 함수
 *  mapXXXX
 * 
 * mapToInt : Stream형 함수 -> IntStream 형

mapToInt(s->s.length());

s객체의 각요소의 길이로 IntStream을 만들자

 

Stream의 주의점 :

1회용이기때문에 순회를 종료 후

검색을 하려고하면 안됨

 

 * 메서드종류
 * Stream<R> map<Funcion<T,R>> :   T형을입력받아 R형 Stream 생성 
 * Stream<R> mapToObj(DoubleFunction<R>) :  double형을 입력받아 R리턴해 R형 Stream생성
 * Stream<R> mapToObj(IntFunction<R>) :  int형을 입력받아 R리턴해 R형 Stream생성
 * Stream<R> mapToObj(LongFunction<R>) :  long형을 입력받아 R리턴해 R형 Stream생성
 * 
 * IntStream mapToInt(ToIntFuction<T>) : T형 입력받아 int형 리턴해 IntStream생성
 * IntStream map(IntUnaryOperator) : int형 입력받아 int형 리턴해 IntStream생성
 * IntStream mapToLong(ToLongFunction<T>) : T형 입력받아 long형 리턴해 LongStream생성
 * IntStream mapToDouble(ToDoubleFunction<T>) : T형 입력받아 double형 리턴해 DoubleStream생성

package ex4_map;

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



public class MapEx1 {
	public static void main(String[] args) {
		List<String> list = Arrays.asList("홍길동2","김삿갓","구운몽","임꺽정나간다","전우치43","이순신");
		System.out.println();
		//글자의 크기로 새로운 IntStream 생성
		//Stream<String> list.stream();(리스트의요소를 가지고있는 stream)
//		IntStream isr = list.stream().mapToInt(String::length);//각 String의length를 반환함
		IntStream isr = list.stream().mapToInt(s->s.length());//각 String의length를 반환함
	
		isr.forEach(System.out::println); /* 주의 : 한번만읽으면 다시 읽을 수 없게됨 */
		//stream은 1회용이라 생각해라 한번 순회하면 다시조회가불가능함!!!
		System.out.println("전제문자열크기 " + list.stream().mapToInt(s->s.length()).sum());
		System.out.println("전제문자열 갯수 " + list.stream().count());
		
		//1~100의 합 출력
		System.out.println("1~100의 합 : "+IntStream.range(1,101).sum());
		
		//list를 요소로 가진 학생 객체를 출력하기
		Stream<Student> sts = list.stream().map(s->new Student(s,0,0));
		//s(list) 입력받아서 Student형 Stream 반환
		sts.forEach(System.out::println);
	}
}

 

4

3

3

6

5

3

전제문자열크기 24

전제문자열 갯수 6

1~100의 합 : 5050

 

---

Map을 이용한 예제

package ex4_map;

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

class Student{
	String name;
	int eng;
	int math;
	public Student(String name, int eng, int math) {
		super();
		this.name = name;
		this.eng = eng;
		this.math = math;
	}
	public String getName() {
		return name;
	}
	public int getEng() {
		return eng;
	}
	public int getMath() {
		return math;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", eng=" + eng + ", math=" + math + "]";
	}
	
	
}
public class Exam1 {
	public static void main(String[] args) {
		List<Student> list = Arrays.asList(new Student("홍길동", 90, 80),
				new Student("김삿갓", 95, 80),
				new Student("이몽룡", 95, 80));
		
		//stream이용해 영어점수합 , 수학점수합 , 전체점수합 출력

		System.out.print("영어점수합  ");
		IntStream engSum = list.stream().mapToInt(s->s.eng);
		//s: student ->s.eng : s.eng만 사용해 IntStream타입으로만들자
		System.out.println(engSum.sum());
		//eng의 합
		
		System.out.print("수학점수합  ");
		IntStream mathSum = list.stream().mapToInt(s->s.math);
		//s: student ->s.math : s.math만 사용해 IntStream타입으로만들자
		System.out.println(mathSum.sum());
		
		System.out.print("전체점수합  ");
		IntStream totalSum = list.stream().mapToInt(s->s.math+s.eng);
		System.out.println(totalSum.sum());
		
		System.out.println("메서드 참조방식");
		System.out.print("영어점수합 : ");
		System.out.println(list.stream().mapToInt(Student::getEng).sum());
		System.out.print("수학점수합 : ");
		System.out.println(list.stream().mapToInt(Student::getMath).sum());
		
		System.out.print("영어 평균");
		System.out.println(list.stream().mapToInt(s->s.getEng()).average().getAsDouble());
						//double average() : 평균을 구해준다
		// getAsDouble() :  값이없다면 throws
		System.out.print("수학 평균");
		System.out.println(list.stream().mapToInt(s->s.getMath()).average().getAsDouble());
	}
}

영어점수합 280

수학점수합 240

전체점수합 520

메서드 참조방식

영어점수합 : 280

수학점수합 : 240

영어 평균93.33333333333333

수학 평균80.0