I/O란?

Input Output라는 뜻

또

Innovation in the Open

혁신은 개방속에 있다라는 뜻


Android, Web, ML, IOT 등 다양한 분야의 주제들을 다뤘다.


io-extended-seoul-17

https://io-extended-seoul-17.firebaseapp.com/


gdg korea facebook

컨퍼런스가 꾸준하게 열리고 있으니 관심있으신 분은 자주 들어가서 확인하시면 좋겠습니다

https://www.facebook.com/search/top/?q=gdg%20korea


gdg korea android

https://www.facebook.com/GDG.Korea.Android/


역시나 내용에 대해서는 다음포스팅에..






사진


처음에는 다같이 컨퍼런스 Keynote를 듣고 

홀을 세개로 나누어 각각들을 수 있게 만들었다.


역시나 스티커









'창고' 카테고리의 다른 글

2019 드로이드 나이츠  (0) 2019.04.26
드로이드나이츠(Droid Knights) 2018  (0) 2018.06.10
드로이드나이츠(Droid Knights) 내용  (0) 2017.11.09
드로이드나이츠(Droid Knights)  (0) 2017.11.09
Stream  (0) 2017.10.03


전 포스팅에서 드로이드나이츠에 대해 아주 간단한 설명과 사진만 게시했습니다.

내용에 관한 글이지만 제가 설명할 수 있을만한게 거의 없네요..

그래서 드로이드 나이츠 스폰서였던 Realm 홈페이지에 컨퍼런스 동영상과 내용이 올라와 있는데

그 url과 아주 대략적으로만 설명해보겠습니다



SESSION






Compose everything with rx & kotlin

https://academy.realm.io/kr/posts/compose-everything-rx-kotlin/

https://speakerdeck.com/importre/compose-everything-with-rx-and-kotlin






Some OK Practices in Android Development

https://academy.realm.io/kr/posts/clean-architecture-in-android/






안드로이드 스튜디오 플러그인 만들어보기

https://academy.realm.io/kr/posts/android-studio-plugin-development/






Firebase를 실제 모바일 백엔드에서 사용했을 때 생기는 일들

https://news.realm.io/kr/news/firebase-as-a-real-mobile-backend






Firebase Remote Config로 배포없이 앱 운영하기

https://news.realm.io/kr/news/firebase-remote-config






빠르고 지속적으로 전달하기: Continuous Delivery for Android

https://news.realm.io/kr/news/continuous-delivery-for-android






UiAutomator와 AWS Device Farm을 활용한 UI 테스팅 자동화

https://academy.realm.io/kr/posts/android-ui-test-automation/






Anatomy of Realm(Realm 심층 분석)

https://academy.realm.io/kr/posts/anatomy-of-realm/






KeyFrame과 Lottie로 인터렉티브한 애니메이션을 구현하기

https://realm.io/kr/news/lottie-for-android-interactive-animation/


'창고' 카테고리의 다른 글

드로이드나이츠(Droid Knights) 2018  (0) 2018.06.10
Googl I/O 2017 Extended in Seoul  (0) 2017.11.10
드로이드나이츠(Droid Knights)  (0) 2017.11.09
Stream  (0) 2017.10.03
람다 표현식  (0) 2017.10.03




미국에는 드로이드콘, 일본에는 드로이드 카이기가 존재하지만

한국에는 안드로이드 독립컨퍼런스가 없었고 그래서 탄생한

드로이드 나이츠다!


2017년 3월 25일에 했다.

내년에도 할 것으로 기대


드로이드나이츠 

https://droidknights.github.io/2017/#/

https://www.facebook.com/droidknights/


컨퍼런스 내용에 대해서는 다음 포스팅에서 다루겠습니다..

http://jhpop.tistory.com/43



컨퍼런스 분위기















굿즈


티셔츠가 이뻐서 지금도 아껴입고 있습니다.


컨퍼런스마다 스티커를 나눠주는거 같아요.

그치만 잘 알지도 못하면서 붙이기가 그래서

나중에 좀 쓴다 하면 붙이고자 합니다.









'창고' 카테고리의 다른 글

드로이드나이츠(Droid Knights) 2018  (0) 2018.06.10
Googl I/O 2017 Extended in Seoul  (0) 2017.11.10
드로이드나이츠(Droid Knights) 내용  (0) 2017.11.09
Stream  (0) 2017.10.03
람다 표현식  (0) 2017.10.03



중간 연산


연산 

형식 

반환형식 

연산의 인수 

