String.joiner
구분자를 이용해서 입력된 데이터를 구분해서 String으로 반환



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Java8Test {
 
    public static void main(String args[]) {
        StringJoiner sj = new StringJoiner(",");
        sj.add("babo");
        sj.add("wedul");
        sj.add("pnp");
        System.out.println(sj.toString());
        
        // 2, 3번재 매개변수를 이용하여 prifix, suffix를 붙힐 수 있다.
        sj = new StringJoiner(",""자기소개 -- "" -- 끝");
        sj.add("babo");
        sj.add("wedul");
        sj.add("pnp");
        System.out.println(sj.toString());
    }
}
 
=> 결과
babo,wedul,pnp
자기소개 -- babo,wedul,pnp -- 끝
cs



String.join
- 구분자를 이용해서 입력된 데이터를 구분해서 String으로 변환

1
2
3
4
5
List<String> data = Arrays.asList("babo", "wedul");
System.out.println(String.join(",", data));
 
==> 결과 
babo,wedul
cs





Collection에서 조건이 부함되면 삭제하는 Removeif

1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]) {
    List<String> data = Arrays.asList("babo""wedul");
        
    Predicate<String> predicate = new Predicate<String>() {
        @Override
        public boolean test(String name) {
            return name.equals("wedul");
        }
    };
        
    data.removeIf(predicate);
    data.stream().forEach(System.out::println);
cs


List 포함된 부분중 모든 부분을 한번에 변경할  있는 기능을 제공하는 ReplaceAll


1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]) {
    List<String> data = Arrays.asList("babo""wedul");
        
    // UnaryOperator는 입력된 input의 값을 반화해주는 클래스 함수형 인터페이스
    UnaryOperator<String> unaryOpt = (String name) -> {return "bb wedul";};
        
    data.replaceAll(unaryOpt);
    data.forEach(System.out::println);
 
==> 결과값
bb wedul
bb wedul
cs



List안에 컨텐츠를 comparator 맞게 정렬 시켜주는 sort 메소드




Stream  체크   제거



1
2
3
4
5
6
7
8
9
10
11
12
13
14
public static void main(String args[]) {
    List<String> data = Arrays.asList("babo"null"wedul"null);
        
    // null이 있는 부분이 있는지 체크
    System.out.println("is Contain null? : " + data.stream().anyMatch(Objects::isNull));
 
    // 널 제거
    data.stream().filter(Objects::nonNull).forEach(System.out::println);
 
==> 결과
is Contain null? : true
babo
wedul
cs


지연실행
-> 람다를 이용하면 필요할때만 호출해서 사용할  있는 Lazy Programming 구현   있다.

기존에 다음과 같이 사용하면 
당장 사용하지 않아도 실행이 되는 문제가 있었다.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Heavy {
        Heavy() {
            System.out.println("Heavy created");
        }
    }
    
    Hodler 클래스
    Holder 클래스는 heavy 클래스를 포함하고 있다.
    public class Holder {
        public Holder() {
            System.out.println("Holder created");
        }
    
        Heavy heavy = new Heavy();
        public Heavy getHeavy() {
            return heavy;
        }
    }
    
    public static void main(String[] args) {
        Holder holder = new Holder();
        System.out.println("Get Heavy instance");
    }
cs



Holder 클래스를 선언   다음과 같은 순서로 실행된다.

==> 출력겨로가
Heavy created
Holder created
Get Heavy instance

Heavy 클래스를 가지고 있지만 당장 사용하지 않는데 Holder클래스가 생성될  먼저 생성되는 문제가 있다.
 
이런 문제를 람다식을 사용하여 필요할  호출하여 사용하는 Lazy 방식으로 변경   있다.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Lazy<T> {
        private Optional<T> instance = Optional.empty();
        private Supplier<T> supplier;
        
        public Lazy(Supplier<T> theSupplier) {
            supplier = theSupplier;
        }
        
        public T get() {
            if(!instance.isPresent()) {
                instance = Optional.of(supplier.get());
            } 
            
            return instance.get();
        }
    }
cs



먼저 하나의 Lazy방식에 사용할 클래스를 선언한다.
그리고 Holder 클래스를 다음과 같이 변경한다.



1
2
3
4
5
6
7
8
9
10
public class Holder {
        public Holder() {
            System.out.println("Holder created");
        }
    
        Lazy<Heavy> heavy = new Lazy<Heavy> (() -> new Heavy());
        public Heavy getHeavy() {
            return heavy.get();
        }
}
cs



다시한번 실행해 보면

Heavy 클래스가 미리 생성되지 않는것을 확인 할 수 있다.


1
2
3
4
public static void main(String[] args) {
        Holder holder = new Holder();
        System.out.println("Get Heavy instance");
}
cs


Java8 함수형 인터페이스 만들어서 사용하기

함수형 인터페이스 사용 
-> 정의한 함수형 인터페이스를 람다식을 이용하여 사용할 수 있다.




1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//     함수형 인터페이스 선언 
//  함수형 인터페이스를 만들고자 할 경우에는 @FunctionalInterface 애노테이션을 붙혀야 한다.
 
@FunctionalInterface
public interface WedulInterface {
    public void print(int x);
}
 
public static void main(String args[]) {
    WedulInterface wedul = new WedulInterface() {
        @Override
        public void print(int x) {
            System.out.println(x);
        }
    };
        
    List<Integer> a = Arrays.asList(1,23);
    a.stream().forEach(wedul::print);
}
cs





자바 8에서 java.util.function 패키지에 추가된 기본 함수형 인터페이스 정리

Function <T, R> 
=> T 입력으로 R 출력하여 반환



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Java8Test {
 
    public static void main(String args[]) {
        
        Function<String, Integer> mapStrToInt = new Function<String, Integer>() {
            public Integer apply(String str) {
                if (str == "wedul") {
                    return 1;
                }
                return 2;
            }
        };
        
        List<String> testData = Arrays.asList("wedul","dd","babo");
        testData.stream().map(mapStrToInt).forEach(System.out::println);
    }
}
cs




Predicate<T> 
-> T 입력으로 boolean 출력으로 반환


1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]) {
        
    Predicate<Integer> predictData = new Predicate<Integer> () {
        @Override
        public boolean test(Integer tes) {
            return tes > 10
        }
    };
        
    List<Integer> test = Arrays.asList(12,3,4,55);
        
    test.stream().filter(predictData).forEach(System.out::println);
}
cs



