(39) [JAVA] 23일

람다식이란?
람다식은 메소드를 하나의 식으로 표현한 것
객체 지향 언어 보다는 함수 지향 언어에 가깝다.
메소드를 간략하면서도 명확한 식으로 표현할 수 있도록 해준다.
메소드를 람다식으로 표현하면 메소드의 이름 및 반환 값이 없어지므로 익명 함수 라고도 한다.
람다식의 형태는 매개 변수를 가진 코드 블록이지만 런타임 시에는 익명 구현 객체를 생성한다.

스트림(stream) 이란?
데이터 처리 연산을 지원하도록 소스에서 추출된 연속된 요소로 정의할 수 있다.
컬렉션과 마찬가지로 스트림은 특정 요소 형식으로 이루어진 연속된 값 집합의 인터페이스를 제공한다.
스트림은 컬렉션,배열,I/O 자원 등의 데이터 제공 소스로부터 데이터를 소비한다.

package ch17.streamEx;

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

public class Ex01 {

	public static void main(String[] args) {
		List<String> list=Arrays.asList("A","B","C");
		
		Iterator<String> it= list.iterator();
		while(it.hasNext()) {
			String s=it.next();
			System.out.println(s);
		}
		System.out.println();
		
		Stream<String> stream=list.stream();
		stream.forEach(System.out::println); // 메소드 참조 
		
	}
}

package ch17.lambdaEx;

public class Ex02 {

	public static void main(String[] args) {
		// 매개변수가 없고 리턴 타입이 void 인 람다식
		
		/*
		User2 u;
		u = () -> { System.out.println("람다식..."); };
		*/
		
		// User2 u =() -> { System.out.println("람다식..."); };
		
		User2 u =() -> System.out.println("람다식...");
		u.disp();
	}
}

interface User2 {
	public void disp();
}

package ch17.lambdaEx;

public class Ex03 {

	public static void main(String[] args) {
		// 하나의 매개변수와 리턴타입이 void 인 람다식
		// User3 u = (int a) -> { a+=10; System.out.println(a); };
		// User3 u = (a) -> { a+=10; System.out.println(a); };
		// User3 u = a -> { a+=10; System.out.println(a); };
		User3 u = a -> System.out.println(a+10);
		u.disp(10);
	}
}

interface User3 {
	public void disp(int a);
}

package ch17.lambdaEx;

public class Ex03 {

	public static void main(String[] args) {
		// 하나의 매개변수와 리턴타입이 void 인 람다식
		// User3 u = (int a) -> { a+=10; System.out.println(a); };
		// User3 u = (a) -> { a+=10; System.out.println(a); };
		// User3 u = a -> { a+=10; System.out.println(a); };
		User3 u = a -> System.out.println(a+10);
		u.disp(10);
	}
}

interface User3 {
	public void disp(int a);
}

package ch17.lambdaEx;

public class Ex04 {

	public static void main(String[] args) {
		// 두개의 매개변수, 리턴 타입 존재
		// User4 u = (a, b) -> { int c = a+b; return c; };
		// User4 u = (a, b) -> { return a+b;};
		User4 u = (a, b) -> a+b;
		
		int s = u.add(10, 5);
		System.out.println(s);
	}
}

@FunctionalInterface
interface User4 {
	public int add(int a, int b);
}

package ch17.lambdaEx;

public class Ex05 {
	public static void main(String[] args) {
		Test5 t = new Test5();
		t.using();
	}
}

interface User5 {
	public void disp();
}

class Test5 {
	int x = 10;
	
	class Demo {
		int y = 20;
		
		public void sub() {
			int a = 100;
			int b = 50;
			
			User5 u = () -> {
				System.out.println(this); 
					// 람다에서의 this는 익명 객체가 아니라 람다식을 구현한 클래스
					// Test5$Demo@34ce8af7
				
				System.out.println(a);
				// System.out.println(y);
				System.out.println(this.y);
			};
			
			u.disp();
			
			// a = 200; // 에러. 람다식에서 사용된 로컬변수는 final 속성
			b = 100;
			System.out.println(a);
			System.out.println(b);
			
		}
	}
	
	public void using() {
		Demo obj = new Demo();
		obj.sub();
	}
}

package ch17.lambdaEx2;

public class Ex01 {

