개발 다이어리

사용할 데이터

package javabasic.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class FuncEx01 {
	static class User{
		final Long id;
		final String name;
		final Integer age;
		
		public User(Long id, String name, Integer age) {
			this.id = id;
			this.name = name;
			this.age = age;
		}
	}
	
	static List<User> getUsers(){
		return Arrays.asList( 
				new User(10L, "ID", 36),
				new User(20L, "BJ", 32),
				new User(30L, "JM", 32),
				new User(40L, "PJ", 27),
				new User(50L, "HA", 25),
				new User(60L, "JE", 26),
				new User(70L, "JI", 31),
				new User(80L, "MP", 23)
				);
	}
	
	
	public static void main(String[] args) {
	}
}

	public static void main(String[] args) {
		List<User> users = getUsers();
		
		System.out.println(
				filter(users,user->user.age>30)+"\n"
				+users
				);
		
		
	}
    static <T> List<T> filter(List<T> list, Predicate<T> predi) {
		//함수형 프로그래밍은 원본 데이터를 수정하지 않는다. 새로운 데이터를 리턴하여
		//부수효과를 극단적으로 배제한다.
		ArrayList<T> newList = new ArrayList<>();
		for(T data : list) {
			//자바는 근본적으로 함수단독으로 존재할 수 없다.
			//따라서 추상 메서드가 단 하나인 인터페이스를 사용해 메서드 형식으로 호출할 수 밖에 없다.
			if(predi.test(data))
				newList.add(data);
		}
		return newList;
	}

filter = [[id=10, name=ID, age=36]
, [id=20, name=BJ, age=32]
, [id=30, name=JM, age=32]
, [id=70, name=JI, age=31]
]
[[id=10, name=ID, age=36]
, [id=20, name=BJ, age=32]
, [id=30, name=JM, age=32]
, [id=40, name=PJ, age=27]
, [id=50, name=HA, age=25]
, [id=60, name=JE, age=26]
, [id=70, name=JI, age=31]
, [id=80, name=MP, age=23]
]

원본에 영향을 가지 않도록 처리했다.

Map

	/*
	 * map은 처리 결과가 입력 결과와 타입은 같거나 다르다.
	 * 길이는 항상 같다.
	 */
	static <T,R> List<R> map(List<T> list, Function<T, R> mapper){
		ArrayList<R> newList = new ArrayList<>();
		for(T data : list) 
			newList.add(mapper.apply(data));
		return newList;
	}

		System.out.println("map = "+
				map(users, user->user.id)
				);

map = [10, 20, 30, 40, 50, 60, 70, 80]

each 만든 후 filter, map에 적용

전체 코드

package javabasic.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;

public class FuncEx01 {
	static class User{
		final Long id;
		final String name;
		final Integer age;
		
		public User(Long id, String name, Integer age) {
			this.id = id;
			this.name = name;
			this.age = age;
		}

		@Override
		public String toString() {
			return "[id=" + id + ", name=" + name + ", age=" + age + "]\n";
		}
		
	}
	
	static List<User> getUsers(){
		return Arrays.asList( 
				new User(10L, "ID", 36),
				new User(20L, "BJ", 32),
				new User(30L, "JM", 32),
				new User(40L, "PJ", 27),
				new User(50L, "HA", 25),
				new User(60L, "JE", 26),
				new User(70L, "JI", 31),
				new User(80L, "MP", 23)
				);
	}
	
	
	public static void main(String[] args) {
		List<User> users = getUsers();
		
		System.out.println("filter = "+
				filter(users,user->user.age>30)+"\n"
				+users
				);
		
		System.out.println("map = "+
				map(users, user->user.id)
				);
		
		each(Arrays.asList(1,2,3,4,5),System.out::print);
		System.out.println();
		
	}
	/*
	 * filter는 처리 결과가 입력 결과와 타입은 같다.
	 * 길이는 같거나, 작을 수 밖에 없다.
	 */
	static <T> List<T> filter(List<T> list, Predicate<T> predi) {
		//함수형 프로그래밍은 원본 데이터를 수정하지 않는다. 새로운 데이터를 리턴하여
		//부수효과를 극단적으로 배제한다.
		ArrayList<T> newList = new ArrayList<>();
		each(list,data->{
			if(predi.test(data))
				newList.add(data);
		});
		
		return newList;
	}
	/*
	 * map은 처리 결과가 입력 결과와 타입은 같거나 다르다.
	 * 길이는 항상 같다.
	 */
	static <T,R> List<R> map(List<T> list, Function<T, R> mapper){
		ArrayList<R> newList = new ArrayList<>();
		each(list, data->{
			newList.add(mapper.apply(data));
		});
		return newList;
	}
	/*
	 * 반복문을 중복을 대체할 함수
	 */
	static <T> List<T> each(List<T> list, Consumer<T> iter){
		for(T data : list) 
			iter.accept(data);
		return list;
	}
	
}