Consumer <T>  
-> T 입력으로 아무것도 반환하지 않는다
-> 단순하게 입력받은 데이터를 처리할때 사용된다.



1
2
3
4
5
6
7
8
9
10
11
12
13
public static void main(String args[]) {
        
    Consumer<Integer> consumerData  = new Consumer<Integer>() {
        @Override
        public void accept(Integer idnt) {
            System.out.println(idnt);
        }
    };
        
    List<Integer> test = Arrays.asList(12,3,4,55);
        
    test.stream().forEach(consumerData);
}
cs




Supplier<T> : 입력을 취하지 않고 T 반환
입력한 데이터를 가지고 있으며get 메소드를 사용하여 호출한 곳에서 입력된 데이터를 사용할  있게 반환  주는 기능 제공



1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String args[]) {
        
    Supplier<Integer> supplier = new Supplier<Integer>() {
        @Override 
        public Integer get() {
            return 1;
        }
    };
        
//        List<Integer> test = Arrays.asList(12,3,4,55);
    System.out.println(supplier.get());
}
cs


스트림에 있는  데이터를 List, String, Set 다양한 형태로 변경하여 추출   있다.

toArray
Stream.toArray Object[] 리턴한다.
 
올바른 타입의 배열을 원하는 경우 다음과 같이 배열 생성자를 전달한다.
String[] result = words.toArray(String[]::new);
 
Collect 메소드
- Collect : 종료 작업으로 인자로 받은 형태의 데이터 타입으로 결과물을 생성한다
- Collect 병렬화를 지원한다또한 공급자누산자결합자를 기본적인 파라미터로 받으며 이는 
  Collectors라는 클래스를 통해 간편하게 정의하여 사용할  있다.

1) List, set, String



1
2
3
4
5
6
7
Stream<String> data = Stream.of("dd", "aa", "cc");
        
// stream 데이터를 list로 변환
List<String> result = data.collect(Collectors.toList());
        
// stream 데이터를 set으로 추출
Set<String> setdata = data.collect(Collectors.toSet()); 
cs




스트림에 있는 모든 문자열들을 서로 연결해서 모으려고 하는 경우 다음과 같이 호출   있다.
 

문자 이어 붙히기


1
2
3
4
5
6
7
Stream<String> data = Stream.of("dd", "aa", "cc");
        
// 데이터 이어 붙히기
String temp = data.collect(Collectors.joining());
System.out.println(temp);
        
==> ddaacc 
cs




구분자 삽입하여 이어 붙히기

1
2
3
4
5
6
7
8
9
10
public static void main(String args[]) {
        
    Stream<String> data = Stream.of("dd""aa""cc");
        
    // 데이터 이어 붙히기
    String temp = data.collect(Collectors.joining("||"));
    System.out.println(temp);    
}
 
==> dd||aa||Cc
cs


그룹핑과 파티셔닝
그룹핑

 
Stream 들어있는 데이터 중에 성질이 같은 값들의 그룹을 만들어서 사용하고자  경우가 있을 것이다.
Stream collect 메소드의 구분자로 Collectors.groupingby 사용하며 기준은 Person dept 사용하여 그룹핑을 한다.




 다운스트림 컬렉터(downStream Collector)
 -> 그룹핑 결과를 List 반환하지 않고 특별히 기재한 방식으로 출력하도록 해주는 


1) set으로 출력




2) 분류된 데이터의 개수를 출력






파티셔닝
리턴되는 값이 boolean 분류 함수인 경우에는 groupingBy 대신 partitioningBy 사용하면 스트림 요소가 true, false 리턴하는 두개의 리스트로 구분된다.




+ Recent posts