	public static void main(String[] args) {
		String s;
		
		// s = String.valueOf(100);
		
		// 람다식
		Conversion c = n -> String.valueOf(100);
		s = c.convert(100);
		System.out.println(s);
		
		// 메소드 참조
		//  : 메소드를 참조하여 매개변수의 정보 및 리턴타입을 알아내여
		//    람다식에서 불필요한 매개변수를 제거하는데 목적이 있음
		Conversion c2 = String::valueOf;
		s = c2.convert(200);
		System.out.println(s);
		

	}

}

interface Conversion {
	public String convert(Integer n);
}

package ch17.lambdaEx2;

import java.util.function.Supplier;

public class Ex02 {

	public static void main(String[] args) {
		// Supplier : 매개변수 없고, 리턴 값 존재
		
		// 람다식
		Supplier<Object> o1 = () -> new Object();
		Object ob1 = o1.get();
		System.out.println(ob1);
		
		// 생성자 메소드 참조
		Supplier<Object> o2 = Object::new;
		Object ob2 = o2.get();
		System.out.println(ob2);

	}

}

package ch17.lambdaEx2;

import java.util.function.BiFunction;

public class Ex03 {

	public static void main(String[] args) {
		// BiFunction : 두개의 매개변수(T, R), 리턴값(R)
		BiFunction<String, String, Boolean> f1 = 
				(s1, s2) -> s1.equals(s2);
		Boolean b = f1.apply("java", "java");
		System.out.println(b);
		
		// 인스턴스 메소드 참조
		BiFunction<String, String, Boolean> f2 =
				String::equals;
		Boolean b2 = f2.apply("java", "java");
		System.out.println(b2);
	}

}

Optional

package ch17.optionalEx;

import java.util.Optional;

/*
   - Optional<T>
      : T 타입의 객체를 포장해주는 래퍼 클래스
   	  : 복잡한 조건문 없이도 널(null) 값으로 인해 발생하는 예외 처리를 할 수 있다.
   	  
   - Optional 객체 생성 방법
     Optional.empty() : 빈 Optional 객체
     Optional.of(value) : value 값이 null이 아닌 경우.
                          null 이면 NullPointerException 발생
     Optional.ofNullable(value) : value 값이 null인지 아닌지 확실하지 않는 경우
     
   - 메소드
     get() : Optional에 저장된 값 반환. null 이면 런타임  
     orElse(other) : null이 아니면 그 값을 반환하고 
                     null이면 other 반환
     ifPresent(인자) : Optional 객체가 null이면 false 로 아무것도 반환하지 않음
			         null 이 아니면 인자를 실행
     orElseGet(인자) : 저장된 값이 null이 아니면 그 값을 반환하고
                      null 이면 인자로 전달된 값을 반환
     map(mapper) : mapper 함수를 통해 입력 값을 다른 값으로 변환
     orElseThrow(예외클래스) : null 인경우 예외 던짐                                         
*/

public class Ex01 {

	public static void main(String[] args) {
		// 빈 Optional 객체
		Optional<String> op = Optional.empty();
		System.out.println(op.orElse("빈객체"));
		// orElse(other) : null이 아니면 그 값을 반환하고 null이면 other 반환
		
		Optional<String> op2 = Optional.of("123");
			// of(value) : value 가 null 이 아닌 경우 사용
		String s = op2.get(); // Optional 객체에 저장된 값 반환
		System.out.println(s);
		
		int n = op2.filter(x->x.length()>0)
					.map(Integer::parseInt)
					.get();
		System.out.println(n);
		
		String str = null;
		Optional<String> op3 = Optional.ofNullable(str);
							// empty Optional 객체
		// System.out.println(op3.get()); //  런타임
		System.out.println(op3.orElse("빈객체"));
		
		str = "abc";
		Optional<String> op4 = Optional.ofNullable(str);
		// System.out.println(op4.get()); // abc
		// System.out.println(op4.orElse("빈객체")); // abc
		op4.ifPresent(x->System.out.println(x.charAt(0))); // a
			// ifPresent() 
			//   : Optional 객체가 null이면 false. 아무것도 반환하지 않음
			//	 : null 이 아니면 인자를 실행
		
		str = null;
		// System.out.println(str.charAt(0)); // 런타임
		Optional<String> op5 = Optional.ofNullable(str);
		op5.ifPresent(a->System.out.println(a.charAt(0)));
				// 아무것도 출력 되지 않는다. println()이 실행되지 않는다.
		
		User u = new User();
		System.out.println(u.get(null)); // default
		System.out.println(u.get("자바")); // 자바

	}
}