함수 디스크립터 

 filter 

 중간 연산 

 Stream<T>

 Predicate<T> 

 T -> boolean 

 map 

 중간 연산 

 Stream<T> 

 Function<T, R>

 T -> R

 limit

 중간 연산 

 Stream<T>

 

 

 sorted

 중간 연산 

 Stream<T>

 Comparator<T>

 (T, T) -> int

 distinct

 중간 연산 

 Stream<T>

 

 



최종 연산


 연산

 형식

 목적

 forEach

 최종 연산

 스트림의 각 요소를 소비하면서 람다를 적용한다. void를 반환

 count

 최종 연산

 스트림의 요소 개수를 반환한다. long을 반환

 collect

 최종 연산

 스트림을 리듀스해서 리스트, 맵, 정수 형식의 컬렉션을 만든다.







필터링과 슬라이싱


distinct

        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4);
        numbers.stream()
            .filter(i -> i%2==0)
            .distinct()
            .forEach(System.out::println);
cs


limit

        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4, 6);
        numbers.stream()
            .filter(i -> i%2==0)
            .distinct()
            .limit(2)
            .forEach(System.out::println);
cs


skip

        List<Integer> numbers = Arrays.asList(1, 2, 1, 3, 3, 2, 4, 6);
        numbers.stream()
            .filter(i -> i%2==0)
            .distinct()
            .skip(1)
            .forEach(System.out::println);
cs






매핑


map

        List<Integer> nameSize = productList.stream()
                                    .map(Product::getName)
                                    .map(String::length)
                                    .collect(Collectors.toList());
cs


Arrays.stream

       String strings[] = new String[]{"hello", "world"};
        Stream<String> strStream = Arrays.stream(strings);
cs


잘못된 예

        List<String> charList = strStream
                .map(word -> word.split(""))
                .map(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());
cs

Stream<String[]>

Stream<Stream<String>>

이 되기때문에 컴파일 에러가 난다.


flatMap : 각 배열을 스트림이 아니라 스트림의 콘텐츠로 매핑한다.

        List<String> charList2 = strStream
                .map(word -> word.split(""))
                .flatMap(Arrays::stream)
                .distinct()
                .collect(Collectors.toList());
cs






검색과 매칭

쇼트서킷 기법을 이용함


anyMatch

        if(productList.stream().anyMatch(p -> p.name.equals("TV"))) {
            System.out.println("I have TV");
        }
cs


allMatch

        if(productList.stream().allMatch(p -> p.price>300000)) {
            System.out.println("I haven't cheap product");
        }
cs


noneMatch

        if(productList.stream().noneMatch(p -> p.price>300000)) {
            System.out.println("I have cheap product");
        }
cs


findAny

        Optional<Product> product = productList.stream()
                .filter(p -> p.price>1000000)
                .findAny();
cs


findFirst

        Optional<Product> product = productList.stream()
                .filter(p -> p.price>1000000)
                .findFirst();
cs







리듀싱


        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        int sum = numbers.stream().reduce(0, (a, b) -> a+b);
cs







숫자형 스트림

IntStream에 경우 사용할 수 있는 메서드

sum, max, min, average 등


매핑

        int sumPrice = productList.stream()
                .mapToInt(Product::getPrice)
                .sum();
cs


객체스트림으로 복원

        Stream<Integer> priceStream = productList.stream()
                .mapToInt(Product::getPrice)
                .boxed();
cs


OptionalInt

        OptionalInt maxPrice = productList.stream()
                .mapToInt(Product::getPrice)
                .max();
        System.out.println(maxPrice.orElse(0));
cs


range

        int oddSum = IntStream.range(0, 11)
                .filter(i -> i%2==1)
                .sum();
cs


rangeClosed

        int evenSum = IntStream.rangeClosed(1, 10)
                .filter(i -> i%2==0)
                .sum();
cs







스트림 만들기


값으로 스트림 만들기

        Stream<String> strStream = Stream.of("Hello", "World");
cs


배열로 스트림 만들기

        String strings[] = new String[]{"Hello", "World"};
        Stream<String> strStream = Arrays.stream(strings);
cs


파일로 스트림 만들기

        try {
            Stream<String> lines = Files.lines(Paths.get("example.txt"), Charset.defaultCharset());
            lines.flatMap(line -> Arrays.stream(line.split(" ")))
                .forEach(System.out::println);
        } catch(IOException e) {
            e.printStackTrace();
        }
cs


함수로 무한 스트림 만들기


