├── .github └── FUNDING.yml ├── .gitignore ├── LICENSE ├── README.md ├── pom.xml └── src ├── main └── java │ └── dev │ └── rinaldo │ ├── lambda │ ├── Java8_Builtin_Functional_Interfaces.java │ ├── Java8_Collections_New_Methods.java │ ├── Java8_DebugLambda.java │ ├── Java8_Lambda_Tipos.java │ └── Java8_MethodReference.java │ ├── optional │ └── Java8_Optional.java │ └── stream │ ├── Java8_Streams_Collect1.java │ ├── Java8_Streams_Creation.java │ ├── Java8_Streams_Paralelos.java │ └── Java8_Streams_Reduce.java └── test └── java └── dev └── rinaldo └── test ├── lambda ├── Java8_Lambda_Test.java └── Java8_Stream_1_Test.java └── support └── RinaldoDevTest.java /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: rinaldodev 2 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | # Compiled class file 2 | *.class 3 | 4 | # Log file 5 | *.log 6 | 7 | # BlueJ files 8 | *.ctxt 9 | 10 | # Mobile Tools for Java (J2ME) 11 | .mtj.tmp/ 12 | 13 | # Package Files # 14 | *.jar 15 | *.war 16 | *.nar 17 | *.ear 18 | *.zip 19 | *.tar.gz 20 | *.rar 21 | 22 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 23 | hs_err_pid* 24 | 25 | *.iml 26 | 27 | # Created by https://www.gitignore.io/api/eclipse 28 | # Edit at https://www.gitignore.io/?templates=eclipse 29 | 30 | ### Eclipse ### 31 | .metadata 32 | bin/ 33 | tmp/ 34 | *.tmp 35 | *.bak 36 | *.swp 37 | *~.nib 38 | local.properties 39 | .settings/ 40 | .loadpath 41 | .recommenders 42 | 43 | # External tool builders 44 | .externalToolBuilders/ 45 | 46 | # Locally stored "Eclipse launch configurations" 47 | *.launch 48 | 49 | # PyDev specific (Python IDE for Eclipse) 50 | *.pydevproject 51 | 52 | # CDT-specific (C/C++ Development Tooling) 53 | .cproject 54 | 55 | # CDT- autotools 56 | .autotools 57 | 58 | # Java annotation processor (APT) 59 | .factorypath 60 | 61 | # PDT-specific (PHP Development Tools) 62 | .buildpath 63 | 64 | # sbteclipse plugin 65 | .target 66 | 67 | # Tern plugin 68 | .tern-project 69 | 70 | # TeXlipse plugin 71 | .texlipse 72 | 73 | # STS (Spring Tool Suite) 74 | .springBeans 75 | 76 | # Code Recommenders 77 | .recommenders/ 78 | 79 | # Annotation Processing 80 | .apt_generated/ 81 | 82 | # Scala IDE specific (Scala & Java development for Eclipse) 83 | .cache-main 84 | .scala_dependencies 85 | .worksheet 86 | 87 | ### Eclipse Patch ### 88 | # Eclipse Core 89 | 90 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 91 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 92 | 93 | # User-specific stuff 94 | .idea/**/workspace.xml 95 | .idea/**/tasks.xml 96 | .idea/**/usage.statistics.xml 97 | .idea/**/dictionaries 98 | .idea/**/shelf 99 | 100 | # AWS User-specific 101 | .idea/**/aws.xml 102 | 103 | # Generated files 104 | .idea/**/contentModel.xml 105 | 106 | .idea 107 | 108 | # Sensitive or high-churn files 109 | .idea/**/dataSources/ 110 | .idea/**/dataSources.ids 111 | .idea/**/dataSources.local.xml 112 | .idea/**/sqlDataSources.xml 113 | .idea/**/dynamic.xml 114 | .idea/**/uiDesigner.xml 115 | .idea/**/dbnavigator.xml 116 | 117 | # Gradle 118 | .idea/**/gradle.xml 119 | .idea/**/libraries 120 | 121 | # Gradle and Maven with auto-import 122 | # When using Gradle or Maven with auto-import, you should exclude module files, 123 | # since they will be recreated, and may cause churn. Uncomment if using 124 | # auto-import. 125 | # .idea/artifacts 126 | # .idea/compiler.xml 127 | # .idea/jarRepositories.xml 128 | # .idea/modules.xml 129 | # .idea/*.iml 130 | # .idea/modules 131 | # *.iml 132 | # *.ipr 133 | 134 | # CMake 135 | cmake-build-*/ 136 | 137 | # Mongo Explorer plugin 138 | .idea/**/mongoSettings.xml 139 | 140 | # File-based project format 141 | *.iws 142 | 143 | # IntelliJ 144 | out/ 145 | 146 | # mpeltonen/sbt-idea plugin 147 | .idea_modules/ 148 | 149 | # JIRA plugin 150 | atlassian-ide-plugin.xml 151 | 152 | # Cursive Clojure plugin 153 | .idea/replstate.xml 154 | 155 | # SonarLint plugin 156 | .idea/sonarlint/ 157 | 158 | # Crashlytics plugin (for Android Studio and IntelliJ) 159 | com_crashlytics_export_strings.xml 160 | crashlytics.properties 161 | crashlytics-build.properties 162 | fabric.properties 163 | 164 | # Editor-based Rest Client 165 | .idea/httpRequests 166 | 167 | # Android studio 3.1+ serialized cache file 168 | .idea/caches/build_file_checksums.ser 169 | .project 170 | 171 | # JDT-specific (Eclipse Java Development Tools) 172 | .classpath 173 | 174 | # Annotation Processing 175 | .apt_generated 176 | 177 | .sts4-cache/ 178 | 179 | # End of https://www.gitignore.io/api/eclipse 180 | 181 | .vscode 182 | .vscode/**/* -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2019 Rinaldo Pitzer Júnior 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso Lambda, Streams e Optional do Java 8 (Completo) 2 | 3 | Códigos feitos para o curso/playlist de Multithreading com Java, no canal RinaldoDev do YouTube. 4 | 5 | * Playlist no YouTube: https://www.youtube.com/playlist?list=PLuYctAHjg89ZkhgOQo0zcTtmHY5nuRYud 6 | * Canal no YouTube: https://www.youtube.com/rinaldodev 7 | 8 | ## Me siga para mais conteúdo gratuito! 9 | 10 | * Twitter: https://twitter.com/rinaldodev 11 | * LinkedIn: https://www.linkedin.com/in/rinaldodev/ 12 | * Facebook: https://www.facebook.com/rinaldodev/ 13 | * Twitch: https://www.twitch.tv/rinaldodev 14 | * Site: https://rinaldo.dev 15 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 2 | 5 | 4.0.0 6 | 7 | dev.rinaldo 8 | java8-lambda-streams 9 | 1.0-SNAPSHOT 10 | 11 | 12 | 8 13 | 8 14 | UTF-8 15 | 16 | 17 | 18 | 19 | org.junit.jupiter 20 | junit-jupiter 21 | 5.9.2 22 | test 23 | 24 | 25 | 26 | -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/lambda/Java8_Builtin_Functional_Interfaces.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.lambda; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Random; 6 | import java.util.stream.Stream; 7 | 8 | /** 9 | * JAVA 8 - Interfaces Funcionais da JDK 10 | * 11 | * @author RinaldoDev 12 | */ 13 | public class Java8_Builtin_Functional_Interfaces { 14 | 15 | public static void main(String[] args) { 16 | 17 | Stream.generate(() -> new Random().nextInt()) // supplier 18 | .limit(5) 19 | .forEach((e) -> System.out.println(e)); // consumer 20 | 21 | List list = Arrays.asList(1, 2, 3, 4, 5); 22 | list.stream() 23 | .filter(e -> e % 2 == 0) // predicate 24 | .map(e -> e.doubleValue()) // function 25 | .reduce((e1, e2) -> e1 + e2) // BinaryOperator 26 | .ifPresent(System.out::println); 27 | 28 | } 29 | 30 | } 31 | 32 | //YouTube: RinaldoDev 33 | //Twitter: @rinaldodev 34 | //Facebook: RinaldoDev 35 | //GitHub: rinaldodev 36 | //LinkedIn: rinaldodev 37 | //Site: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/lambda/Java8_Collections_New_Methods.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.lambda; 2 | 3 | import java.util.ArrayList; 4 | import java.util.HashMap; 5 | import java.util.List; 6 | 7 | /** 8 | * JAVA 8 - Novos métodos em Collections 9 | * 10 | * @author RinaldoDev 11 | */ 12 | public class Java8_Collections_New_Methods { 13 | 14 | public static void main(String[] args) { 15 | 16 | // List 17 | List list = new ArrayList<>(); 18 | list.add(1); 19 | list.add(2); 20 | list.add(3); 21 | list.add(4); 22 | 23 | // forEach 24 | list.forEach(n -> System.out.println(n)); 25 | 26 | // removeIf 27 | list.removeIf(n -> n % 2 == 0); 28 | list.forEach(n -> System.out.println(n)); 29 | 30 | // replaceAll 31 | list.replaceAll(n -> n * 2); 32 | list.forEach(n -> System.out.println(n)); 33 | 34 | // Map 35 | HashMap map = new HashMap<>(); 36 | map.put(0, "Se"); 37 | map.put(1, "inscreva"); 38 | map.put(2, "no"); 39 | map.put(3, "canal"); 40 | 41 | // forEach 42 | map.forEach((k, v) -> System.out.println(k + v)); 43 | 44 | // compute 45 | map.compute(1, (k, v) -> v + " agora"); 46 | map.forEach((k, v) -> System.out.println(k + v)); 47 | 48 | // merge 49 | map.merge(4, "!", (v1, v2) -> v1 + v2); 50 | map.forEach((k, v) -> System.out.println(k + v)); 51 | 52 | // replaceAll 53 | map.replaceAll((k, v) -> v + "!"); 54 | map.forEach((k, v) -> System.out.println(k + v)); 55 | } 56 | 57 | } 58 | 59 | //YouTube: RinaldoDev 60 | //Twitter: @rinaldodev 61 | //Facebook: RinaldoDev 62 | //GitHub: rinaldodev 63 | //LinkedIn: rinaldodev 64 | //Site: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/lambda/Java8_DebugLambda.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.lambda; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | 6 | /** 7 | * JAVA 8 - Debug Lambda 8 | * 9 | * @author RinaldoDev 10 | */ 11 | public class Java8_DebugLambda { 12 | 13 | public static void main(String[] args) { 14 | 15 | List list = Arrays.asList(1, 2, 5, 8, 9); 16 | 17 | list.stream() 18 | .peek(n -> System.out.println(n + "Se inscreva!")) 19 | .filter(n -> n % 2 == 0) 20 | .peek(n -> System.out.println(n + "Comente!")) 21 | // .filter(n -> n % 2 == 0) 22 | // .filter(n -> n % 2 == 0) 23 | // .map(..) 24 | .forEach(System.out::println); 25 | 26 | } 27 | 28 | private static StringBuilder converteParaStringBuilder(Integer n) { 29 | StringBuilder builder = new StringBuilder(); 30 | builder.append(n); 31 | builder.append("s"); 32 | builder.append("a"); 33 | return builder; 34 | } 35 | 36 | } 37 | 38 | //YouTube: RinaldoDev 39 | //Twitter: @rinaldodev 40 | //Facebook: RinaldoDev 41 | //GitHub: rinaldodev 42 | //LinkedIn: rinaldodev 43 | //Site: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/lambda/Java8_Lambda_Tipos.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.lambda; 2 | 3 | import java.util.stream.IntStream; 4 | 5 | /** 6 | * JAVA 8 - Funções Lambda - Tipos 7 | * 8 | * @author RinaldoDev 9 | */ 10 | public class Java8_Lambda_Tipos { 11 | 12 | public static void main(String[] args) { 13 | 14 | // Parênteses 15 | Runnable runnable = () -> System.out.println("Se inscreva no canal!"); 16 | 17 | IntStream.range(0, 5) 18 | .filter((int n) -> n % 2 == 0) 19 | .reduce((n1, n2) -> n1 + n2) 20 | .ifPresent(System.out::println); 21 | 22 | // Chaves 23 | IntStream.range(0, 5) 24 | .filter((int n) -> { 25 | System.out.println("Se inscreva no canal!"); 26 | return n % 2 == 0; 27 | }) 28 | .forEach(System.out::println); 29 | 30 | } 31 | 32 | } 33 | 34 | //YouTube: RinaldoDev 35 | //Twitter: @rinaldodev 36 | //Facebook: RinaldoDev 37 | //GitHub: rinaldodev 38 | //LinkedIn: rinaldodev 39 | //Site: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/lambda/Java8_MethodReference.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.lambda; 2 | 3 | import java.math.BigDecimal; 4 | import java.util.Arrays; 5 | import java.util.List; 6 | 7 | /** 8 | * JAVA 8 - Method Reference 9 | * 10 | * @author RinaldoDev 11 | */ 12 | public class Java8_MethodReference { 13 | 14 | public static void main(String[] args) { 15 | 16 | List list = Arrays.asList(1, 2, 3, 4, 5); 17 | 18 | list.stream() 19 | .forEach(System.out::println); // method reference 20 | 21 | list.stream() 22 | .forEach((n) -> System.out.println(n)); // sem method reference 23 | 24 | // métodos estáticos 25 | list.stream() 26 | .map((n) -> multipliquePorDois(n)) 27 | .forEach(System.out::println); 28 | 29 | list.stream() 30 | .map(Java8_MethodReference::multipliquePorDois) 31 | .forEach(System.out::println); 32 | 33 | // construtores 34 | list.stream() 35 | .map((n) -> new BigDecimal(n)) 36 | .forEach(System.out::println); 37 | 38 | list.stream() 39 | .map(BigDecimal::new) 40 | .forEach(System.out::println); 41 | 42 | // várias instâncias 43 | list.stream() 44 | .map((n) -> n.doubleValue()) 45 | .forEach(System.out::println); 46 | 47 | list.stream() 48 | .map(Integer::doubleValue) 49 | .forEach(System.out::println); 50 | 51 | // única instância 52 | BigDecimal dois = new BigDecimal(2); 53 | list.stream() 54 | .map(BigDecimal::new) 55 | .map((b) -> dois.multiply(b)) 56 | .forEach(System.out::println); 57 | 58 | list.stream() 59 | .map(BigDecimal::new) 60 | .map(dois::multiply) 61 | .forEach(System.out::println); 62 | } 63 | 64 | private static Integer multipliquePorDois(Integer i) { 65 | return i * 2; 66 | } 67 | 68 | } 69 | 70 | //YouTube: RinaldoDev 71 | //Twitter: @rinaldodev 72 | //Facebook: RinaldoDev 73 | //GitHub: rinaldodev 74 | //LinkedIn: rinaldodev 75 | //Site: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/optional/Java8_Optional.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.optional; 2 | 3 | import java.util.Optional; 4 | 5 | /** 6 | * JAVA 8 - Optional
7 | * Vídeo em: https://www.youtube.com/watch?v=hmU2QEEc4sU 8 | * 9 | * @author RinaldoDev 10 | */ 11 | public class Java8_Optional { 12 | 13 | public static void main(String[] args) { 14 | 15 | // String s = "Inscreva-se!"; 16 | String s = "1"; 17 | 18 | Optional numero = converteEmNumero(s); 19 | 20 | System.out.println(numero); 21 | System.out.println(numero.isPresent()); 22 | System.out.println(numero.get()); 23 | 24 | numero.ifPresent(n -> System.out.println(n)); 25 | 26 | Integer orElse = numero.orElse(2); 27 | System.out.println(orElse); 28 | 29 | Integer orElseGet = numero.orElseGet(() -> 5); 30 | System.out.println(orElseGet); 31 | 32 | Integer orElseThrow = numero.orElseThrow(() -> new NullPointerException()); 33 | System.out.println(orElseThrow); 34 | 35 | } 36 | 37 | public static Optional converteEmNumero(String numeroStr) { 38 | 39 | try { 40 | Integer integer = Integer.valueOf(numeroStr); 41 | return Optional.of(integer); 42 | } catch (Exception e) { 43 | return Optional.empty(); 44 | } 45 | 46 | } 47 | 48 | // public static OptionalInt converteEmNumero(String numeroStr) { 49 | // 50 | // try { 51 | // int integer = Integer.parseInt(numeroStr); 52 | // return OptionalInt.of(integer); 53 | // } catch (Exception e) { 54 | // return OptionalInt.empty(); 55 | // } 56 | // 57 | // } 58 | 59 | } 60 | 61 | // YouTube: RinaldoDev 62 | // Twitter: @rinaldodev 63 | // Facebook: RinaldoDev 64 | // GitHub: rinaldodev 65 | // LinkedIn: rinaldodev 66 | // Blog: rinaldo.dev 67 | -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/stream/Java8_Streams_Collect1.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.stream; 2 | 3 | import java.util.ArrayDeque; 4 | import java.util.Arrays; 5 | import java.util.Comparator; 6 | import java.util.Deque; 7 | import java.util.HashSet; 8 | import java.util.IntSummaryStatistics; 9 | import java.util.List; 10 | import java.util.Map; 11 | import java.util.Optional; 12 | import java.util.Set; 13 | import java.util.stream.Collectors; 14 | 15 | /** 16 | * JAVA 8 - Streams - Collect
17 | * Vídeo em: https://www.youtube.com/watch?v=mTbh9d2orcU 18 | * 19 | * @author RinaldoDev 20 | */ 21 | public class Java8_Streams_Collect1 { 22 | 23 | public static void main(String[] args) { 24 | List list = Arrays.asList(1,2,3,4,5,6); 25 | 26 | // fornecedor - acumulação - combinação 27 | Set collect = list.stream() 28 | .collect( 29 | () -> new HashSet<>(), 30 | (l, e) -> l.add(e.toString()), 31 | (l1, l2) -> l1.addAll(l2) 32 | ); 33 | 34 | System.out.println(list); 35 | System.out.println(collect); 36 | 37 | // toList / toSet 38 | Deque collect2 = list.stream() 39 | .filter((n) -> n % 2 == 0) 40 | .collect(Collectors.toCollection( 41 | () -> new ArrayDeque() 42 | )); 43 | System.out.println(collect2); 44 | 45 | // joining 46 | String join = list.stream() 47 | .map(n -> n.toString()) 48 | .collect(Collectors.joining("f")); 49 | System.out.println(join); 50 | 51 | // averaging 52 | Double media = list.stream() 53 | .collect(Collectors.averagingInt(n -> n.intValue())); 54 | System.out.println(media); 55 | 56 | // summing 57 | Integer soma = list.stream() 58 | .collect(Collectors.summingInt(n -> n.intValue())); 59 | System.out.println(soma); 60 | 61 | // summarizing 62 | IntSummaryStatistics stats = list.stream() 63 | .collect(Collectors.summarizingInt(n -> n.intValue())); 64 | System.out.println("IntSummaryStatistics: "); 65 | System.out.println(stats.getAverage()); 66 | System.out.println(stats.getCount()); 67 | System.out.println(stats.getMax()); 68 | System.out.println(stats.getMin()); 69 | System.out.println(stats.getSum()); 70 | 71 | // counting 72 | Long count = list.stream() 73 | .filter((n) -> n % 2 == 0) 74 | .collect(Collectors.counting()); 75 | System.out.println(count); 76 | 77 | // max/min 78 | list.stream() 79 | .filter((n) -> n % 2 == 0) 80 | .collect(Collectors.minBy(Comparator.naturalOrder())) 81 | .ifPresent(System.out::println); 82 | 83 | // groupingBy 84 | Map> groupingBy = list.stream() 85 | .collect(Collectors.groupingBy((n) -> n % 3)); 86 | System.out.println(groupingBy); 87 | 88 | // partitioningBy 89 | Map> partitioningBy = list.stream() 90 | .collect(Collectors.partitioningBy((n) -> n % 2 == 0)); 91 | System.out.println(partitioningBy); 92 | 93 | // toMap 94 | Map toMap = list.stream() 95 | .collect(Collectors.toMap( 96 | n -> n, 97 | n -> Math.pow(n.doubleValue(), 5) 98 | )); 99 | System.out.println(toMap); 100 | } 101 | 102 | } 103 | 104 | //YouTube: RinaldoDev 105 | //Twitter: @rinaldodev 106 | //Facebook: RinaldoDev 107 | //GitHub: rinaldodev 108 | //LinkedIn: rinaldodev 109 | //Site: rinaldo.dev 110 | -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/stream/Java8_Streams_Creation.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.stream; 2 | 3 | import java.io.BufferedReader; 4 | import java.io.File; 5 | import java.io.FileNotFoundException; 6 | import java.io.FileReader; 7 | import java.io.IOException; 8 | import java.nio.file.Files; 9 | import java.nio.file.Path; 10 | import java.nio.file.Paths; 11 | import java.util.Arrays; 12 | import java.util.List; 13 | import java.util.Random; 14 | import java.util.regex.Pattern; 15 | import java.util.stream.IntStream; 16 | import java.util.stream.Stream; 17 | 18 | /** 19 | * JAVA 8 - Streams - Criando STREAMS 20 | * @author rinaldodev 21 | */ 22 | public class Java8_Streams_Creation { 23 | 24 | public static void main(String[] args) throws IOException { 25 | 26 | // Collection 27 | List list = Arrays.asList(1,2,3,4); 28 | list.stream().forEach(System.out::println); 29 | 30 | // Arrays 31 | Integer[] intArray = new Integer[] {1,2,3,4}; 32 | Arrays.stream(intArray).forEach(System.out::println); 33 | 34 | // Stream.of 35 | Stream 36 | .of("Se", "inscreva", "no", "canal", "!") 37 | .forEach(System.out::println); 38 | 39 | // IntStream.range 40 | IntStream.range(15, 20).forEach(System.out::println); 41 | 42 | // Stream.iterate 43 | Stream 44 | .iterate(5, n -> n * 2) 45 | .limit(10) 46 | .forEach(System.out::println); 47 | 48 | // BufferedReader - lines 49 | // streams.txt - 11, 12, 13 50 | File file = new File("streams.txt"); 51 | FileReader in = new FileReader(file); 52 | try (BufferedReader br = new BufferedReader(in)) { 53 | br.lines().forEach(System.out::println); 54 | } 55 | 56 | // Files 57 | Path p = Paths.get(""); 58 | Files.list(p).forEach(System.out::println); 59 | 60 | // Random 61 | new Random() 62 | .ints() 63 | .limit(10) 64 | .forEach(System.out::println); 65 | 66 | // Pattern 67 | String s = "Deixe um curtir no vídeo!"; 68 | Pattern pa = Pattern.compile(" "); 69 | pa.splitAsStream(s).forEach(System.out::println); 70 | } 71 | 72 | } 73 | 74 | //YouTube: RinaldoDev 75 | //Twitter: @rinaldodev 76 | //Facebook: RinaldoDev 77 | //GitHub: rinaldodev 78 | //LinkedIn: rinaldodev 79 | //Site: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/stream/Java8_Streams_Paralelos.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Map; 6 | import java.util.stream.Collectors; 7 | import java.util.stream.IntStream; 8 | 9 | /** 10 | * JAVA 8 - Streams Paralelos 11 | * 12 | * @author RinaldoDev 13 | */ 14 | public class Java8_Streams_Paralelos { 15 | 16 | public static void main(String[] args) { 17 | List list = Arrays.asList(1,2,3,4); 18 | 19 | // parallel vs parallelStream 20 | // list.parallelStream() 21 | // IntStream.range(0, 5).parallel() 22 | 23 | // forEach x forEachOrdered 24 | list.parallelStream() 25 | .forEach(System.out::println); 26 | System.out.println("---"); 27 | list.parallelStream() 28 | .forEachOrdered(System.out::println); 29 | 30 | System.out.println("---"); 31 | 32 | // findAny 33 | list.parallelStream() 34 | .findAny() 35 | .ifPresent(System.out::println); 36 | System.out.println("---"); 37 | list.stream() 38 | .findAny() 39 | .ifPresent(System.out::println); 40 | 41 | System.out.println("---"); 42 | 43 | // unordered 44 | list.parallelStream() 45 | .unordered() 46 | .skip(1) 47 | .limit(2) 48 | .forEach(System.out::println); 49 | 50 | System.out.println("---"); 51 | 52 | // reduce 53 | // (1 + 2) + (3 + 4) = 10 - é associativa 54 | // (1 - 2) - (3 - 4) != -8 - não é associativa 55 | list.parallelStream() 56 | .reduce((n1, n2) -> n1 - n2) 57 | .ifPresent(System.out::println); 58 | 59 | System.out.println("---"); 60 | 61 | // toMap 62 | Map collect = 63 | list.parallelStream() 64 | .collect( 65 | Collectors 66 | .toConcurrentMap(n -> n, n -> n % 2 == 0) 67 | ); 68 | System.out.println(collect); 69 | System.out.println("---"); 70 | 71 | // groupingBy 72 | Map> collect2 = 73 | list.parallelStream() 74 | .collect( 75 | Collectors 76 | .groupingByConcurrent(n -> n % 2 == 0) 77 | ); 78 | System.out.println(collect2); 79 | 80 | } 81 | 82 | } 83 | 84 | //YouTube: RinaldoDev 85 | //Twitter: @rinaldodev 86 | //Facebook: RinaldoDev 87 | //GitHub: rinaldodev 88 | //LinkedIn: rinaldodev 89 | //Blog: rinaldo.dev -------------------------------------------------------------------------------- /src/main/java/dev/rinaldo/stream/Java8_Streams_Reduce.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.stream; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.Optional; 6 | import java.util.OptionalDouble; 7 | import java.util.stream.DoubleStream; 8 | 9 | /** 10 | * JAVA 8 - Streams - Reduce
11 | * Vídeo em: https://youtu.be/2aHElyENpuM 12 | * 13 | * @author RinaldoDev 14 | */ 15 | public class Java8_Streams_Reduce { 16 | 17 | public static void main(String[] args) { 18 | String s = "Inscreva-se no canal e compartilhe esse vídeo!"; 19 | String[] split = s.split(" "); 20 | List listStr = Arrays.asList(split); 21 | List list = Arrays.asList(1,2,3,4,5,6); 22 | 23 | // 1 + 2 + 3 + 4 + 5 + 6 24 | // reduce - soma 25 | Optional soma = list.stream() 26 | .reduce((n1, n2) -> n1 + n2); 27 | 28 | System.out.println(soma.get()); 29 | 30 | //reduce - multiplicação 31 | Optional multiplicacao = list.stream() 32 | .reduce((n1, n2) -> n1 * n2); 33 | 34 | System.out.println(multiplicacao.get()); 35 | 36 | //reduce - concatenação 37 | Optional concatenacao = listStr.stream() 38 | .reduce((s1, s2) -> s1.concat(s2)); 39 | 40 | System.out.println(concatenacao.get()); 41 | 42 | // 1 - 2 - 3 - 4 - 5 - 6 43 | // reduce - subtração - NÃO FAÇA 44 | Optional subtracao = list.stream() 45 | .reduce((n1, n2) -> n1 - n2); 46 | 47 | System.out.println(subtracao.get()); 48 | 49 | 50 | // reduce - soma 51 | Integer soma2 = list.stream() 52 | .reduce(0, (n1, n2) -> n1 + n2); 53 | 54 | System.out.println(soma2); 55 | 56 | //reduce - multiplicação 57 | Integer multiplicacao2 = list.stream() 58 | .reduce(1, (n1, n2) -> n1 * n2); 59 | 60 | System.out.println(multiplicacao2); 61 | 62 | //reduce - concatenação 63 | String concatenacao2 = listStr.stream() 64 | .reduce("", (s1, s2) -> s1.concat(s2)); 65 | 66 | System.out.println(concatenacao2); 67 | 68 | // reduce - menor valor 69 | double menorValor = DoubleStream.of(1.5, 2.9, 6.7) 70 | .reduce(Double.POSITIVE_INFINITY, (d1, d2) -> Math.min(d1, d2)); 71 | System.out.println(menorValor); 72 | 73 | 74 | // reduce - soma 75 | Integer soma3 = list.stream() 76 | .reduce(0, (n1, n2) -> n1 + n2, (n1, n2) -> n1 + n2); 77 | 78 | System.out.println(soma3); 79 | 80 | // reduce - map + combiner 81 | String reduce = list.stream() 82 | .reduce( 83 | "", 84 | (n1, n2) -> n1.toString().concat(n2.toString()), 85 | (n1, n2) -> n1.concat(n2) 86 | ); 87 | System.out.println(reduce); 88 | 89 | } 90 | 91 | } 92 | 93 | //YouTube: RinaldoDev 94 | //Twitter: @rinaldodev 95 | //Facebook: RinaldoDev 96 | //GitHub: rinaldodev 97 | //LinkedIn: rinaldodev 98 | //Blog: rinaldo.dev 99 | -------------------------------------------------------------------------------- /src/test/java/dev/rinaldo/test/lambda/Java8_Lambda_Test.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.test.lambda; 2 | 3 | import dev.rinaldo.test.support.RinaldoDevTest; 4 | import org.junit.jupiter.api.Test; 5 | 6 | import java.util.Arrays; 7 | import java.util.List; 8 | import java.util.concurrent.atomic.AtomicInteger; 9 | 10 | import static org.junit.jupiter.api.Assertions.*; 11 | 12 | /** 13 | * EXERCÍCIOS da aula introdutória de Lambdas: https://www.youtube.com/watch?v=lbCYLgoVpfQ&list=PLuYctAHjg89ZkhgOQo0zcTtmHY5nuRYud&index=2 14 | * 15 | * 16 | * ----------------------- SOBRE OS EXERCÍCIOS ----------------------- 17 | * Estes exercícios foram elaborados por Rinaldo para o canal RinaldoDev no youtube: youtube.com/rinaldodev 18 | * 19 | * Este exercício foi feito gratuitamente e está disponível abertamente no GitHub. 20 | * 21 | * Se puder, peço que contribua se tornando membro do canal no YouTube. Você ainda ganha acesso a mais vídeos de 22 | * correções de exercícios e vários conteúdos exclusivos: https://www.youtube.com/rinaldodev/join 23 | * ------------------------------------------------------------------- 24 | * 25 | * 26 | * ----------------------- COMO FAZER OS EXERCÍCIOS ----------------------- 27 | * Os exercícios são testes usando JUnit onde você deve alterar a parte do código indicada para fazer o teste passar. 28 | * 29 | * Sempre que um comentário tiver "!!! INÍCIO DA SUA PARTE !!!", significa que você deverá alterar o teste a partir 30 | * daquele ponto para fazê-lo passar, e não poderá alterar nada mais depois de "!!! FIM DA SUA PARTE !!!". 31 | * Os comentários podem ainda conter instruções e regras adicionais. 32 | * Alterar o teste em qualquer outro ponto ou não seguir as regras descritas nos comentários é considerado trapaça. 33 | * ------------------------------------------------------------------------ 34 | * 35 | * 36 | * ----------------------- SETUP/WHEN/THEN ----------------------- 37 | * O teste usa o formato de testes setup/when/then. 38 | * "setup": é onde é feito a configuração inicial dos testes, instanciados os objetos que serão testados. 39 | * "validações do exercício": validações mínimas para garantir que o teste vai rodar. 40 | * "when": execução que será testada e irá alterar o estado de variáveis ou objetos. 41 | * "then": validações de que o estado esperado foi atingido. 42 | * --------------------------------------------------------------- 43 | * 44 | * 45 | * ----------------------- AINDA ESTOU COM DÚVIDAS! ----------------------- 46 | * Assista ao vídeo com as explicações de cada exercício! Ele fica na mesma playlist dos demais! 47 | * Se quiser mais ajuda, entra no nosso grupo do WhatsApp que alguém pode te ajudar: https://rinaldo.dev/whatsapp 48 | * ------------------------------------------------------------------------ 49 | * 50 | * 51 | * ----------------------- DEPOIS DE TERMINAR ----------------------- 52 | * Ao terminar os testes, se você for um membro do canal, compartilha lá no nosso grupo do WhatsApp! https://rinaldo.dev/whatsapp 53 | * 54 | * Ou então poste em qualquer rede social e me marque! Sou @RinaldoDev em todas elas! 55 | * 56 | * Twitter: https://twitter.com/rinaldodev 57 | * Instagram: https://www.instagram.com/rinaldodev/ 58 | * LinkedIn: https://www.linkedin.com/in/rinaldodev/ 59 | * Site: https://rinaldo.dev 60 | * GitHub: https://github.com/rinaldodev 61 | * Facebook: https://www.facebook.com/rinaldodev 62 | * Twitch: https://www.twitch.tv/rinaldodev 63 | * ------------------------------------------------------------------ 64 | * 65 | */ 66 | public class Java8_Lambda_Test extends RinaldoDevTest { 67 | 68 | /** 69 | * EXERCÍCIO 1 - FUNÇÃO LAMBDA 70 | */ 71 | @Test 72 | public void test1() { 73 | // -- setup -- 74 | final AtomicInteger soma = new AtomicInteger(0); 75 | 76 | final Thread minhaTreadTradicional = new Thread(new Runnable() { 77 | @Override 78 | public void run() { 79 | soma.incrementAndGet(); 80 | } 81 | }); 82 | 83 | // !!! INÍCIO DA SUA PARTE !!! 84 | 85 | // 1) faça uma thread imitando o comportamento da thread acima 86 | // 2) use uma função lambda para representar o Runnable 87 | 88 | final Thread minhaTreadLambda = null; // ... seu código ao invés de 'null' ... 89 | 90 | // !!! FIM DA SUA PARTE !!! 91 | 92 | // -- validações do exercício -- 93 | assertNotNull(soma, TESTE_QUEBRADO); 94 | assertNotNull(minhaTreadTradicional, TESTE_QUEBRADO); 95 | assertNotNull(minhaTreadLambda, "'minhaTreadLambda' não pode ser 'null', você deve implementá-la."); 96 | 97 | // -- when -- 98 | minhaTreadTradicional.run(); 99 | minhaTreadLambda.run(); 100 | 101 | // -- then -- 102 | assertEquals(2, soma.get(), "O valor final de 'soma' deve ser 2, pois deverá incrementado 2 vezes: primeiro pela thread 'minhaTreadTradicional' e depois pela 'minhaTreadLambda'."); 103 | } 104 | 105 | /** 106 | * EXERCÍCIO 2 - FOREACH 107 | */ 108 | @Test 109 | public void test2() { 110 | // -- setup -- 111 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5); 112 | 113 | // -- validações do exercício -- 114 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 115 | assertEquals(Arrays.asList(1, 2, 3, 4, 5), listaDeNumeros, TESTE_QUEBRADO); 116 | 117 | // -- when -- 118 | for (Integer integer : listaDeNumeros) { 119 | System.out.print(integer); 120 | } 121 | 122 | // !!! INÍCIO DA SUA PARTE !!! 123 | 124 | // 1) imprima os 5 números da lista no console, imitando o comportamento do 'for' acima 125 | // 2) imprima todos os números na mesma linha usando "System.out.print" 126 | // 3) utilize o método forEach da API de Streams 127 | // 4) passe uma função lambda como argumento para o método forEach 128 | 129 | // ... seu código ... 130 | 131 | // !!! FIM DA SUA PARTE !!! 132 | 133 | // -- then -- 134 | assertConsoleContains("1234512345"); 135 | } 136 | 137 | /** 138 | * EXERCÍCIO 3 - FILTER 139 | */ 140 | @Test 141 | public void test3() { 142 | // -- setup -- 143 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5, 6); 144 | 145 | // -- validações do exercício -- 146 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 147 | assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), listaDeNumeros, TESTE_QUEBRADO); 148 | 149 | // -- when -- 150 | 151 | // !!! INÍCIO DA SUA PARTE !!! 152 | 153 | // 1) imprima no console os números pares da lista 154 | // 2) imprima todos na mesma linha usando "System.out.print" 155 | // 3) use streams, filter e forEach. 156 | 157 | // ... seu código ... 158 | 159 | // !!! FIM DA SUA PARTE !!! 160 | 161 | // -- then -- 162 | assertConsoleContains("246"); 163 | } 164 | } 165 | -------------------------------------------------------------------------------- /src/test/java/dev/rinaldo/test/lambda/Java8_Stream_1_Test.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.test.lambda; 2 | 3 | import dev.rinaldo.test.support.RinaldoDevTest; 4 | import org.junit.jupiter.api.Test; 5 | 6 | import java.util.Arrays; 7 | import java.util.List; 8 | 9 | import static org.junit.jupiter.api.Assertions.*; 10 | 11 | /** 12 | * EXERCÍCIOS da aula de Streams - Parte 1: https://www.youtube.com/watch?v=bTlS_BdS41w&list=PLuYctAHjg89ZkhgOQo0zcTtmHY5nuRYud&index=3 13 | * 14 | * 15 | * ----------------------- SOBRE OS EXERCÍCIOS ----------------------- 16 | * Estes exercícios foram elaborados por Rinaldo para o canal RinaldoDev no youtube: youtube.com/rinaldodev 17 | * 18 | * Este exercício foi feito gratuitamente e está disponível abertamente no GitHub. 19 | * 20 | * Se puder, peço que contribua se tornando membro do canal no YouTube. Você ainda ganha acesso a mais vídeos de 21 | * correções de exercícios e vários conteúdos exclusivos: https://www.youtube.com/rinaldodev/join 22 | * ------------------------------------------------------------------- 23 | * 24 | * 25 | * ----------------------- COMO FAZER OS EXERCÍCIOS ----------------------- 26 | * Os exercícios são testes usando JUnit onde você deve alterar a parte do código indicada para fazer o teste passar. 27 | * 28 | * Sempre que um comentário tiver "!!! INÍCIO DA SUA PARTE !!!", significa que você deverá alterar o teste a partir 29 | * daquele ponto para fazê-lo passar, e não poderá alterar nada mais depois de "!!! FIM DA SUA PARTE !!!". 30 | * Os comentários podem ainda conter instruções e regras adicionais. 31 | * Alterar o teste em qualquer outro ponto ou não seguir as regras descritas nos comentários é considerado trapaça. 32 | * ------------------------------------------------------------------------ 33 | * 34 | * 35 | * ----------------------- SETUP/WHEN/THEN ----------------------- 36 | * O teste usa o formato de testes setup/when/then. 37 | * "setup": é onde é feito a configuração inicial dos testes, instanciados os objetos que serão testados. 38 | * "validações do exercício": validações mínimas para garantir que o teste vai rodar. 39 | * "when": execução que será testada e irá alterar o estado de variáveis ou objetos. 40 | * "then": validações de que o estado esperado foi atingido. 41 | * --------------------------------------------------------------- 42 | * 43 | * 44 | * ----------------------- AINDA ESTOU COM DÚVIDAS! ----------------------- 45 | * Assista ao vídeo com as explicações de cada exercício! Ele fica na mesma playlist dos demais! 46 | * Se quiser mais ajuda, entra no nosso grupo do WhatsApp que alguém pode te ajudar: https://rinaldo.dev/whatsapp 47 | * ------------------------------------------------------------------------ 48 | * 49 | * 50 | * ----------------------- DEPOIS DE TERMINAR ----------------------- 51 | * Ao terminar os testes, se você for um membro do canal, compartilha lá no nosso grupo do WhatsApp! https://rinaldo.dev/whatsapp 52 | * 53 | * Ou então poste em qualquer rede social e me marque! Sou @RinaldoDev em todas elas! 54 | * 55 | * Twitter: https://twitter.com/rinaldodev 56 | * Instagram: https://www.instagram.com/rinaldodev/ 57 | * LinkedIn: https://www.linkedin.com/in/rinaldodev/ 58 | * Site: https://rinaldo.dev 59 | * GitHub: https://github.com/rinaldodev 60 | * Facebook: https://www.facebook.com/rinaldodev 61 | * Twitch: https://www.twitch.tv/rinaldodev 62 | * ------------------------------------------------------------------ 63 | * 64 | */ 65 | public class Java8_Stream_1_Test extends RinaldoDevTest { 66 | 67 | /** 68 | * EXERCÍCIO 1 - SKIP 69 | */ 70 | @Test 71 | public void test1() { 72 | // -- setup -- 73 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5, 6); 74 | 75 | // -- validações do exercício -- 76 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 77 | assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), listaDeNumeros, TESTE_QUEBRADO); 78 | 79 | // -- when -- 80 | 81 | // !!! INÍCIO DA SUA PARTE !!! 82 | 83 | // 1) imprima no console os números 4, 5 e 6 da lista. 84 | // 2) imprima todos na mesma linha usando "System.out.print" 85 | // 3) use streams, skip e forEach. 86 | 87 | // ... seu código ... 88 | 89 | // !!! FIM DA SUA PARTE !!! 90 | 91 | // -- then -- 92 | assertConsoleContains("456"); 93 | } 94 | 95 | /** 96 | * EXERCÍCIO 2 - LIMIT 97 | */ 98 | @Test 99 | public void test2() { 100 | // -- setup -- 101 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5, 6); 102 | 103 | // -- validações do exercício -- 104 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 105 | assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), listaDeNumeros, TESTE_QUEBRADO); 106 | 107 | // -- when -- 108 | 109 | // !!! INÍCIO DA SUA PARTE !!! 110 | 111 | // 1) imprima no console os números 1, 2 e 3 da lista. 112 | // 2) imprima todos na mesma linha usando "System.out.print" 113 | // 3) use streams, limit e forEach. 114 | 115 | // ... seu código ... 116 | 117 | // !!! FIM DA SUA PARTE !!! 118 | 119 | // -- then -- 120 | assertConsoleContains("123"); 121 | } 122 | 123 | /** 124 | * EXERCÍCIO 3 - DISTINCT 125 | */ 126 | @Test 127 | public void test3() { 128 | // -- setup -- 129 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 1, 2, 3); 130 | 131 | // -- validações do exercício -- 132 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 133 | assertEquals(Arrays.asList(1, 2, 3, 1, 2, 3), listaDeNumeros, TESTE_QUEBRADO); 134 | 135 | // -- when -- 136 | 137 | // !!! INÍCIO DA SUA PARTE !!! 138 | 139 | // 1) imprima no console os números 1, 2 e 3 da lista, mas apenas uma vez cada 140 | // 2) imprima todos na mesma linha usando "System.out.print" 141 | // 3) use streams, distinct e forEach. 142 | 143 | // ... seu código ... 144 | 145 | // !!! FIM DA SUA PARTE !!! 146 | 147 | // -- then -- 148 | assertConsoleContains("123"); 149 | } 150 | 151 | /** 152 | * EXERCÍCIO 4 - FILTER 153 | */ 154 | @Test 155 | public void test4() { 156 | // -- setup -- 157 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); 158 | 159 | // -- validações do exercício -- 160 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 161 | assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8), listaDeNumeros, TESTE_QUEBRADO); 162 | 163 | // -- when -- 164 | 165 | // !!! INÍCIO DA SUA PARTE !!! 166 | 167 | // 1) imprima no console os números ímpares da lista 168 | // 2) imprima todos na mesma linha usando "System.out.print" 169 | // 3) use streams, filter e forEach. 170 | 171 | // ... seu código ... 172 | 173 | // !!! FIM DA SUA PARTE !!! 174 | 175 | // -- then -- 176 | assertConsoleContains("1357"); 177 | } 178 | 179 | /** 180 | * EXERCÍCIO 5 - MAP 181 | */ 182 | @Test 183 | public void test5() { 184 | // -- setup -- 185 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5, 6); 186 | 187 | // -- validações do exercício -- 188 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 189 | assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), listaDeNumeros, TESTE_QUEBRADO); 190 | 191 | // -- when -- 192 | 193 | // !!! INÍCIO DA SUA PARTE !!! 194 | 195 | // 1) imprima no console os números da lista multiplicados por 3 196 | // 2) imprima todos na mesma linha usando "System.out.print" 197 | // 3) use streams, map e forEach. 198 | 199 | // ... seu código ... 200 | 201 | // !!! FIM DA SUA PARTE !!! 202 | 203 | // -- then -- 204 | assertConsoleContains("369121518"); 205 | } 206 | 207 | /** 208 | * EXERCÍCIO 6 - SKIP, LIMIT, MAP 209 | */ 210 | @Test 211 | public void test6() { 212 | // -- setup -- 213 | final List listaDeNumeros = Arrays.asList(1, 2, 3, 4, 5, 6); 214 | 215 | // -- validações do exercício -- 216 | assertNotNull(listaDeNumeros, TESTE_QUEBRADO); 217 | assertEquals(Arrays.asList(1, 2, 3, 4, 5, 6), listaDeNumeros, TESTE_QUEBRADO); 218 | 219 | // -- when -- 220 | 221 | // !!! INÍCIO DA SUA PARTE !!! 222 | 223 | // 1) imprima no console os números 3 e 4 da lista, multiplicados por 2 224 | // 2) imprima todos na mesma linha usando "System.out.print" 225 | // 3) use streams, skip, limit, map e forEach. 226 | 227 | // ... seu código ... 228 | 229 | // !!! FIM DA SUA PARTE !!! 230 | 231 | // -- then -- 232 | assertConsoleContains("68"); 233 | } 234 | 235 | } 236 | -------------------------------------------------------------------------------- /src/test/java/dev/rinaldo/test/support/RinaldoDevTest.java: -------------------------------------------------------------------------------- 1 | package dev.rinaldo.test.support; 2 | 3 | import org.junit.jupiter.api.AfterEach; 4 | import org.junit.jupiter.api.BeforeEach; 5 | 6 | import java.io.ByteArrayOutputStream; 7 | import java.io.PrintStream; 8 | 9 | import static org.junit.jupiter.api.Assertions.assertTrue; 10 | 11 | public class RinaldoDevTest { 12 | public static final String TESTE_QUEBRADO = "Você mexeu em algo que não deveria, volte o código do teste ao estado original."; 13 | public static final PrintStream CONSOLE_ORIGINAL = System.out; 14 | public static final ByteArrayOutputStream CONSOLE = new ByteArrayOutputStream(); 15 | 16 | @BeforeEach 17 | public void setup() { 18 | CONSOLE.reset(); 19 | System.setOut(new PrintStream(CONSOLE)); 20 | } 21 | 22 | @AfterEach 23 | public void teardown() { 24 | CONSOLE.reset(); 25 | System.setOut(CONSOLE_ORIGINAL); 26 | } 27 | 28 | public static final void assertConsoleContains(CharSequence texto) { 29 | String s = CONSOLE.toString(); 30 | assertTrue(s.contains(texto), "Não foi impresso no console o texto esperado.\n\nDeveria ser: \n------\n" + texto + "\n------\n\nMas o console tinha: \n------\n" + s + "\n------\n\n"); 31 | } 32 | } 33 | --------------------------------------------------------------------------------