Lambda
01 annonymous_inner_type
[GasStation]
package ex01_annonymous_inner_type;
public class GasStation {
private int totalOil;
private int payPerLiter;
private int earning;
public GasStation() {
}
public void sellOil(String model,int oil) {
//Car 인터페이스를 구현한 별도 클래스를 만들고, 해당 클래스 객체를 만들고, add Oil()호출
//Car's addOil()
//Car car 지역변수(객체) 선언 (sellOil 메소드 호출 시 생성되고, sellOil 메소드 종료시 소멸된다.)
Car car;
// Car car 지역변수(객체) 생성
// 람다식으로 Car 인터페이스 타입의 객체 생성
car=()->{
totalOil -=oil;
earning += oil *payPerLiter;
System.out.println(model+" "+oil+"L 주유완료");
};
//Car car 지역변수 (객체) 의 addOil() 메소드 호출
car.addOil();
}
public int getTotalOil() {
return totalOil;
}
public void setTotalOil(int totalOil) {
this.totalOil = totalOil;
}
public int getPayPerLiter() {
return payPerLiter;
}
public void setPayPerLiter(int payPerLiter) {
this.payPerLiter = payPerLiter;
}
public int getEarning() {
return earning;
}
public void setEarning(int earning) {
this.earning = earning;
}
}
[Car]
package ex01_annonymous_inner_type;
public interface Car {
void addOil(); //public abstract void addOil();
}
[MainWrapper]
package ex01_annonymous_inner_type;
public class MainWrapper {
public static void main(String[] args) {
//주유소
GasStation station =new GasStation();
station.setTotalOil(1000); //1000L
station.setPayPerLiter(2000); // 1L당 2000원
//기름팔기
station.sellOil("모닝",50); // 모닝 50L 주유 완료
station.sellOil("레이",50); // 레이 50L 주유 완료
//주유소 상태
System.out.println("남은Oil:"+station.getTotalOil());//900L
System.out.println("번돈:"+station.getEarning()); //200000원
}
}
02 lambda
[MainWrapper]
package ex02_lambda;
public class MainWrapper {
public static void main(String[] args) {
//주유소
GasStation station =new GasStation();
station.setTotalOil(1000); //1000L
station.setPayPerLiter(2000); // 1L당 2000원
//기름팔기
station.sellOil("모닝",50); // 모닝 50L 주유 완료
station.sellOil("레이",50); // 레이 50L 주유 완료
//주유소 상태
System.out.println("남은Oil:"+station.getTotalOil());//900L
System.out.println("번돈:"+station.getEarning()); //200000원
}
}
[GasStation]
package ex02_lambda;
/*
* 람다 표현식
* 1. Annonymous Inner Type 방식의 객체를 생성할 때 사용할 수 있는 새로운 표현식이다.
* 2. 추상 메소드가 하나인 인터페이스에서 람다 표현식을 사용할 수 있다.
* (함수형 인터페이스 : 추상메소드가 하나인 인터페이스)
* 3. 형식
* (매개변수) -> {
* 본문;
* }
*
*/
/*
* 람다 표현식 적용 예시
* 1. 파라미터 x ,반환 x
* () ->{
* System.out.println("Hello World");
* };
* () ->System.out.println("Hello Wrold"); //메소드 본문이 줄이면 중괄호 {} 생략 가능
* 2. 파라미터 0 , 반환 x (파라미터의 타입은 생략한다.)
*
* (name) -> {
* System.out.println("Hello"+name);
* }
*
* (name) -> System.ouot.println("Hello"+name);
*
* 3. 파라미터 x, 반환 O (반환 타입은 생략한다.)
* ()->{
* String name ="tom";
* return name;
* }
*
* () ->"tom"; //메소드에 return만 존재하면 return 을 생략한다.
*
* 4.파라미터 0 ,반환 0
*
* //이름을 전달하면 "님"을 붙여서 출력하고 해당 값을 반환하는 함수를
*
* //정수 값을 전달하면 해당 값보다 1 이 큰 수를 반환하는 함수
*
*
*
* //이름을 전달하면 "님"을 붙여서 출력하고 해당 값을 반환하는 함수를
(name)->{
String retVal=name +"님";
System.out.println(retVal);
return retVal;
};
//정수 값을 전달하면 해당 값보다 1 이 큰 수를 반환하는 함수
(n)->n+1;
*/
public class GasStation {
private String name;
private int totalOil;
private int payPerLiter;
private int earning;
public GasStation() {
}
public void sellOil(String model,int oil) {
//Car 인터페이스를 구현한 별도 클래스를 만들고, 해당 클래스 객체를 만들고, add Oil()호출
//Car's addOil()
//Car car 지역변수(객체) 선언 (sellOil 메소드 호출 시 생성되고, sellOil 메소드 종료시 소멸된다.)
Car car;
// Car car 지역변수(객체) 생성
car = new Car() {
@Override
public void addOil() {
totalOil -=oil;
earning += oil *payPerLiter;
System.out.println(model+" "+oil+"L 주유완료");
}
};
//Car car 지역변수 (객체) 의 addOil() 메소드 호출
car.addOil();
}
public int getTotalOil() {
return totalOil;
}
public void setTotalOil(int totalOil) {
this.totalOil = totalOil;
}
public int getPayPerLiter() {
return payPerLiter;
}
public void setPayPerLiter(int payPerLiter) {
this.payPerLiter = payPerLiter;
}
public int getEarning() {
return earning;
}
public void setEarning(int earning) {
this.earning = earning;
}
}
[Car]
package ex02_lambda;
public interface Car {
void addOil(); //public abstract void addOil();
}
03 functional_interface
[MainWrapper]
package ex03_functional_interface;
public class MainWrapper {
public static void ex01() {
// Anonymous inner Type 생성
/*
MyInterface1 interface1 = new MyInterface1() {
@Override
public void method1() {
System.out.println("Hello World");
}
};
*/
// 람다 표현식으로 생성
MyInterface1 interface1 = () -> System.out.println("Hello World");
// method1() 호출
interface1.method1();
}
public static void ex02() {
// Anonymous inner Type 생성
/*
MyInterface2 interface2 = new MyInterface2() {
@Override
public void method2(String name) {
System.out.println(name + "님");
}
};
*/
// 람다 표현식으로 생성
MyInterface2 interface2 = (name) -> System.out.println(name + "님");
// method2() 호출
interface2.method2("홍길동");
}
public static void ex03() {
// Anonymous inner Type 생성
/*
MyInterface3 interface3 = new MyInterface3() {
@Override
public String method3() {
return "Hello World";
}
};
*/
// 람다 표현식 생성
MyInterface3 interface3 = () -> "Hello World";
// method3() 호출
String str = interface3.method3();
System.out.println(str);
}
public static void ex04() {
// Anonymous inner Type 생성
/*
MyInterface4 interface4 = new MyInterface4() {
@Override
public String method4(String name) {
return name + "님";
}
};
*/
// 람다 표현식 생성
MyInterface4 interface4 = (name) -> name + "님";
// method4() 호출
String str = interface4.method4("홍길동");
System.out.println(str);
}
public static void main(String[] args) {
// ex01();
// ex02();
// ex03();
ex04();
}
}[MyInterface1]
package ex03_functional_interface;
/*
* @FuntionalInterface
* 1. 함수형 인터페이스에 작성하는 Annotation이다.
* 2. 추상 메소드를 하나만 가진 인터페이스에 작성할 수 있다.
* 3. 람다 표현식으로 객체를 생성할 수 있는 인터페이스이다.
*
*/
@FunctionalInterface
public interface MyInterface1 {
void method1();
}
[MyInterface2]
package ex03_functional_interface;
@FunctionalInterface
public interface MyInterface2 {
void method2(String name);
}
[MyInterface3]
package ex03_functional_interface;
@FunctionalInterface
public interface MyInterface3 {
String method3();
}
[MyInterface4]
package ex03_functional_interface;
@FunctionalInterface
public interface MyInterface4 {
String method4(String name);
}
04 Supplier
[MainWrapper]
package ex04_Supplier;
import java.util.function.Supplier;
public class MainWrapper {
/*
* Supplier 인터페이스
* 1. 형식
* @FunctionalInterface
* public interface Supplier<T>{
* T get();
* }
*
* 2.파라미터가 없고 반환 값이 있는 get() 메소드를 가진 함수형 인터페이스이다.
* 3.항상 값을 제공하기 때문에 "제공자(Supplier)"라고 부른다.
*/
public static void ex01() {
//Supplier 람다 표현식 생성
Supplier<String>supplier = () -> "Hello World";
System.out.println(supplier.get());
}
public static void ex02(Supplier<String>supplier)
{
System.out.println(supplier.get());
}
public static void ex03(Supplier<Integer>supplier)
{
System.out.println("획득 포인트:"+supplier.get());
}
public static void main(String[] args) {
ex03(()->(int)(Math.random()*10));
}
}
05 Consumer
[MainWrapper]
package ex05_Consumer;
import java.util.Arrays;
import java.util.function.Consumer;
public class MainWrapper {
/*
* consumer 인터페이스
* 1. 형식
*
* @FunctionalInterface
* public interface Consumer<T>{
* void accept(T t); }
*
*
* 2.하나의 파라미터를 받아서 사용하고 반환하지 않는 함수형 인터페이스이다.
* 3. accept() 추상 메소드를 가지고 있다.
* 4. 값을 받아서 사용만 하기 때문에 "소비자(Consumer)" 라고 부른다.
*/
public static void ex01() {
Consumer<String> consumer=(t)->System.out.println(t+"님");
consumer.accept("홍길동");
}
public static void ex02(Consumer<String>consumer)
{
String str="east,west,south,north";
consumer.accept("str");
}
public static void main(String[] args) {
//ex01();
ex02((t)->{String[]array=t.split("[,]");
System.out.println(Arrays.toString(array)); //콤마로 분리해서 배열에 저장한 뒤 해당 출력하기
});
}
}
06 Function
[MainWrapper]
package ex06_Function;
import java.util.function.Function;
public class MainWrapper {
/*
*Function 인터페이스
*
* 1. 형식
*
* @FunctionInterface
* public interface Function<T,R>{
*
* R apply(T t);
* }
*
*
* 2. 파라미터를 받아서 특정 처리를 한 뒤 해당 값을 반환하는 함수형 인터페이스이다.
* 3. 파라미터 T를 받아서 R을 반환하는 apply() 메소드를 가지고 있다.
* 4.. 특정 처리를 한 뒤 처리된 값을 반환하기 때문에 "함수(Function)"라고 부른다.
*
*
*/
public static void ex01() {
Function<String , String>function=(name)->name+"님"; //name 을 전달하면 name+"님" 을 반환
String name=function.apply("홍길동");
System.out.println(name);
}
public static void ex02() {
//String 전달("100")하면 integer 반환하는 Function
Function<String , Integer>function=(str)->Integer.parseInt(str);
int n=function.apply("100");
System.out.println(n);
}
public static void main(String[] args) {
ex01();
ex02();
}
}
07 Predicate
[MainWrapper]
package ex07_Predicate;
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class MainWrapper {
/*
* Predicate 인터페이스
*
* 1. 형식
*
* @FunctionalInterface
* public interface Predicate<T> {
* boolean test(T t);
* }
*
* 2. 하나의 파라미터를 전달 받아서 true 또는 false를 반환하는 함수형 인터페이스이다.
* 3. 특정 값을 전달하면 해당 값을 검사한 뒤 true/false 여부를 반환하는 test() 메소드를 가지고 있다.
* 4. 어떤 값이 조건을 만족하는지 설명하기 때문에 "설명부(Predicate")이라고 부른다.
*/
public static void ex01() {
// 양수이면 true 아니면 false를 반환
Predicate<Integer> isPositive = (n) -> n >= 0;
if(isPositive.test(-1)) {
System.out.println("양수");
} else {
System.out.println("음수");
}
}
public static<T> void ex02(Predicate<T> predicate, List<T> list) {
// List<T>에 존재하는 홀수만 출력하기
for(int i = 0, length = list.size(); i < length; i++) {
T element = list.get(i);
if(predicate.test(element)) {
System.out.println(element);
}
}
}
public static double getAverage(Predicate<Person> predicate, List<Person> list) {
int total = 0;
int count = 0;
for(Person person : list) {
if(predicate.test(person)) {
total += person.getAge();
count++;
}
}
return (double)total / count;
}
public static void ex03() {
List<Person> list = Arrays.asList(
new Person("길동", 50),
new Person("영철", 30),
new Person("재동", 15),
new Person("미희", 16)
);
double youngAge = getAverage((p) -> p.getAge() < 20, list);
double oldAge = getAverage((p) -> p.getAge() >= 20, list);
System.out.println(youngAge);
System.out.println(oldAge);
}
public static void main(String[] args) {
// ex01();
// ex02((number) -> number % 2 == 1, Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
ex03();
}
}[Person]
package ex07_Predicate;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}08 method_reference
[Person]
package ex08_method_reference;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}[MainWrapper]
package ex08_method_reference;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
public class MainWrapper {
/*
* 메소드 참조(method reference)
* 1. 람다식이 오직 1개의 메소드만 호출하는 경우에 불필요한 매개변수 선언을 제거하고 사용할 수 있도록 도와주는 방식이다.
* 2. 문법상으로만 매개변수가 제거되는 것이지 실제로 제거되는 것은 아니다. (여전히 매개변수로 인수를 전달할 수 있다.)
* 3. 매개변수가 제거되기 때문에 람다식의 "() ->" 부분이 없어진다.
* 4. 형식
* 1) 클래스::메소드
* 2) 객체::메소드
*/
public static void ex01() {
// Consumer 람다식 (매개변수 number로 전달된 인수를 출력한다.)
Consumer<Integer> consumer1 = (number) -> System.out.println(number);
consumer1.accept(10);
// Consumer 메소드 참조 (문법상으로 매개변수가 제거된 상태이지만 매개변수로 인수가 여전히 전달된다.)
Consumer<Integer> consumer2 = System.out::println;
consumer2.accept(20);
}
public static void ex02() {
// Function 람다식 (매개변수 t를 Integer로 변환한 값을 반환한다.)
Function<String, Integer> function1 = (t) -> Integer.parseInt(t);
int n1 = function1.apply("100");
System.out.println(n1);
// Function 메소드 참조 (Integer.parse() 결과를 반환한다. -> 역시 어떤 값이 전달되는지는 문법상으로 제거된 상태이다.)
Function<String, Integer> function2 = Integer::parseInt;
int n2 = function2.apply("200");
System.out.println(n2);
}
public static void ex03() {
// List
List<Person> people = Arrays.asList(
new Person("정숙", 20),
new Person("재홍", 30),
new Person("정희", 40)
);
// Function 람다식 (매개변수 p의 getName() 메소드 결과를 반환한다.)
Function<Person, String> function3 = (p) -> p.getName();
for(Person p : people) {
System.out.println(function3.apply(p));
}
// Function 메소드 참조 (매개변수가 생략되어 있지만 매개변수는 Person 타입임을 알 수 있다. 매개변수로 전달된 Person의 getName() 메소드 결과를 반환한다.
Function<Person, String> function4 = Person::getName;
for(Person p : people) {
System.out.println(function4.apply(p));
}
}
public static void main(String[] args) {
ex01();
ex02();
ex03();
}
}Stream
01 Stream
[MainWrapper]
package ex01_Stream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
public class MainWrapper {
/*
* 스트림 생성 &for Each()
*/
public static void ex01()
{
/*
* forEach() 메소드
* 1. Stream 파이프라인의 마지막에 사용할 수 있는 메소드 중 하나이다.
* 2. Stream 파이프라인의 각 요소를 순회할 때 사용한다.
* 3. for문처럼 동작한다.
* 4. 형식
* void forEach(Consumer<T>consumer);
*
*/
//Stream 생성
Stream<String>stream=Stream.of("봄","여름","가을","겨울");
//Consumer생성(Anonnymous inner Type 생성)
Consumer<String>consumer=new Consumer<String>() {
@Override
public void accept(String t) {
System.out.println(t);
}
};
stream.forEach(consumer);
}
public static void ex02()
{
//Stream생성
Stream<String>stream=Stream.of("봄","여름","가을","겨울");
//Consumer 생성 (람다표현식)
Consumer<String>consumer=(t)->System.out.println(t);
//foreach메소드 호출
stream.forEach(consumer);
}
public static void ex03() {
//Stream 생성
Stream<String>stream=Stream.of("봄","여름","가을","겨울");
//forEach호출
stream.forEach((t)->System.out.println(t));
}
/*
* 각종 스트림 생성 방법
*/
public static void ex04() {
//1. Integer 전용 Stream
//IntStream isStream =IntStream.of(1,2,3,4,5); //1,2,3,4,5
// IntStream isStream =IntStream.range(1, 6); //1 이상 6 미만(1,2,3,4,5)
//IntStream isStream =IntStream.rangeClosed(1, 5); //1이상 5 이하(1,2,3,4,5)
IntStream isStream =IntStream.rangeClosed(1, 5);
isStream.forEach((number)->System.out.println(number));
//2.Long 전용 Stream(range,rangeClosed 가능)
LongStream lStream=LongStream.of(1,2,3,4,5);
lStream.forEach((number)->System.out.println(number));
//3. Double 전용 Stream (range,rangeClosed 불가능)
DoubleStream dStream=DoubleStream.of(1.1,2.2);
dStream.forEach((number)->System.out.println(number));
}
public static void ex05() {
//배열->Stream
//1. 일반 Stream
String[] season= {"봄","여름","가을","겨울"};
Stream<String>stream= Arrays.stream(season);
stream.forEach((t)->System.out.println(t));
//2. IntStream
int[]iNumber= {1,2,3,4,5};
IntStream iStream=Arrays.stream(iNumber);
iStream.forEach((number)->System.out.println(number));
//3.DoubleStream
double[]dNumber= {1.1,2.2};
DoubleStream dStream=Arrays.stream(dNumber);
dStream.forEach((number)->System.out.println(number));
Arrays.stream(dNumber).forEach(System.out::println);
}
public static void ex06()
{
//컬렉션 (Collection)->Stream
//List
List<String>list =Arrays.asList("봄","여름","가을","겨울");
Stream<String>stream=list.stream();
stream.forEach((t)->System.out.println(t));
//Set -> Stream
Set<String>set=new HashSet<String>(Arrays.asList("봄","여름","가을","겨울"));
set.stream().forEach((t)->System.out.println(t));
}
//다시
public static void ex07()
{
/* //파일(입출력 스트림) -> Stream
File file =new File("src/ex01_Stream/hello.txt");//동등한 위치에 있을 땐 파일의 이름만 적어도 됨.new File("hello.txt")도 무방하다.
try(BufferedReader reader=new BufferedReader(new FileReader(file))){
//Stream생성
Stream<String>stream = reader.lines(); //한줄씩 전부 읽어서 스트림파이프라인에 준비시켜라
//forEach호출
stream.forEach((line)->System.out.println(line));
//StringBuider로
StringBuilder sb = new StringBuilder();
stream.forEach((line)->sb.append(line+"\n"));
}
catch (IOException e) {
e.printStackTrace();
}*/
// 파일(입출력 스트림) -> Stream
File file = new File("src/ex01_Stream/hello.txt"); // new File("hello.txt")도 가능함(동일한 곳에 있기 때문에)
try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
// Stream 생성
Stream<String> stream = reader.lines();
// forEach() 호출
StringBuilder sb = new StringBuilder();
stream.forEach((line) -> sb.append(line + "\n"));
// 확인
System.out.println(sb.toString());
} catch (IOException e) {
e.printStackTrace();
}
}
public static void ex08()
{
try {
//Path 를 이용한 Stream처리
Path path =Paths.get("src/ex01_Stream/hello.txt");
Stream<String> stream =Files.lines(path);
stream.forEach((line)->System.out.println(line));
stream.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
public static void ex09()
{
//디렉터리에 저장된 파일 목록 -> Stream
File dir =new File("C:/Program Files");
File[] files =dir.listFiles();
Stream<File>stream =Arrays.stream(files);
stream.forEach((file)->System.out.println(file.getPath()));
}
public static void ex10()
{
//Path 를 이용한 Stream처리
try {
Path path =Paths.get("C:/Program Files");
Stream<Path>stream= Files.list(path);
stream.forEach((p)->System.out.println(p.getFileName())); //getName 비스무리 한거
stream.close();
}
catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
ex10();
}
}
[hello.txt]
Hello
world
02 terminal
[MainWrapper]
package ex02_terminal;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
public class MainWrapper {
public static void ex01() {
// 통계 계산
// IntStream iStream = IntStream.range(1, 6); // 1,2,3,4,5
System.out.println("합계: " + IntStream.range(1, 6).sum());
System.out.println("평균: " + IntStream.range(1, 6).average().getAsDouble());
System.out.println("개수: " + IntStream.range(1, 6).count());
System.out.println("최대: " + IntStream.range(1, 6).max().getAsInt());
System.out.println("최소: " + IntStream.range(1, 6).min().getAsInt());
}
public static void ex02() {
// Stream -> List
// Stream
Stream<String> stream = Stream.of("봄", "여름", "가을", "겨울");
// Stream -> List
List<String> list = stream.collect(Collectors.toList());
System.out.println(list);
}
public static void ex03() {
List<Person> people = Arrays.asList(
new Person("김철수", 20),
new Person("고영희", 30),
new Person("김상철", 5),
new Person("이미희", 7)
);
// allMatch() : 모든 요소를 검사해서 모두 만족하면 true 반환
boolean result1 = people.stream()
.allMatch((person) -> person.getAge() >= 20);
System.out.println("모두 20살 이상인가? " + result1);
// anyMatch() : 모든 요소를 검사해서 하나만 만족해도 true 반환
boolean result2 = people.stream()
.anyMatch((person) -> person.getAge() >= 20);
System.out.println("한 명이라도 20살 이상인가? " + result2);
// noneMatch() : 모든 요소를 검사해서 모두 만족하지 않으면 true 반환
boolean result3 = people.stream()
.noneMatch((person) -> person.getAge() >= 20);
System.out.println("모두 20살 이상이 아닌가? " + result3);
}
public static void ex04() {
// List
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
// T reduce(T identity, BinaryOperator<T> accumulator);
int total1 = numbers.stream()
.reduce(0, (a, b) -> a + b); // 스트림 요소가 없는 경우 0을 반환
System.out.println(total1);
// Optional<T> reduce(BinaryOperator<T> accumulator);
Optional<Integer> opt = numbers.stream()
.reduce((a, b) -> a + b);
int total2 = opt.get(); // Optinal로 감싼 값을 꺼내는 get() 메소드
System.out.println(total2);
// Optional<T> reduce(BinaryOperator<T> accumulator);
int total3 = numbers.stream()
.reduce(Integer::sum)
.get();// reduce의 결과가 Optional이므로 값을 빼기 위해 get() 메소드를 추가한다.
System.out.println(total3);
// Integer::sum은 Integer 클래스의 sum 메소드를 호출함을 의미한다.
// class Integer {
// public static int sum(int a, int b) {
// return a + b;
// }
// }
}
public static void main(String[] args) {
// ex01();
// ex02();
// ex03();
ex04();
}
}[Person]
package ex02_terminal;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}03 intermedia
[MainWrapper]
package ex03_intermedia;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import ex02_terminal.Person;
public class MainWrapper {
public static void ex01() {
// 필터 (원하는 요소만 사용)
// List
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
// 홀수만 출력하기
list.stream()
.filter((number) -> number % 2 == 1) // 조건
.forEach((n) -> System.out.println(n)); // 할일
}
public static void ex02() {
// 필터 (원하는 요소만 사용)
// List
List<Person> list = Arrays.asList(
new Person("홍자", 20),
new Person("영미", 10),
new Person("미희", 30),
new Person("숙자", 15)
);
// age가 20 이상인 Person을 List로 생성
List<Person> adult = list.stream()
.filter((person) -> person.getAge() >= 20)
.collect(Collectors.toList());
// adult 확인
adult.stream()
.forEach((person) -> System.out.println(person.getName() + ", " + person.getAge()));
}
public static void ex03() {
// 변환 (값을 바꿈)
// List
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
// 1씩 증가시키기
list.stream()
.map((number) -> number + 1)
.forEach((number) -> System.out.println(number));
}
public static void ex04() {
// 변환 (값을 바꿈)
// List
List<Person> list = Arrays.asList(
new Person("홍자", 20),
new Person("영미", 10),
new Person("미희", 30),
new Person("숙자", 15)
);
// 필터 + 변환
List<Person> adult = list.stream()
.filter((person) -> person.getAge() >= 20)
.map((person) -> new Person(person.getName() + "님", person.getAge() + 1))
.collect(Collectors.toList());
System.out.println(adult);
}
public static void ex05() {
// distinct (중복된 요소 제거)
IntStream.of(1, 1, 2, 2, 3, 3)
.distinct()
.forEach((number) -> System.out.println(number));
// Person 객체의 중복 검사를 위해서는 Person 클래스에 equals 메소드의 오버라이딩이 필요하다.
List<Person> people = Arrays.asList(
new Person("이정숙", 15),
new Person("이정숙", 15),
new Person("김영철", 16),
new Person("김영철", 16)
);
people.stream()
.distinct()
.forEach((person) -> System.out.println(person.getName() + ", " + person.getAge()));
}
public static void ex06() {
// sorted (전달된 Comparator 또는 사전 편찬 순으로 정렬된 스트림을 반환)
IntStream.of(3, 1, 6, 5, 2, 4)
.sorted() // 오름차순 정렬
.forEach((number) -> System.out.println(number));
System.out.println();
Stream.of("google", "daum", "naver")
.sorted() // 사전순으로 정렬
.forEach((word) -> System.out.println(word));
System.out.println();
Stream.of("google", "daum", "naver")
.sorted(Comparator.comparing((word) -> word.length())) // 글자수로 정렬
.forEach((word) -> System.out.println(word));
}
public static void main(String[] args) {
// ex01();
// ex02();
// ex03();
// ex04();
// ex05();
ex06();
}
}[Person]
package ex03_intermedia;
import java.util.Objects;
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(age, name);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
return age == other.age && Objects.equals(name, other.name);
}
}
졸려요
개발자로서 성장하는 데 큰 도움이 된 글이었습니다. 감사합니다.