class User {
	public String get(String s) {
		Optional<String> op = Optional.ofNullable(s);
		String str = op.orElseGet(this::defaultValue);
			// orElseGet(a)
		    //   : null 이 아니면 그 값을 반환하고
			//   : null 이면 인수로 전달된 값(a) 반환      
		return str;
	}
	
	public String defaultValue() {
		return "default";
	}
	
}

package ch17.optionalEx;

import java.util.NoSuchElementException;
import java.util.Optional;

public class Ex02 {

	public static void main(String[] args) {
		// 문자열을 정수로
		Integer n = Optional.of("123")
				.map(Integer::valueOf)
				.orElseThrow(NoSuchElementException::new);
		System.out.println(n);

		n = Optional.of("123")
				.map(Integer::valueOf)
				.get();
		System.out.println(n);
		
	}

}

package ch17.optionalEx;

import java.util.Optional;

public class Ex03 {
	public static void main(String[] args) {
		String s = getCity2(null);
		System.out.println(s);
	}
	
	public static String getCity(Order order) {
		if(order != null) {
			Member member = order.getMember();
			
			if(member != null) {
				Address address = member.getAddress();
				if(address != null) {
					String city = address.getCity();
					if(city != null) {
						return city;
					}
				}
			}
		}
		
		return "도시 없음";
	}
	
	public static String getCity2(Order order) {
		return Optional.ofNullable(order)
				.map(Order::getMember)
				.map(Member::getAddress)
				.map(Address::getCity)
				.orElse("도시 없음");
	}

}

class Address {
	private String city;
	private String street;
	
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
}

class Member {
	private String id;
	private String name;
	private Address address;
	
	public String getId() {
		return id;
	}
	public void setId(String id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
}

class Order {
	private long num;
	private String product;
	private Member member;
	
	public long getNum() {
		return num;
	}
	public void setNum(long num) {
		this.num = num;
	}
	public String getProduct() {
		return product;
	}
	public void setProduct(String product) {
		this.product = product;
	}
	public Member getMember() {
		return member;
	}
	public void setMember(Member member) {
		this.member = member;
	}
	
}

스트림 특징

스트림은 데이터 소스로 부터 데이터를 읽기만 할 뿐 변경하지 않는다. 스트림은 한번만 사용할 수 있다. 반복자와 마찬가지로 한번 탐색할 요소를 다시 탐색하려면 데이터소스에서 새로운 스트림을 만들어야 한다.

package ch17.streamEx;

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

public class Ex01 {

	public static void main(String[] args) {
		List<String> list = Arrays.asList("A", "B", "C");
		
		// 컬렉션 사용 예
		Iterator<String> it = list.iterator();
		while(it.hasNext()) {
			String s = it.next();
			System.out.println(s);
		}
		System.out.println();
		
		// 스트림 사용 예
		Stream<String> stream = list.stream();
		// stream.forEach(s -> System.out.println(s)); // 람다식
		stream.forEach(System.out::println); // 메소드 참조
		
		
		

	}

}

package ch17.streamEx;

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

public class Ex02 {

	public static void main(String[] args) {
		List<String> list = Arrays.asList("X", "A", "B", "A", "X", "C", "Y");
		
		// 중복 제거
		
		// 기존 방식
		for(int i=0; i<list.size(); i++) {
			if(list.indexOf(list.get(i)) == i) {
				System.out.println(list.get(i));
			}
		}
		System.out.println();
	
		// 스트림
		Stream<String> stream = list.stream();
		stream.distinct()
			.forEach(System.out::println);
		System.out.println();
		
		// 최종연산은 스트림의 요소를 모두 소모하므로 한번만 연산이 가능
		// stream.forEach(System.out::println); // 런타임오류
		
		Stream<String> stream2 = list.stream();
		stream2.distinct() // 중복제거(중간연산)
			.limit(3) //  중간연산
			.sorted() // 중산연산
			.forEach(System.out::println);
		
	}

}

package ch17.streamEx;

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

public class Ex03 {