iterate

        Stream.iterate(1, i->i+1)
            .filter(i -> i%2==0)
            .limit(10)
            .forEach(System.out::println);
cs


generate : Supplier를 통해 인수를 받는다

        Stream.generate(Math::random)
            .map(d -> d*44+1)
            .mapToInt(Double::intValue)
            .distinct()
            .limit(6)
            .forEach(System.out::println);
cs




'창고' 카테고리의 다른 글

드로이드나이츠(Droid Knights) 2018  (0) 2018.06.10
Googl I/O 2017 Extended in Seoul  (0) 2017.11.10
드로이드나이츠(Droid Knights) 내용  (0) 2017.11.09
드로이드나이츠(Droid Knights)  (0) 2017.11.09
람다 표현식  (0) 2017.10.03


함수형 인터페이스


 함수형 인터페이스 

 함수 디스크립터 

 기본형 특화 

 Predicate<T>

 T -> boolean 

 IntPredicate, LongPredicate, DoublePredicate 

 Consumer<T>

 T -> void 

 IntConsumer, LongConsumer, DoubleConsumer

 Function<T, R>

 T -> R 

 IntFunction<R>, IntToDoubleFunction, IntToLongFunction, 

 LongFunction<R>, LongToDoubleFunction, LongToIntFunction, 

 DoubleFunction<R>, 

 ToIntFunction<T>, ToDoubleFunction<T>, ToLongFunction<T>  

 Supplier<T> 

 () -> T 

 BooleanSupplier, IntSupplier, LongSupplier, DoubleSupplier

 UnaryOperator 

 T -> T 

 IntUnaryOperator, LongUnaryOperator, DoubleUnaryOperator

 BinaryOperator<T> 

 (T, T) -> T 

 IntBinaryOperator, LongBinaryOperator, DoubleBinaryOperator

 BiPredicate<L, R> 

 (L, R) -> boolean 

  

 BiConsumer<T, U> 

 (T, U) -> void 

 ObjIntConsumer<T>, ObjLongConsumer<T>, ObjDoubleConsumer<T>

 BiFunction<T, U, R> 

 (T, U) -> R 

 ToIntBiFunction<T, U>, ToLongBiFunction<T, U>, ToDoubleBiFunction<T, U> 








간략화 과정


코드전달

        Comparator<Product> nameComparator = new Comparator<Product>() {
            @Override
            public int compare(Product p1, Product p2) {
                return p1.name.compareTo(p2.name);
            }
        };
        productList.sort(nameComparator);
cs


익명클래스 사용

        productList.sort(new Comparator<Product>() {
            @Override
            public int compare(Product p1, Product p2) {
                return p1.name.compareTo(p2.name);
            }
        });
cs


람다 표현식 사용

        productList.sort((p1, p2)->p1.name.compareTo(p2.name));
cs


메서드 레퍼런스 사용

        productList.sort(Comparator.comparing(Product::getName));
cs








Comparator


reversed

        productList.sort(Comparator.comparing(Product::getName));
cs


thenComparing

        productList.sort(Comparator.comparing(Product::getName).thenComparing(Product::getPrice));
cs







Predicate


기본 사용법

        Predicate<Product> expensiveProduct = (Product p) -> p.price>1000000;
        List<Product> expensiveList = productList.stream().filter(expensiveProduct).collect(Collectors.toList());
cs


negate

        Predicate<Product> cheapProduct = expensiveProduct.negate();
cs


and

        Predicate<Product> expensiveTv = expensiveProduct.and(p -> p.name.equals("TV"));
cs


or

        Predicate<Product> expensiveOrCheapP = expensiveProduct.or(p -> p.price<500000);
cs







Function


andThen

        Function<Integer, Integer> f = x -> x+1;
        Function<Integer, Integer> g = x -> x*2;
        Function<Integer, Integer> h = f.andThen(g);
        
        int result = h.apply(3);
cs


compose

        Function<Integer, Integer> f = x -> x+1;
        Function<Integer, Integer> g = x -> x*2;
        Function<Integer, Integer> h = f.compose(g);
        
        int result = h.apply(3);
cs




'창고' 카테고리의 다른 글

드로이드나이츠(Droid Knights) 2018  (0) 2018.06.10
Googl I/O 2017 Extended in Seoul  (0) 2017.11.10
드로이드나이츠(Droid Knights) 내용  (0) 2017.11.09
드로이드나이츠(Droid Knights)  (0) 2017.11.09
Stream  (0) 2017.10.03

+ Recent posts

티스토리툴바