제네릭스(Generics)

컴파일 시 타입체크 해주는 기능

	<T> == Type
	<E> == Element
	<K> == Key
	<V> == Value
	<N> == Number
 	<R> == Result

# Collection.java 중 일부
public interface Collection<E> extends Iterable<E> {
	int size();
	boolean isEmpty();
	Iterator<E> iterator();
	boolean add(E e);
	<T> T[] toArray(T[] a);
	boolean containsAll(Collection<?> c);
	boolean addAll(Collection<? extends E> c);
}

# List.java 중 일부
public interface List<E> extends Collection<E> {
  // Collection 에 있는 메소드들 모두 포함 
  // + List 에만 있는 메소드들
	boolean add(E e);
}

# 활용 예제(읽고 이해)
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Main {
    public static void main(String[] args) {

        List<String> list = new ArrayList();
        list.add("string");
        Collection<String> collection = list;

        List<Exception> exceptionList = new ArrayList<>();
        Collection<Exception> exceptionCollection= exceptionList;

        List<IllegalArgumentException> exceptions = new ArrayList<>();
        exceptionCollection.addAll(exceptions);
    }
}

람다

식별자없이 실행가능한 함수
이중 콜론 연산자 :: - 매개변수를 중복해서 사용하고 싶지 않을 때 사용

[기존의 메소드 형식]
  반환타입 메소드이름(매개변수 선언) {
      수행 코드 블록
  }

[람다식의 형식]
  (매개변수 선언) -> {
      수행 코드 블록
  }

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

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("korea");
        list.add("japan");
        list.add("france");
        Stream<String> stream = list.stream();
        stream.map(str -> str.toUpperCase())   // 실제 사용할 함수
        					 .forEach(it -> System.out.println(it));
                         //  .forEach(System.out::println); 
    }
}
KOREA			// stream 리스트의 스트링을 하나씩 꺼내서 수행해줘
JAPAN			// map 앞의 값을 어떤 값으로 바꿀게
FRANCE			// foreach 하나하나 실행해줘

스트림

컬렉션의 저장 요소를 하나씩 참조해서 람다식으로 처리할 수 있또록 해주는 반복자

• 필터링, 데이터 변경, 다른 타입이나 자료구조로 변환 가능
• 데이터 소스를 변경하지 않음
• 작업을 내부적으로 반복처리
• 컬렉션의 요소를 모두 읽고나면 닫혀서 재사용불가
• 스트림 생성 -> 중간연산(트랜스폼) -> 최종연산(결과물 만듦)
  중간연산 - map(변환), sorted(정렬), skip(스트림 자르기), limit(스트림 자르기)

# List -> Set
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

public class Main {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("서울");
        list.add("대구");
        list.add("부산");
        list.add("서울");

        System.out.println(list);

        List<String> result = list.stream()
                .limit(2)   // 앞의 2개만 출력
                .collect(Collectors.toList());  // 하나로 모음 다른리스트로 모아서
        System.out.println(result);

        System.out.println("list -> transformation -> set");
        Set<String> set = list.stream()
                .filter(it -> "서울".equals(it))  // '서울'과 같으면 
                .collect(Collectors.toSet());  // set으로 서울만 남음(set 중복x)
        System.out.println(set);

    }
}
[서울, 대구, 부산, 서울]
[서울, 대구]
list -> transformation -> set
[서울]

# Array -> Stream
import java.util.Arrays;
import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        String[] arr = {"SQL", "Java", "Python"};
        Stream<String> stringstream = Arrays.stream(arr);
        stringstream.forEach(System.out::println);
    }
}
SQL   // stream이라 하나씩
Java
Python

• Map 예제

build.gradle의 dependecies에 library 추가 
dependencies {
	implementation 'org.apache.commons:commons-lang3:3.0'
}
library : 다른 곳에서 구현된 코드

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

import org.apache.commons.lang3.tuple.Pair;

class Sale {
    String fruitName;
    int price;
    float discount;

    public Sale(String fruitName, int price, float discount) {
        this.fruitName = fruitName;
        this.price = price;
        this.discount = discount;
    }
}

public class Main {
    public static void main(String[] args) {
        List<Sale> saleList = Arrays.asList(
                new Sale("Apple", 5000, 0.05f),
                new Sale("Grape", 3000, 0.1f),
                new Sale("Orange", 4000, 0.2f),
                new Sale("Tangerine", 2000, 0)
        );

        Stream<Sale> saleStream = saleList.stream();
        saleStream.map(sale -> Pair.of(sale.fruitName, sale.price * (1 - sale.discount)))
                  .forEach(pair -> System.out.println(pair.getLeft() + " 실 구매가:  " + pair.getRight() + "원 "));
    }			  //       4pair로 나와서 왼쪽값, 오른쪽값으로 나누어 출력
}

• reduce

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

public class Main {
    public static void main(String[] args) {
       List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        System.out.println(list.stream().reduce(0, Integer::sum));
     // 1.								.reduce(0, (a, b) -> Integer.sum(a, b)));
     // 2. 스트림 사용x
     // Integer acc = 0;
     // for (Integer integer : list) {
     //     acc = acc + integer;
     // }
     // System.out.println(acc);
    }
}  
// list에서 stream을 만들고 0번째부터 시작해서 하나씩 꺼내면서 sum 실행 
// 1 + 2 + ... + 10
// 55

예제

이씨 성을 가진 사람 수 세기, startsWith, count 함수 사용
Javadoc

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

public class Main {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("김정우", "김호정", "이하늘", "이정희", "박정우");
        System.out.println("이씨 성 수 : " + names.stream()
                                           		.filter(name -> name.startsWith("이"))
                                                .count());
    }
}
이씨 성 수 : 2

네트워킹

강의다시보기