	public static void main(String[] args) {
		// 스트림 생성 방법
		
		// 컬렉션에서 생성
		List<String> list = Arrays.asList("A", "B", "C");
		Stream<String> stream = list.stream();
		stream.forEach(System.out::print);
		System.out.println("\n");
		
		// 배열에서 생성
		String[] ss = new String[] {"A", "B", "C"};
		// Stream<String> stream2 = Stream.of(ss); // 스트림의 클래스 메소드
		Stream<String> stream2 = Arrays.stream(ss); 
		stream2.forEach(System.out::print);
		System.out.println("\n");
		
		// 특정 범위에서 스트림 생성
		IntStream stream3 = IntStream.range(1, 6); // end 범위 미포함
		stream3.forEach(System.out::print);
		System.out.println("\n");
		
		IntStream stream4 = IntStream.rangeClosed(1, 5); // end 범위 포함
		stream4.forEach(System.out::print);
		System.out.println("\n");
		
		
		// 난수에서 스트림 생성
		IntStream stream5 = new Random().ints(); // 무한 스트림
		stream5.limit(5).forEach(System.out::println);
		System.out.println("\n");
		
		IntStream stream6 = new Random().ints(5); // 5개의 난수
		stream6.forEach(System.out::println);
		System.out.println("\n");

		IntStream stream7 = new Random().ints(5, 1, 11); // 1~10사이의 5개의 난수
		stream7.forEach(System.out::println);
		System.out.println("\n");
	}

}

package ch17.streamEx;

import java.util.stream.Stream;

public class Ex04 {

	public static void main(String[] args) {
		// 스트림 생성 방법
		// 람다식
		Stream<Integer> s = Stream.iterate(0, n -> n + 2);
							// 무한 스트림. 0부터 짝수
							// iterate(seed, f) : seed 부터 f에 의해 계산된 결과를 다시 seed로 해서 계산을 반복
		s.limit(5).forEach(System.out::println);
		System.out.println();
		
		// generate(s) : 람다식에 의해 계산된 요소로하는 무한 스트림 생성. 이전 결과를 계산에 사용하지 않음
		Stream<Double> s2 = Stream.generate(Math::random);
		s2.limit(5).forEach(System.out::println);
		System.out.println();
		
		
		
		

	}

}

package ch17.streamEx;

import java.util.stream.IntStream;

public class Ex05 {

	public static void main(String[] args) {
		// 스트림 중간 연산
		
		IntStream s1 = IntStream.range(0, 10);
		s1.skip(4).forEach(n->System.out.print(n+" "));
		// skip(n) : n개 제외
		System.out.println("\n");
		
		IntStream s2 = IntStream.range(0, 10);
		s2.limit(4).forEach(n->System.out.print(n+" "));
		// limit(n) : 처음부터 n개 만큼으로 제한
		System.out.println("\n");
		
		IntStream s3 = IntStream.range(0, 10);
		s3.skip(3).limit(4).forEach(n->System.out.print(n+" "));
		System.out.println("\n");
		
		// 홀수만
		IntStream s4 = IntStream.range(0, 10);
		s4.filter(n->n%2!=0).forEach(n->System.out.print(n+" "));
		// filter(조건) : 조건에 만족하는 요소로 구성된 필터
		System.out.println("\n");
		
		// peek() : 스트림의 요소를 소모하지 않으므로 여러번 사용 가능
		IntStream s5 = 
				IntStream.of(7,5,5,2,1,2,3,5,4,6);
		s5.peek(s -> System.out.println("원본:"+s))		
			.skip(2)
			.peek(s -> System.out.println("skip(2):"+s))
			.limit(5)
			.peek(s -> System.out.println("limit(5):"+s))
			.sorted()
			.forEach(System.out::println);
	}
}

'💻 > JAVA' 카테고리의 다른 글

(38) [JAVA] 22일 (0)	2024.04.10
(36-37) [JAVA] 20-21일 (0)	2024.04.10
(35) [JAVA] 19일 (1)	2024.04.10
(34) [JAVA] 18일 입출력 스트림(I/O Stream) - 2 (0)	2024.04.03
(33) [JAVA] 18일 입출력 스트림(I/O Stream) (0)	2024.04.03

Power Up!

(39) [JAVA] 23일

Optional

스트림 특징

'💻 > JAVA' 카테고리의 다른 글

티스토리툴바

(39) [JAVA] 23일

Optional

스트림 특징

'💻 > JAVA' 카테고리의 다른 글

관련글

티스토리툴바