├── .gitignore ├── README.md ├── palestra ├── Capitulo2.java ├── Javaneiros.java ├── TesteJ8.java └── java8.sh ├── pom.xml └── src ├── main └── java │ └── br │ └── com │ └── casadocodigo │ └── java8 │ ├── Capitulo10.java │ ├── Capitulo11.java │ ├── Capitulo12.java │ ├── Capitulo2.java │ ├── Capitulo3.java │ ├── Capitulo4.java │ ├── Capitulo5.java │ ├── Capitulo6.java │ ├── Capitulo7.java │ ├── Capitulo8.java │ ├── Capitulo9.java │ ├── Usuario.java │ └── Validator.java └── test └── java └── br └── com └── casadocodigo └── java8 └── BuscaAlunoTest.java /.gitignore: -------------------------------------------------------------------------------- 1 | *.class 2 | 3 | # Package Files # 4 | *.jar 5 | *.war 6 | *.ear 7 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | java8 2 | ===== 3 | 4 | Se quer executar os testes via maven, você precisa ajustar a variável de ambiente JAVA_HOME_8 para apontar para a home do seu JDK8, ou então remover essa configuração de dentro do pom.xml, no caso de já ser seu default. 5 | 6 | É a base para o novo curso de Java da Caelum: 7 | https://www.caelum.com.br/curso-java-orientacao-objetos 8 | 9 | Assim como a formação de Java da alura: 10 | https://www.alura.com.br/formacao-java 11 | -------------------------------------------------------------------------------- /palestra/Capitulo2.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.util.function.*; 3 | import java.util.stream.*; 4 | 5 | 6 | class Usuario { 7 | private int pontos; 8 | private String nome; 9 | private boolean moderador; 10 | 11 | public Usuario(String nome, int pontos) { 12 | this.pontos = pontos; 13 | this.nome = nome; 14 | } 15 | 16 | public int getPontos() { 17 | return pontos; 18 | } 19 | 20 | public String getNome() { 21 | return nome; 22 | } 23 | 24 | public void tornaModerador() { 25 | this.moderador = true; 26 | } 27 | } 28 | 29 | 30 | public class Capitulo2 { 31 | 32 | public static void main(String ... args) { 33 | 34 | Usuario uu1 = new Usuario("Paulo Silveira", 150); 35 | Usuario uu2 = new Usuario("Rodrigo Turini", 120); 36 | Usuario uu3 = new Usuario("Guilherme Silveira", 190); 37 | 38 | List usuarios = Arrays.asList(uu1, uu2, uu3); 39 | 40 | for(Usuario u : usuarios) { 41 | System.out.println(u.getNome()); 42 | } 43 | 44 | Consumer mostrador = new Consumer() { 45 | public void accept(Usuario p) { 46 | System.out.println(p.getNome()); 47 | } 48 | }; 49 | 50 | usuarios.forEach(mostrador); 51 | 52 | // paulo 1 (falar de defender methods) 53 | usuarios.forEach(new Consumer() { 54 | public void accept(Usuario p) { 55 | System.out.println(p.getNome()); 56 | } 57 | }); 58 | 59 | // paulo 2 60 | usuarios.forEach((Usuario u) -> { System.out.println(u.getNome());}); 61 | 62 | // paulo 3 63 | //Consumer consumidor = (Usuario u) -> { System.out.println(u.getNome());}; 64 | 65 | usuarios.forEach((u) -> { System.out.println(u.getNome());}); 66 | 67 | usuarios.forEach(u -> { System.out.println(u.getNome());}); 68 | 69 | // paulo 4 70 | usuarios.forEach(u -> System.out.println(u.getNome())); 71 | 72 | usuarios.stream().peek(System.out::println); 73 | 74 | 75 | // somar numero de posts dos usuarios 76 | 77 | // com lambda, posso usar o mapToInt e chamar o sum 78 | 79 | // rodrigo 1 (Falar do streamificacao da api) 80 | usuarios.stream().mapToInt(u -> u.getPontos()).sum(); 81 | 82 | Stream nomes = usuarios.stream().map(Usuario::getNome); 83 | 84 | // a mesma coisa só que com method reference 85 | // rodrigo 2, falar do method reference 86 | int soma = usuarios.stream().mapToInt(Usuario::getPontos).sum(); 87 | 88 | System.out.println("soma dos pontos: "+ soma); 89 | 90 | 91 | // todos que tem mais de 50 posts, favoritar! 92 | // rodrigo 3, falando que stream tem muitos outros metodos! 93 | Stream stream = usuarios.stream().filter( 94 | new Predicate() { 95 | public boolean test(Usuario p) { 96 | return p.getPontos() > 50; 97 | } 98 | } 99 | ); 100 | 101 | // rodrigo4: problema, eu nao queria Stream! eu queria List! 102 | 103 | List filtrados = usuarios.stream().filter( 104 | new Predicate() { 105 | public boolean test(Usuario p) { 106 | return p.getPontos() > 50; 107 | } 108 | } 109 | ).collect(Collectors.toList()); 110 | 111 | // rodrigo 5: explicar que .stream e .collect sao complementares, a ida e a volta! 112 | // rodrigo 6: com lambda: 113 | List filtrados2 = usuarios.stream().filter(p -> p.getPontos() > 50).collect(Collectors.toList()); 114 | 115 | usuarios.stream().filter(p -> p.getPontos() > 50).forEach(p -> p.tornaModerador()); 116 | 117 | // rodrigo 7: abusando do method reference 118 | usuarios.stream().filter(p -> p.getPontos() > 50).forEach(Usuario::tornaModerador); 119 | 120 | usuarios.stream().filter(p -> p.getPontos() > 50).forEach(System.out::println); 121 | 122 | // usando o peek 123 | usuarios.stream().filter(p -> p.getPontos() > 50).peek(Usuario::tornaModerador).forEach(System.out::println); 124 | 125 | // ordenar os Usuarios por post (numero de pontos) 126 | 127 | // usando o sort (da propria lista de usuarios) com lambda 128 | 129 | usuarios.sort((Usuario o1, Usuario o2) -> (o1.getPontos() - o2.getPontos())); 130 | 131 | // usando o sort com lambda sem informação do tipo Usuario 132 | 133 | usuarios.sort( (o1, o2) -> (o1.getPontos() - o2.getPontos())); 134 | 135 | // usando o sorted do Stream.. a diferença é que esse cara é lazy, ou 136 | // seja retorna um Stream que contem a lista ordenada 137 | 138 | 139 | usuarios.sort((u1, u2) -> u1.getNome().compareTo(u2.getNome())); 140 | 141 | usuarios.stream().sorted( (o1, o2) -> (o1.getPontos() - o2.getPontos())); 142 | 143 | 144 | Collections.sort(usuarios, 145 | (u1, u2) -> u1.getNome().compareTo(u2.getNome())); 146 | 147 | 148 | Comparator comparator = 149 | Comparator.comparing(u -> u.getNome()); 150 | 151 | usuarios.sort(Comparator.comparing(u -> u.getPontos())); 152 | 153 | 154 | Function extraiNome = u -> u.getNome(); 155 | Comparator comparator2 = 156 | Comparator.comparing(extraiNome); 157 | 158 | usuarios.sort(comparator2); 159 | 160 | // É meio obvio, mas acho valido falar que podemos escrever 161 | // o compareTo no usuario e usar method reference, algo como: 162 | // usuarios.sort(Usuario::compareTo) ... fica bem mais simples 163 | 164 | // só um sout pra mostrar que deu certo 165 | usuarios.forEach(u -> System.out.println("Usuario "+ u.getNome() 166 | + " tem " +u.getPontos() + " Pontos" )); 167 | 168 | } 169 | 170 | 171 | } 172 | -------------------------------------------------------------------------------- /palestra/Javaneiros.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.util.function.*; 3 | import java.util.stream.*; 4 | 5 | class Usuario { 6 | private int pontos; 7 | private String nome; 8 | private boolean favorito; 9 | 10 | public Usuario(String nome, int pontos) { 11 | this.pontos = pontos; 12 | this.nome = nome; 13 | } 14 | 15 | public int getPontos() { 16 | return pontos; 17 | } 18 | 19 | public String getNome() { 20 | return nome; 21 | } 22 | 23 | public void favoritar() { 24 | this.favorito = true; 25 | } 26 | } 27 | 28 | public class Javaneiros { 29 | 30 | 31 | public static void main(String ... args) { 32 | 33 | Usuario p1 = new Usuario("Paulo Silveira", 150); 34 | Usuario p2 = new Usuario("Gilliard Cordeiro", 120); 35 | Usuario p3 = new Usuario("Giovanni Bassi", 350); 36 | 37 | 38 | List x = Arrays.asList(p1, p2, p3); 39 | 40 | // foreach de usuarios com Consumer e Accept 41 | 42 | 43 | 44 | 45 | x.forEach((Usuario u) -> {System.out.println(u.getNome());}); 46 | 47 | 48 | // lambda e transformacao do Consumer 49 | 50 | x.forEach(System.out::println); 51 | 52 | // Extension/Virtual Methods 53 | 54 | // lambda sem tipo, parenteses 55 | 56 | 57 | // Runnable! 58 | 59 | new Thread(() -> {}).start(); 60 | 61 | new Thread(new Runnable() { 62 | public void run() { 63 | 64 | } 65 | }).start(); 66 | 67 | 68 | // mapear para nomes dos usuarios. streamificacao 69 | 70 | Stream x2= x.stream().map(u -> u.getNome()); 71 | 72 | 73 | // method reference pro getNome 74 | 75 | 76 | Stream x3= x.stream().map(Usuario::getNome); 77 | 78 | // methos reference pro Sysout. 79 | 80 | // total de pontos por usuario 81 | 82 | 83 | // usuarios com mais de 50 pontos. filter, predicate e test 84 | // devolvendo Stream 85 | 86 | List ll = x.stream().filter(u -> u.getPontos() > 50). 87 | collect(Collectors.toList()); 88 | 89 | 90 | // collect e Collectos toList 91 | 92 | // favoritando todos os usuarios com mais de 50 pontos 93 | 94 | 95 | x.stream().filter(u -> u.getPontos() > 300). 96 | peek(Usuario::favoritar).forEach( 97 | u -> System.out.println(u.getNome())); 98 | 99 | 100 | 101 | // ordenando uma lista 20 anos depois do Java 1. 102 | 103 | x.sort(Comparators.comparing(Usuario::getPontos)); 104 | 105 | 106 | 107 | 108 | } 109 | } 110 | -------------------------------------------------------------------------------- /palestra/TesteJ8.java: -------------------------------------------------------------------------------- 1 | import java.util.*; 2 | import java.util.function.*; 3 | import java.util.stream.*; 4 | 5 | class Usuario { 6 | private int pontos; 7 | private String nome; 8 | private boolean moderador; 9 | 10 | public Usuario(String nome, int pontos) { 11 | this.pontos = pontos; 12 | this.nome = nome; 13 | } 14 | 15 | public int getPontos() { 16 | return pontos; 17 | } 18 | 19 | public String getNome() { 20 | return nome; 21 | } 22 | 23 | public void tornaModerador() { 24 | this.moderador = true; 25 | } 26 | } 27 | 28 | public class Capitulo2 { 29 | public static void main(String ... args) { 30 | Usuario u1 = new Usuario("Paulo Silveira", 150); 31 | Usuario u2 = new Usuario("Rodrigo Turini", 120); 32 | Usuario u3 = new Usuario("Guilherme Silveira", 190); 33 | 34 | List usuarios = Arrays.asList(u1, u2, u3); 35 | 36 | for(Usuario u : usuarios) { 37 | System.out.println(u.getNome()); 38 | } 39 | 40 | // Consumer c = Usuario::new; 41 | 42 | usuarios.forEach(System.out::println); 43 | 44 | int soma = usuarios.stream().mapToInt(Usuario::getPontos).sum(); 45 | 46 | System.out.println("soma" +soma); 47 | 48 | 49 | // favoritar quem tem mais de 50 pontos: 50 | 51 | usuarios.stream().filter(u -> u.getPontos() > 50) 52 | .forEach(Usuario::favoritar); 53 | 54 | 55 | // comparator! 56 | 57 | usuarios.sort(Usuario::compareUsandoPontos); 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | } 74 | 75 | 76 | } 77 | -------------------------------------------------------------------------------- /palestra/java8.sh: -------------------------------------------------------------------------------- 1 | export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0.jdk/Contents/Home 2 | export PATH=${JAVA_HOME}/bin:${PATH} 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /pom.xml: -------------------------------------------------------------------------------- 1 | 3 | 4.0.0 4 | 5 | br.com.casadocodigo 6 | java8 7 | 1.0-SNAPSHOT 8 | jar 9 | 10 | Projeto do Livro de Java 8 da Casa do Código 11 | http://www.casadocodigo.com.br 12 | 13 | 14 | UTF-8 15 | 16 | 17 | 18 | 19 | 20 | org.apache.maven.plugins 21 | maven-compiler-plugin 22 | 23 | ${JAVA_HOME_8}/bin/javac 24 | true 25 | true 26 | 1.8 27 | 1.8 28 | 1.8 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | junit 38 | junit 39 | 4.8.1 40 | test 41 | 42 | 43 | com.google.guava 44 | guava 45 | 13.0 46 | compile 47 | 48 | 49 | 50 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo10.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.text.SimpleDateFormat; 4 | import java.time.Duration; 5 | import java.time.LocalDate; 6 | import java.time.LocalDateTime; 7 | import java.time.LocalTime; 8 | import java.time.Month; 9 | import java.time.MonthDay; 10 | import java.time.Period; 11 | import java.time.ZoneId; 12 | import java.time.ZonedDateTime; 13 | import java.time.format.DateTimeFormatter; 14 | import java.time.format.TextStyle; 15 | import java.time.temporal.ChronoUnit; 16 | import java.util.Calendar; 17 | import java.util.Locale; 18 | 19 | public class Capitulo10 { 20 | 21 | public static void main(String[] args) { 22 | 23 | // incrementando um mês com Calendar 24 | Calendar mesQueVem = Calendar.getInstance(); 25 | mesQueVem.add(Calendar.MONTH, 1); 26 | 27 | // incrementando um mês com LocalDate 28 | LocalDate mesQueVem2 = LocalDate.now().plusMonths(1); 29 | 30 | // decrementando um mês com LocalDate 31 | LocalDate anoPassado = LocalDate.now().minusYears(1); 32 | 33 | // LocalDateTime 34 | 35 | LocalDateTime agora = LocalDateTime.now(); 36 | System.out.println(agora); 37 | 38 | // construindo um LocalDateTime a partir de um LocalDate 39 | LocalDateTime hojeAoMeioDia = LocalDate.now().atTime(12,0); 40 | 41 | // construindo um LocalDateTime pela junção de um LocalDate com LocalTime 42 | 43 | LocalTime agora3 = LocalTime.now(); 44 | LocalDate hoje = LocalDate.now(); 45 | LocalDateTime dataEhora = hoje.atTime(agora3); 46 | 47 | // adicionando informação de timezone para ter um ZonedDateTime. 48 | ZonedDateTime dataComHoraETimezone = 49 | dataEhora.atZone(ZoneId.of("America/Sao_Paulo")); 50 | 51 | // de ZonedDateTime para LocalDateTime 52 | 53 | LocalDateTime semTimeZone = dataComHoraETimezone.toLocalDateTime(); 54 | 55 | // criando a partir do factory method *of* 56 | 57 | LocalDate date = LocalDate.of(2014, 12, 25); 58 | LocalDateTime dateTime = LocalDateTime.of(2014, 12, 25, 10, 30); 59 | 60 | // utilizando métodos *with* para adicionar valores 61 | 62 | LocalDate dataDoPassado = LocalDate.now().withYear(1988); 63 | 64 | System.out.println(dataDoPassado.getYear()); 65 | 66 | // comparações entre datas com os métodos *is* 67 | 68 | LocalDate amanha = LocalDate.now().plusDays(1); 69 | 70 | System.out.println(hoje.isBefore(amanha)); 71 | System.out.println(hoje.isAfter(amanha)); 72 | System.out.println(hoje.isEqual(amanha)); 73 | 74 | // dia do mês atual a partir do MonthDay 75 | 76 | System.out.println("hoje é dia: "+ MonthDay.now().getDayOfMonth()); 77 | 78 | // enum Month 79 | 80 | System.out.println(LocalDate.of(2014, 12, 25)); 81 | System.out.println(LocalDate.of(2014, Month.DECEMBER, 25)); 82 | 83 | System.out.println(Month.DECEMBER.firstMonthOfQuarter()); 84 | System.out.println(Month.DECEMBER.plus(2)); 85 | System.out.println(Month.DECEMBER.minus(1)); 86 | 87 | // formatando e exibindo os modelos de data 88 | 89 | Locale pt = new Locale("pt"); 90 | 91 | System.out.println(Month.DECEMBER 92 | .getDisplayName(TextStyle.FULL, pt)); 93 | 94 | System.out.println(Month.DECEMBER 95 | .getDisplayName(TextStyle.SHORT, pt)); 96 | 97 | String resultado = agora.format(DateTimeFormatter.ISO_LOCAL_TIME); 98 | 99 | agora.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")); 100 | 101 | // parseando de String para LocalDate 102 | 103 | DateTimeFormatter formatador = DateTimeFormatter.ofPattern("dd/MM/yyyy"); 104 | String resultado2 = agora.format(formatador); 105 | LocalDate agoraEmData = LocalDate.parse(resultado2, formatador); 106 | 107 | // formatando com Calendar 108 | 109 | Calendar instante = Calendar.getInstance(); 110 | instante.set(2014, Calendar.FEBRUARY, 30); 111 | SimpleDateFormat dateFormat = new SimpleDateFormat("dd/MM/yy"); 112 | System.out.println(dateFormat.format(instante.getTime())); 113 | 114 | // data e hora inválida 115 | 116 | LocalDate.of(2014, Month.FEBRUARY, 30); 117 | 118 | LocalDateTime horaInvalida = LocalDate.now().atTime(25, 0); 119 | 120 | // diferença de dias com Calendar 121 | 122 | Calendar calendar = Calendar.getInstance(); 123 | 124 | Calendar outraData = Calendar.getInstance(); 125 | outraData.set(1988, Calendar.JANUARY, 25); 126 | 127 | long diferenca = calendar.getTimeInMillis() - outraData.getTimeInMillis(); 128 | 129 | long milissegundosDeUmDia = 1000 * 60 * 60 * 24; 130 | 131 | long dias = diferenca / milissegundosDeUmDia; 132 | 133 | // diferença de dias com ChronoUnit 134 | 135 | LocalDate agora4 = LocalDate.now(); 136 | LocalDate outraData2 = LocalDate.of(1989, Month.JANUARY, 25); 137 | long dias2 = ChronoUnit.DAYS.between(outraData2, agora4); 138 | 139 | // diferença de meses e anos 140 | 141 | long meses = ChronoUnit.MONTHS.between(outraData2, agora4); 142 | long anos = ChronoUnit.YEARS.between(outraData2, agora4); 143 | System.out.printf("%s dias, %s meses e %s anos", dias2, meses, anos); 144 | 145 | // periodo entre duas datas 146 | 147 | LocalDate outraData3 = LocalDate.of(1989, Month.JANUARY, 25); 148 | Period periodo = Period.between(outraData3, agora4); 149 | System.out.printf("%s dias, %s meses e %s anos", 150 | periodo.getDays(), periodo.getMonths(), periodo.getYears()); 151 | 152 | // invertendo valores do periodo 153 | 154 | Period periodo2 = Period.between(outraData3, agora4); 155 | 156 | if (periodo2.isNegative()) periodo2 = periodo2.negated(); 157 | 158 | System.out.printf("%s dias, %s meses e %s anos", 159 | periodo2.getDays(), periodo2.getMonths(), periodo2.getYears()); 160 | 161 | // o mesmo, só que agora trabalhando com duração 162 | 163 | LocalDateTime agora5 = LocalDateTime.now(); 164 | LocalDateTime daquiAUmaHora = agora5.plusHours(1); 165 | Duration duration = Duration.between(agora5, daquiAUmaHora); 166 | 167 | if (duration.isNegative()) duration = duration.negated(); 168 | 169 | System.out.printf("%s horas, %s minutos e %s segundos", 170 | duration.toHours(), duration.toMinutes(), duration.getSeconds()); 171 | 172 | } 173 | } 174 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo11.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import static java.util.Arrays.asList; 4 | 5 | import java.math.BigDecimal; 6 | import java.nio.file.Path; 7 | import java.nio.file.Paths; 8 | import java.time.LocalDateTime; 9 | import java.time.temporal.ChronoUnit; 10 | import java.time.format.DateTimeFormatter; 11 | import java.time.YearMonth; 12 | import java.util.ArrayList; 13 | import java.util.Arrays; 14 | import java.util.Collections; 15 | import java.util.Comparator; 16 | import java.util.List; 17 | import java.util.Map; 18 | import java.util.Optional; 19 | import java.util.function.Function; 20 | import java.util.stream.Collectors; 21 | import java.util.stream.Stream; 22 | import java.util.function.Function; 23 | 24 | class Product { 25 | private String name; 26 | private Path file; 27 | private BigDecimal price; 28 | 29 | public Product(String name, Path file, BigDecimal price) { 30 | this.name = name; 31 | this.file = file; 32 | this.price = price; 33 | } 34 | 35 | public String getName() { 36 | return this.name; 37 | } 38 | 39 | public Path getFile() { 40 | return this.file; 41 | } 42 | 43 | public BigDecimal getPrice() { 44 | return this.price; 45 | } 46 | 47 | public String toString() { 48 | return this.name; 49 | } 50 | } 51 | 52 | class Customer { 53 | private String name; 54 | 55 | public Customer(String name) { 56 | this.name = name; 57 | } 58 | 59 | public String getName() { 60 | return this.name; 61 | } 62 | 63 | public String toString() { 64 | return this.name; 65 | } 66 | } 67 | 68 | class Payment { 69 | private List products; 70 | private LocalDateTime date; 71 | private Customer customer; 72 | 73 | public Payment(List products, 74 | LocalDateTime date, 75 | Customer customer) { 76 | this.products = 77 | Collections.unmodifiableList(products); 78 | this.date = date; 79 | this.customer = customer; 80 | } 81 | 82 | public List getProducts() { 83 | return this.products; 84 | } 85 | 86 | public LocalDateTime getDate() { 87 | return this.date; 88 | } 89 | 90 | public Customer getCustomer() { 91 | return this.customer; 92 | } 93 | 94 | public String toString() { 95 | return "[Payment: " + 96 | date.format(DateTimeFormatter.ofPattern("dd/MM/yyyy")) + 97 | " " + customer + " " + products + "]"; 98 | } 99 | } 100 | 101 | class Subscription { 102 | private BigDecimal monthlyFee; 103 | private LocalDateTime begin; 104 | private Optional end; 105 | private Customer customer; 106 | 107 | public Subscription(BigDecimal monthlyFee, LocalDateTime begin, 108 | Customer customer) { 109 | this.monthlyFee = monthlyFee; 110 | this.begin = begin; 111 | this.end = Optional.empty(); 112 | this.customer = customer; 113 | } 114 | 115 | public Subscription(BigDecimal monthlyFee, LocalDateTime begin, 116 | LocalDateTime end, Customer customer) { 117 | this.monthlyFee = monthlyFee; 118 | this.begin = begin; 119 | this.end = Optional.of(end); 120 | this.customer = customer; 121 | } 122 | 123 | public BigDecimal getMonthlyFee() { 124 | return monthlyFee; 125 | } 126 | 127 | public LocalDateTime getBegin() { 128 | return begin; 129 | } 130 | 131 | public Optional getEnd() { 132 | return end; 133 | } 134 | 135 | public Customer getCustomer() { 136 | return customer; 137 | } 138 | 139 | public BigDecimal getTotalPaid() { 140 | return getMonthlyFee() 141 | .multiply(new BigDecimal(ChronoUnit.MONTHS 142 | .between(getBegin(), 143 | getEnd().orElse(LocalDateTime.now())))); 144 | } 145 | } 146 | 147 | 148 | public class Capitulo11 { 149 | 150 | public static void main (String... args) throws Exception { 151 | 152 | Customer paulo = new Customer("Paulo Silveira"); 153 | Customer rodrigo = new Customer("Rodrigo Turini"); 154 | Customer guilherme = new Customer("Guilherme Silveira"); 155 | Customer adriano = new Customer("Adriano Almeida"); 156 | 157 | Product bach = new Product("Bach Completo", 158 | Paths.get("/music/bach.mp3"), new BigDecimal(100)); 159 | Product poderosas = new Product("Poderosas Anita", 160 | Paths.get("/music/poderosas.mp3"), new BigDecimal(90)); 161 | Product bandeira = new Product("Bandeira Brasil", 162 | Paths.get("/images/brasil.jpg"), new BigDecimal(50)); 163 | Product beauty = new Product("Beleza Americana", 164 | Paths.get("beauty.mov"), new BigDecimal(150)); 165 | Product vingadores = new Product("Os Vingadores", 166 | Paths.get("/movies/vingadores.mov"), new BigDecimal(200)); 167 | Product amelie = new Product("Amelie Poulain", 168 | Paths.get("/movies/amelie.mov"), new BigDecimal(100)); 169 | 170 | LocalDateTime today = LocalDateTime.now(); 171 | LocalDateTime yesterday = today.minusDays(1); 172 | LocalDateTime lastMonth = today.minusMonths(1); 173 | 174 | Payment payment1 = 175 | new Payment(asList(bach, poderosas), today, paulo); 176 | Payment payment2 = 177 | new Payment(asList(bach, bandeira, amelie), yesterday, rodrigo); 178 | Payment payment3 = 179 | new Payment(asList(beauty, vingadores, bach), today, adriano); 180 | Payment payment4 = 181 | new Payment(asList(bach, poderosas, amelie), lastMonth, guilherme); 182 | Payment payment5 = 183 | new Payment(asList(beauty, amelie), yesterday, paulo); 184 | 185 | List payments = asList(payment1, payment2, 186 | payment3, payment4, payment5); 187 | 188 | // ordenar List por data 189 | 190 | payments.stream() 191 | .sorted(Comparator.comparing(Payment::getDate)) 192 | .forEach(System.out::println); 193 | 194 | // somatoria dos valores de payment1: 195 | 196 | BigDecimal p1total = 197 | payment1.getProducts().stream() 198 | .map(Product::getPrice) 199 | .reduce(BigDecimal.ZERO, (total, price) -> total.add(price)); 200 | 201 | payment1.getProducts().stream() 202 | .map(Product::getPrice) 203 | .reduce(BigDecimal::add) 204 | .ifPresent(System.out::println); 205 | 206 | // somatoria de todos os payments 207 | 208 | Stream pricesStream = 209 | payments.stream() 210 | .map(p -> p.getProducts().stream() 211 | .map(Product::getPrice) 212 | .reduce(BigDecimal.ZERO, BigDecimal::add)); 213 | 214 | 215 | BigDecimal total = 216 | payments.stream() 217 | .map(p -> p.getProducts().stream() 218 | .map(Product::getPrice) 219 | .reduce(BigDecimal.ZERO, BigDecimal::add)) 220 | .reduce(BigDecimal.ZERO, BigDecimal::add); 221 | 222 | Stream priceOfEachProduct = 223 | payments.stream() 224 | .flatMap(p -> p.getProducts().stream().map(Product::getPrice)); 225 | 226 | Function> mapper = 227 | p -> p.getProducts().stream().map(Product::getPrice); 228 | 229 | 230 | BigDecimal totalFlat = 231 | payments.stream() 232 | .flatMap(p -> p.getProducts().stream().map(Product::getPrice)) 233 | .reduce(BigDecimal.ZERO, BigDecimal::add); 234 | 235 | // qual é o produto mais vendido? 236 | 237 | Stream products = payments.stream() 238 | .flatMap(p -> p.getProducts().stream()); 239 | 240 | 241 | Map topProducts = payments.stream() 242 | .flatMap(p -> p.getProducts().stream()) 243 | .collect(Collectors.groupingBy(Function.identity(), 244 | Collectors.counting())); 245 | 246 | 247 | System.out.println(topProducts); 248 | 249 | 250 | 251 | 252 | topProducts.entrySet().stream() 253 | .forEach(System.out::println); 254 | 255 | topProducts.entrySet().stream() 256 | .max(Comparator.comparing(Map.Entry::getValue)) 257 | .ifPresent(System.out::println); 258 | 259 | 260 | // quero map 261 | 262 | Map totalValuePerProduct = payments.stream() 263 | .flatMap(p -> p.getProducts().stream()) 264 | .collect(Collectors.groupingBy(Function.identity(), 265 | Collectors.reducing(BigDecimal.ZERO, Product::getPrice, BigDecimal::add))); 266 | 267 | totalValuePerProduct.entrySet().stream() 268 | .sorted(Comparator.comparing(Map.Entry::getValue)) 269 | .forEach(System.out::println); 270 | 271 | 272 | Map totalValuePerProduct2 = payments.stream() 273 | .flatMap(p -> p.getProducts().stream()) 274 | .collect(Collectors.toMap(Function.identity(), 275 | Product::getPrice, 276 | BigDecimal::add)); 277 | 278 | totalValuePerProduct2.entrySet().stream() 279 | .sorted(Comparator.comparing(Map.Entry::getValue)) 280 | .forEach(System.out::println); 281 | 282 | // usuário para lista de payment 283 | Map> customerToPayments = 284 | payments.stream() 285 | .collect(Collectors.groupingBy(Payment::getCustomer)); 286 | 287 | Map>> customerToProductsList = payments.stream() 288 | .collect(Collectors.groupingBy(Payment::getCustomer, 289 | Collectors.mapping(Payment::getProducts, Collectors.toList()))); 290 | 291 | customerToProductsList.entrySet().stream() 292 | .sorted(Comparator.comparing(e -> e.getKey().getName())) 293 | .forEach(System.out::println); 294 | 295 | 296 | System.out.println(); 297 | 298 | // transformando List> em List quando value de map: 299 | Map> customerToProducts2steps = 300 | customerToProductsList.entrySet().stream() 301 | .collect(Collectors.toMap(Map.Entry::getKey, 302 | e -> e.getValue().stream() 303 | .flatMap(List::stream) 304 | .collect(Collectors.toList()))); 305 | 306 | customerToProducts2steps.entrySet().stream() 307 | .sorted(Comparator.comparing(e -> e.getKey().getName())) 308 | .forEach(System.out::println); 309 | 310 | System.out.println(); 311 | 312 | Map> customerToProducts1step = payments.stream() 313 | .collect(Collectors.groupingBy(Payment::getCustomer, 314 | Collectors.mapping(Payment::getProducts, Collectors.toList()))) 315 | .entrySet().stream() 316 | .collect(Collectors.toMap(Map.Entry::getKey, 317 | e -> e.getValue().stream() 318 | .flatMap(List::stream) 319 | .collect(Collectors.toList()))); 320 | 321 | // usando reducao 322 | Map> customerToProducts = payments.stream() 323 | .collect(Collectors.groupingBy(Payment::getCustomer, 324 | Collectors.reducing(Collections.emptyList(), 325 | Payment::getProducts, 326 | (l1, l2) -> { List l = new ArrayList<>(); 327 | l.addAll(l1); 328 | l.addAll(l2); 329 | return l;} ))); 330 | 331 | customerToProducts.entrySet().stream() 332 | .sorted(Comparator.comparing(e -> e.getKey().getName())) 333 | .forEach(System.out::println); 334 | 335 | 336 | // qual é o usuario que mais pagou 337 | 338 | Map totalValuePerCustomer = payments.stream() 339 | .collect(Collectors.groupingBy(Payment::getCustomer, 340 | Collectors.reducing(BigDecimal.ZERO, 341 | p -> p.getProducts().stream().map(Product::getPrice).reduce(BigDecimal.ZERO, BigDecimal::add), 342 | BigDecimal::add))); 343 | 344 | totalValuePerCustomer.entrySet().stream() 345 | .sorted(Comparator.comparing(Map.Entry::getValue)) 346 | .forEach(System.out::println); 347 | 348 | Function paymentToTotal = 349 | p -> p.getProducts().stream() 350 | .map(Product::getPrice) 351 | .reduce(BigDecimal.ZERO, BigDecimal::add); 352 | 353 | Map totalValuePerCustomer2 = payments.stream() 354 | .collect(Collectors.groupingBy(Payment::getCustomer, 355 | Collectors.reducing(BigDecimal.ZERO, 356 | paymentToTotal, 357 | BigDecimal::add))); 358 | 359 | 360 | 361 | // quero map> agrupar por mes as vendas 362 | Map> paymentsPerMonth = payments.stream() 363 | .collect(Collectors.groupingBy(p -> YearMonth.from(p.getDate()))); 364 | 365 | paymentsPerMonth.entrySet().stream() 366 | .forEach(System.out::println); 367 | 368 | // quero map total recebido por mes 369 | Map paymentsValuePerMonth = payments.stream() 370 | .collect(Collectors.groupingBy(p -> YearMonth.from(p.getDate()), 371 | Collectors.reducing(BigDecimal.ZERO, 372 | p -> p.getProducts().stream() 373 | .map(Product::getPrice) 374 | .reduce(BigDecimal.ZERO, 375 | BigDecimal::add), 376 | BigDecimal::add))); 377 | 378 | 379 | paymentsValuePerMonth.entrySet().stream() 380 | .forEach(System.out::println); 381 | 382 | 383 | 384 | 385 | // subscriptions 386 | 387 | BigDecimal monthlyFee = new BigDecimal("99.90"); 388 | 389 | Subscription s1 = new Subscription(monthlyFee, 390 | yesterday.minusMonths(5), paulo); 391 | 392 | Subscription s2 = new Subscription(monthlyFee, 393 | yesterday.minusMonths(8), today.minusMonths(1), rodrigo); 394 | 395 | Subscription s3 = new Subscription(monthlyFee, 396 | yesterday.minusMonths(5), today.minusMonths(2), adriano); 397 | 398 | List subscriptions = Arrays.asList(s1, s2, s3); 399 | 400 | // numero de meses pago 401 | System.out.println(ChronoUnit.MONTHS.between( 402 | s1.getBegin(), LocalDateTime.now())); 403 | 404 | System.out.println(ChronoUnit.MONTHS.between( 405 | s1.getBegin(), s1.getEnd().orElse(LocalDateTime.now()))); 406 | 407 | // dada uma unica subscription, calcular quanto ele pagou ate hoje 408 | System.out.println(s1.getMonthlyFee() 409 | .multiply(new BigDecimal(ChronoUnit.MONTHS.between( 410 | s1.getBegin(), s1.getEnd().orElse(LocalDateTime.now()))))); 411 | 412 | 413 | // dada uma colecao de subscription, calcular quanto todos pagaram ate hoje 414 | 415 | BigDecimal totalPaid = subscriptions.stream() 416 | .map(Subscription::getTotalPaid) 417 | .reduce(BigDecimal.ZERO, BigDecimal::add); 418 | System.out.println(totalPaid); 419 | 420 | // EXERCICIOS 421 | 422 | // achar o usuario que mais pagou total de valor de subscriptions ate hoje 423 | 424 | // achar o usuario que ficou mais meses pagando (independente dela estar ativa ou nao) 425 | 426 | // quero map, qual é o tipo de produto que ele mais comprou 427 | 428 | // que tipo de produto é o mais vendido (sum(VIDEO), sum(AUDIO)) 429 | 430 | // Dado um %%Payment%%, gere a lista de %%Paths%% dos arquivos digitais comprados. 431 | } 432 | } 433 | 434 | // para exercicios 435 | 436 | enum Type { 437 | MUSIC, 438 | VIDEO, 439 | IMAGE; 440 | } 441 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo12.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import static java.util.Comparator.comparing; 4 | 5 | import java.util.Arrays; 6 | import java.util.Comparator; 7 | import java.util.List; 8 | import java.util.function.BiFunction; 9 | import java.util.function.Consumer; 10 | import java.util.function.Function; 11 | 12 | class Capitulo12 { 13 | 14 | public static void main(String[] args) { 15 | 16 | Usuario u1 = new Usuario("Paulo Silveira", 150); 17 | Usuario u2 = new Usuario("Rodrigo Turini", 120); 18 | Usuario u3 = new Usuario("Guilherme Silveira", 190); 19 | 20 | List usuarios = Arrays.asList(u1, u2, u3); 21 | 22 | // limitacoes da inferencia 23 | 24 | // necessidade de tipagem para inferencia correta: 25 | usuarios.sort(Comparator.comparingInt((Usuario u) -> u.getPontos()) 26 | .thenComparing(u -> u.getNome())); 27 | 28 | usuarios.sort(Comparator.comparing(u -> u.getPontos()).reversed()); 29 | 30 | 31 | 32 | } 33 | } -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo2.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.function.Consumer; 6 | 7 | public class Capitulo2 { 8 | 9 | public static void main(String... args) { 10 | 11 | Usuario u1 = new Usuario("Paulo Silveira", 150); 12 | Usuario u2 = new Usuario("Rodrigo Turini", 120); 13 | Usuario u3 = new Usuario("Guilherme Silveira", 190); 14 | 15 | List usuarios = Arrays.asList(u1, u2, u3); 16 | 17 | for (Usuario u : usuarios) { 18 | System.out.println(u.getNome()); 19 | } 20 | 21 | usuarios.forEach(new Consumer() { 22 | public void accept(Usuario p) { 23 | System.out.println(p.getNome()); 24 | } 25 | }); 26 | 27 | usuarios.forEach(u -> System.out.println(u.getNome())); 28 | 29 | usuarios.forEach(u -> u.tornaModerador()); 30 | 31 | } 32 | } -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo3.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | class Capitulo3 { 4 | 5 | public static void main(String[] args) { 6 | 7 | Runnable r1 = new Runnable(){ 8 | public void run(){ 9 | for (int i = 0; i <= 1000; i++) { 10 | System.out.println(i); 11 | } 12 | } 13 | }; 14 | new Thread(r1).start(); 15 | 16 | Runnable r2 = () -> { 17 | for (int i = 0; i <= 1000; i++) { 18 | System.out.println(i); 19 | } 20 | }; 21 | new Thread(r2).start(); 22 | 23 | new Thread(() -> { 24 | for (int i = 0; i <= 1000; i++) { 25 | System.out.println(i); 26 | } 27 | }).start(); 28 | 29 | Validador validadorCEP = new Validador() { 30 | public boolean valida(String valor) { 31 | return valor.matches("[0-9]{5}-[0-9]{3}"); 32 | } 33 | }; 34 | 35 | Validador validadorCEPComLambda = 36 | valor -> valor.matches("[0-9]{5}-[0-9]{3}"); 37 | 38 | Runnable o = () -> { 39 | System.out.println("O que sou eu? Que lambda?"); 40 | }; 41 | 42 | System.out.println(o); 43 | System.out.println(o.getClass()); 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo4.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.Arrays; 4 | import java.util.List; 5 | import java.util.ArrayList; 6 | import java.util.function.Consumer; 7 | import java.util.function.Predicate; 8 | 9 | public class Capitulo4 { 10 | 11 | public static void main(String... args) { 12 | 13 | Usuario u1 = new Usuario("Paulo Silveira", 150); 14 | Usuario u2 = new Usuario("Rodrigo Turini", 120); 15 | Usuario u3 = new Usuario("Guilherme Silveira", 190); 16 | 17 | List usuarios = Arrays.asList(u1, u2, u3); 18 | 19 | Consumer mostraMensagem = u -> 20 | System.out.println("antes de imprimir os nomes"); 21 | 22 | Consumer imprimeNome = u -> 23 | System.out.println(u.getNome()); 24 | 25 | usuarios.forEach(mostraMensagem.andThen(imprimeNome)); 26 | 27 | List usuarios2 = new ArrayList<>(); 28 | usuarios2.addAll(usuarios); 29 | 30 | Predicate predicado = new Predicate() { 31 | public boolean test(Usuario u) { 32 | return u.getPontos() > 160; 33 | } 34 | }; 35 | 36 | usuarios2.removeIf(predicado); 37 | usuarios2.forEach(u -> System.out.println(u)); 38 | 39 | usuarios2.removeIf(u -> u.getPontos() > 160); 40 | } 41 | } -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo5.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.Arrays; 4 | import java.util.Collections; 5 | import java.util.Comparator; 6 | import java.util.List; 7 | import java.util.function.*; 8 | 9 | class Capitulo5 { 10 | 11 | public static void main(String[] args) { 12 | 13 | Usuario user1 = new Usuario("Paulo Silveira", 150); 14 | Usuario user2 = new Usuario("Rodrigo Turini", 120); 15 | Usuario user3 = new Usuario("Guilherme Silveira", 190); 16 | 17 | List usuarios = Arrays.asList(user1, user2, user3); 18 | 19 | Comparator comparator = new Comparator() { 20 | public int compare(Usuario u1, Usuario u2) { 21 | return u1.getNome().compareTo(u2.getNome()); 22 | } 23 | }; 24 | 25 | Collections.sort(usuarios, comparator); 26 | 27 | usuarios.sort(comparator); 28 | 29 | Comparator comparatorComLambda = 30 | (u1, u2) -> u1.getNome().compareTo(u2.getNome()); 31 | 32 | Collections.sort(usuarios, comparator); 33 | 34 | Collections.sort(usuarios, 35 | (u1, u2) -> u1.getNome().compareTo(u2.getNome())); 36 | 37 | usuarios.sort((u1, u2) -> u1.getNome().compareTo(u2.getNome())); 38 | 39 | 40 | usuarios.sort(Comparator.comparing(u -> u.getNome())); 41 | 42 | usuarios.sort(Comparator.comparing(u -> u.getPontos())); 43 | 44 | List list = Collections.emptyList(); 45 | list.sort(Comparator.comparing((String s)->s.toString()) 46 | .thenComparing(s -> s.length())); 47 | 48 | Function extraiPontos = u -> u.getPontos(); 49 | Comparator comparator3 = Comparator.comparing(extraiPontos); 50 | usuarios.sort(comparator3); 51 | 52 | 53 | ToIntFunction extraiPontos2 = u -> u.getPontos(); 54 | Comparator comparator4 = Comparator.comparingInt(extraiPontos2); 55 | usuarios.sort(comparator4); 56 | 57 | usuarios.sort(Comparator.comparingInt(u -> u.getPontos())); 58 | 59 | // ordem natural: 60 | List palavras = 61 | Arrays.asList("Casa do Código", "Alura", "Caelum"); 62 | 63 | palavras.sort(Comparator.naturalOrder()); 64 | palavras.sort(Comparator.reverseOrder()); 65 | 66 | } 67 | } 68 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo6.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import static java.util.Comparator.comparing; 4 | 5 | import java.util.Arrays; 6 | import java.util.Comparator; 7 | import java.util.List; 8 | import java.util.function.*; 9 | 10 | class Capitulo6 { 11 | 12 | public static void main(String[] args) { 13 | 14 | Usuario u1 = new Usuario("Paulo Silveira", 150); 15 | Usuario u2 = new Usuario("Rodrigo Turini", 120); 16 | Usuario u3 = new Usuario("Guilherme Silveira", 190); 17 | 18 | List usuarios = Arrays.asList(u1, u2, u3); 19 | 20 | usuarios.forEach(u -> u.tornaModerador()); 21 | 22 | usuarios.forEach(Usuario::tornaModerador); 23 | 24 | Consumer tornaModerador = Usuario::tornaModerador; 25 | usuarios.forEach(tornaModerador); 26 | 27 | usuarios.sort(Comparator.comparing(u -> u.getNome())); 28 | 29 | usuarios.sort(Comparator.comparing(Usuario::getNome)); 30 | 31 | Function byName = Usuario::getNome; 32 | usuarios.sort(comparing(byName)); 33 | 34 | // compondo comparators 35 | 36 | usuarios.sort(Comparator.comparingInt(Usuario::getPontos)); 37 | 38 | 39 | Comparator c = Comparator.comparingInt(Usuario::getPontos) 40 | .thenComparing(Usuario::getNome); 41 | 42 | usuarios.sort(Comparator.comparingInt(Usuario::getPontos) 43 | .thenComparing(Usuario::getNome)); 44 | 45 | usuarios.sort(Comparator.nullsLast( 46 | Comparator.comparing(Usuario::getNome))); 47 | 48 | // necessidade de tipagem para inferencia correta: 49 | usuarios.sort(Comparator.comparingInt((Usuario u) -> u.getPontos()) 50 | .thenComparing(u -> u.getNome())); 51 | 52 | Comparator comparator = Comparator.comparing(u -> u.getPontos()); 53 | usuarios.sort(comparator.thenComparing(u -> u.getNome())); 54 | 55 | Comparator comparator2 = Comparator.comparing(u -> u.getNome()); 56 | usuarios.sort(comparator2.reversed()); 57 | 58 | usuarios.sort(Comparator.comparing(Usuario::getPontos).reversed()); 59 | 60 | 61 | usuarios.sort(Comparator.comparing(u -> u.getPontos()).reversed()); 62 | 63 | // esse o compilador nao infere e da erro: 64 | // usuarios.sort(Comparator.comparing(u -> u.getPontos()).reversed()); 65 | 66 | // metodos estaticos: 67 | 68 | usuarios.forEach(System.out::println); 69 | 70 | Function criadorDeUsuarios = Usuario::new; 71 | Usuario rodrigo = criadorDeUsuarios.apply("Rodrigo Turini"); 72 | Usuario paulo = criadorDeUsuarios.apply("Paulo Silveira"); 73 | 74 | BiFunction criadorDeUsuarios2 = Usuario::new; 75 | Usuario rodrigo2 = criadorDeUsuarios2.apply("Rodrigo Turini", 50); 76 | Usuario paulo2 = criadorDeUsuarios2.apply("Paulo Silveira", 300); 77 | 78 | 79 | Runnable bloco = rodrigo::tornaModerador; 80 | 81 | Runnable bloco1 = rodrigo::tornaModerador; 82 | Runnable bloco2 = () -> rodrigo.tornaModerador(); 83 | 84 | 85 | Consumer consumer1 = Usuario::tornaModerador; 86 | Consumer consumer2 = (u) -> u.tornaModerador(); 87 | 88 | BiFunction max = Math::max; 89 | ToIntBiFunction max2 = Math::max; 90 | IntBinaryOperator max3 = Math::max; 91 | 92 | } 93 | } -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo7.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.*; 4 | import java.io.*; 5 | import java.math.*; 6 | import java.util.stream.*; 7 | import java.util.function.*; 8 | 9 | class Capitulo7 { 10 | public static void main (String... args) throws Exception { 11 | 12 | Usuario u1 = new Usuario("Paulo Silveira", 150); 13 | Usuario u2 = new Usuario("Rodrigo Turini", 120); 14 | Usuario u3 = new Usuario("Guilherme Silveira", 90); 15 | 16 | List usuarios = Arrays.asList(u1, u2, u3); 17 | 18 | usuarios.sort(Comparator.comparing(Usuario::getPontos).reversed()); 19 | usuarios.subList(0,1).forEach(Usuario::tornaModerador); 20 | 21 | Collections.sort(usuarios, new Comparator() { 22 | @Override 23 | public int compare(Usuario u1, Usuario u2) { 24 | return u1.getPontos() - u2.getPontos(); 25 | } 26 | }); 27 | 28 | Collections.reverse(usuarios); 29 | List top10 = usuarios.subList(0, 1); 30 | for(Usuario usuario : top10) { 31 | usuario.tornaModerador(); 32 | } 33 | 34 | Stream stream = usuarios.stream() 35 | .filter(u -> u.getPontos() > 100); 36 | 37 | stream.forEach(System.out::println); 38 | 39 | Supplier> supplier = ArrayList::new; 40 | BiConsumer, Usuario> accumulator = ArrayList::add; 41 | BiConsumer,ArrayList> combiner = ArrayList::addAll; 42 | 43 | usuarios.stream() 44 | .filter(u -> u.getPontos() > 100) 45 | .collect(supplier, accumulator, combiner); 46 | 47 | usuarios.stream() 48 | .filter(u -> u.getPontos() > 100) 49 | .collect(ArrayList::new, ArrayList::add, ArrayList::addAll); 50 | 51 | List maisQue100 = usuarios.stream() 52 | .filter(u -> u.getPontos() > 100) 53 | .collect(Collectors.toList()); 54 | 55 | ArrayList pontos = new ArrayList<>(); 56 | usuarios.forEach(u -> pontos.add(u.getPontos())); 57 | 58 | List pontos2 = usuarios.stream() 59 | .map(u -> u.getPontos()) 60 | .collect(Collectors.toList()); 61 | 62 | List pontos3 = usuarios.stream() 63 | .map(Usuario::getPontos) 64 | .collect(Collectors.toList()); 65 | 66 | Stream stream2 = usuarios.stream() 67 | .map(Usuario::getPontos); 68 | 69 | IntStream stream3 = usuarios.stream() 70 | .mapToInt(Usuario::getPontos); 71 | 72 | double pontuacaoMedia = usuarios.stream() 73 | .mapToInt(Usuario::getPontos) 74 | .average() 75 | .getAsDouble(); 76 | 77 | usuarios.stream() 78 | .mapToInt(Usuario::getPontos) 79 | .average() 80 | .orElseThrow(IllegalStateException::new); 81 | 82 | List vazia = Collections.emptyList(); 83 | 84 | 85 | double media = vazia.stream() 86 | .mapToInt(Usuario::getPontos) 87 | .average() 88 | .orElse(0.0); 89 | 90 | OptionalDouble media2 = usuarios 91 | .stream() 92 | .mapToInt(Usuario::getPontos) 93 | .average(); 94 | 95 | double pontuacaoMedia2 = media2.orElse(0.0); 96 | 97 | Optional max = usuarios 98 | .stream() 99 | .max(Comparator.comparingInt(Usuario::getPontos)); 100 | 101 | Optional maxNome = usuarios 102 | .stream() 103 | .max(Comparator.comparingInt(Usuario::getPontos)) 104 | .map(u -> u.getNome()); 105 | 106 | 107 | } 108 | } 109 | 110 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo8.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.*; 4 | import java.io.*; 5 | import java.nio.file.*; 6 | import java.util.stream.*; 7 | import java.util.function.*; 8 | 9 | class Capitulo8 { 10 | public static void main (String... args) throws Exception { 11 | 12 | Usuario user1 = new Usuario("Paulo Silveira", 150); 13 | Usuario user2 = new Usuario("Rodrigo Turini", 120); 14 | Usuario user3 = new Usuario("Guilherme Silveira", 90); 15 | 16 | List usuarios = Arrays.asList(user1, user2, user3); 17 | 18 | List filtradosOrdenados = usuarios.stream() 19 | .filter(u -> u.getPontos() > 100) 20 | .sorted(Comparator.comparing(Usuario::getNome)) 21 | .collect(Collectors.toList()); 22 | 23 | // peek mostra so os processados: 24 | usuarios.stream() 25 | .filter(u -> u.getPontos() > 100) 26 | .peek(System.out::println).findAny(); 27 | 28 | System.out.println(); 29 | 30 | // peek é apens intermeridiario: 31 | 32 | usuarios.stream() 33 | .filter(u -> u.getPontos() > 100) 34 | .peek(System.out::println); // precisa chamar terminal! 35 | 36 | System.out.println(); 37 | 38 | // sort é operador intermediario, porem stateful: 39 | usuarios.stream() 40 | .sorted(Comparator.comparing(Usuario::getNome)) 41 | .peek(System.out::println) 42 | .findAny(); 43 | 44 | System.out.println(); 45 | 46 | 47 | usuarios.stream() 48 | .sorted(Comparator.comparing(Usuario::getNome)) 49 | .peek(System.out::println) 50 | .findAny(); 51 | 52 | Usuario maximaPontuacao = usuarios.stream() 53 | .max(Comparator.comparing(Usuario::getPontos)) 54 | .get(); 55 | 56 | int total = usuarios.stream() 57 | .mapToInt(Usuario::getPontos) 58 | .sum(); 59 | 60 | int valorInicial = 0; 61 | IntBinaryOperator operacao = (a, b) -> a + b; 62 | 63 | int total2 = usuarios.stream() 64 | .mapToInt(Usuario::getPontos) 65 | .reduce(valorInicial, operacao); 66 | 67 | int multiplicacao = usuarios.stream() 68 | .mapToInt(Usuario::getPontos) 69 | .reduce(1, (a,b) -> a * b); 70 | 71 | // pulando o map! 72 | int total3 = usuarios.stream() 73 | .reduce(0, (atual, u) -> atual + u.getPontos(), Integer::sum); 74 | 75 | boolean hasModerator = usuarios.stream() 76 | .anyMatch(Usuario::isModerador); 77 | 78 | 79 | 80 | // stream infinito: 81 | 82 | Random random = new Random(0); 83 | IntStream stream = IntStream.generate(() -> random.nextInt()); 84 | 85 | // loop infinito 86 | // int valor = stream.sum(); 87 | 88 | List list = IntStream 89 | .generate(() -> random.nextInt()) 90 | .limit(100) 91 | .boxed() 92 | .collect(Collectors.toList()); 93 | 94 | class Fibonacci implements IntSupplier { 95 | private int anterior = 0; 96 | private int proximo = 1; 97 | 98 | public int getAsInt() { 99 | proximo = proximo + anterior; 100 | anterior = proximo - anterior; 101 | return anterior; 102 | } 103 | } 104 | 105 | IntStream.generate(new Fibonacci()) 106 | .limit(10) 107 | .forEach(System.out::println); 108 | 109 | int maiorQue100 = IntStream 110 | .generate(new Fibonacci()) 111 | .filter(f -> f > 100) 112 | .findFirst() 113 | .getAsInt(); 114 | 115 | System.out.println(maiorQue100); 116 | 117 | IntStream.iterate(0, x -> x + 1) 118 | .limit(10) 119 | .forEach(System.out::println); 120 | 121 | 122 | 123 | // flatmap e java.nio.files 124 | 125 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 126 | .forEach(System.out::println); 127 | 128 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 129 | .filter(p -> p.toString().endsWith(".java")) 130 | .forEach(System.out::println); 131 | 132 | 133 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 134 | .filter(p -> p.toString().endsWith(".java")) 135 | .map(p -> lines(p)) 136 | .forEach(System.out::println); 137 | 138 | Stream> strings = 139 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 140 | .filter(p -> p.toString().endsWith(".java")) 141 | .map(p -> lines(p)); 142 | 143 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 144 | .filter(p -> p.toString().endsWith(".java")) 145 | .flatMap(p -> lines(p)) 146 | .forEach(System.out::println); 147 | 148 | 149 | IntStream chars = 150 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 151 | .filter(p -> p.toString().endsWith(".java")) 152 | .flatMap(p -> lines(p)) 153 | .flatMapToInt((String s) -> s.chars()); 154 | 155 | 156 | Grupo englishSpeakers = new Grupo(); 157 | englishSpeakers.add(user1); 158 | englishSpeakers.add(user2); 159 | 160 | Grupo spanishSpeakers = new Grupo(); 161 | spanishSpeakers.add(user2); 162 | spanishSpeakers.add(user3); 163 | 164 | List groups = Arrays.asList(englishSpeakers, spanishSpeakers); 165 | groups.stream() 166 | .flatMap(g -> g.getUsuarios().stream()) 167 | .distinct() 168 | .forEach(System.out::println); 169 | 170 | } 171 | 172 | static Stream lines(Path p) { 173 | try { 174 | return Files.lines(p); 175 | } catch(IOException e) { 176 | throw new UncheckedIOException(e); 177 | } 178 | } 179 | } 180 | 181 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Capitulo9.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.*; 4 | import java.io.*; 5 | import java.nio.file.*; 6 | import java.util.stream.*; 7 | import java.util.function.*; 8 | 9 | 10 | class Capitulo9 { 11 | 12 | private static long total = 0; 13 | 14 | public static void main (String... args) throws Exception { 15 | 16 | LongStream lines = 17 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 18 | .filter(p -> p.toString().endsWith(".java")) 19 | .mapToLong(p -> lines(p).count()); 20 | 21 | List lines2 = 22 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 23 | .filter(p -> p.toString().endsWith(".java")) 24 | .map(p -> lines(p).count()) 25 | .collect(Collectors.toList()); 26 | 27 | { 28 | Map linesPerFile = new HashMap<>(); 29 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 30 | .filter(p -> p.toString().endsWith(".java")) 31 | .forEach(p -> 32 | linesPerFile.put(p, lines(p).count())); 33 | System.out.println(linesPerFile); 34 | 35 | } 36 | Map linesPerFile = 37 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 38 | .filter(p -> p.toString().endsWith(".java")) 39 | .collect(Collectors.toMap( 40 | Function.identity(), 41 | p -> lines(p).count())); 42 | 43 | System.out.println(linesPerFile); 44 | 45 | 46 | 47 | Map> content = 48 | Files.list(Paths.get("./br/com/casadocodigo/java8")) 49 | .filter(p -> p.toString().endsWith(".java")) 50 | .collect(Collectors.toMap( 51 | p -> p, 52 | p -> lines(p).collect(Collectors.toList()))); 53 | 54 | 55 | 56 | 57 | Usuario user1 = new Usuario("Paulo Silveira", 150, true); 58 | Usuario user2 = new Usuario("Rodrigo Turini", 120, true); 59 | Usuario user3 = new Usuario("Guilherme Silveira", 90); 60 | Usuario user4 = new Usuario("Sergio Lopes", 120); 61 | Usuario user5 = new Usuario("Adriano Almeida", 100); 62 | 63 | List usuarios = Arrays.asList(user1, user2, user3, user4, user5); 64 | 65 | Map nameToUser = usuarios 66 | .stream() 67 | .collect(Collectors.toMap( 68 | Usuario::getNome, 69 | Function.identity())); 70 | System.out.println(nameToUser); 71 | 72 | 73 | Map> pontuacaoVelha = new HashMap<>(); 74 | 75 | for(Usuario u: usuarios) { 76 | if(!pontuacaoVelha.containsKey(u.getPontos())) { 77 | pontuacaoVelha.put(u.getPontos(), new ArrayList<>()); 78 | } 79 | pontuacaoVelha.get(u.getPontos()).add(u); 80 | } 81 | 82 | System.out.println(pontuacaoVelha); 83 | 84 | Map> pontuacaoJ8 = new HashMap<>(); 85 | 86 | for(Usuario u: usuarios) { 87 | pontuacaoJ8 88 | .computeIfAbsent(u.getPontos(), user -> new ArrayList<>()) 89 | .add(u); 90 | } 91 | 92 | System.out.println(pontuacaoJ8); 93 | 94 | 95 | Map> pontuacao = usuarios 96 | .stream() 97 | .collect(Collectors.groupingBy(Usuario::getPontos)); 98 | 99 | System.out.println(pontuacao); 100 | 101 | Map> moderadores = usuarios 102 | .stream() 103 | .collect(Collectors.partitioningBy(Usuario::isModerador)); 104 | 105 | System.out.println(moderadores); 106 | 107 | Map pontuacaoPorTipo = usuarios 108 | .stream() 109 | .collect(Collectors.partitioningBy(u -> u.isModerador(), 110 | Collectors.summingInt(Usuario::getPontos))); 111 | 112 | System.out.println(pontuacaoPorTipo); 113 | 114 | Map> nomesPorTipo = usuarios 115 | .stream() 116 | .collect(Collectors.partitioningBy(u -> u.isModerador(), 117 | Collectors.mapping(Usuario::getNome, Collectors.toList()))); 118 | 119 | System.out.println(nomesPorTipo); 120 | 121 | 122 | 123 | // PARALLEL 124 | 125 | List filtradosOrdenados = usuarios.parallelStream() 126 | .filter(u -> u.getPontos() > 100) 127 | .sorted(Comparator.comparing(Usuario::getNome)) 128 | .collect(Collectors.toList()); 129 | 130 | long sum = 131 | LongStream.range(0, 1_000_000_000) 132 | .filter(x -> x % 2 == 0) 133 | .parallel() 134 | .sum(); 135 | System.out.println(sum); 136 | 137 | } 138 | 139 | static Stream lines(Path p) { 140 | try { 141 | return Files.lines(p); 142 | } catch(IOException e) { 143 | throw new UncheckedIOException(e); 144 | } 145 | } 146 | 147 | } 148 | 149 | class UnsafeParallelStreamUsage { 150 | private static long total = 0; 151 | 152 | public static void main (String... args) throws Exception { 153 | LongStream.range(0, 1_000_000_000) 154 | .parallel() 155 | .filter(x -> x % 2 == 0) 156 | .forEach(n -> total += n); 157 | 158 | System.out.println(total); 159 | } 160 | } 161 | -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Usuario.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import java.util.*; 4 | 5 | class Usuario { 6 | 7 | private int pontos; 8 | private String nome; 9 | private boolean moderador; 10 | 11 | public Usuario(String nome) { 12 | this.nome = nome; 13 | } 14 | 15 | public Usuario(String nome, int pontos) { 16 | this.pontos = pontos; 17 | this.nome = nome; 18 | this.moderador = false; 19 | } 20 | 21 | public Usuario(String nome, int pontos, boolean moderador) { 22 | this.pontos = pontos; 23 | this.nome = nome; 24 | this.moderador = moderador; 25 | } 26 | 27 | public int getPontos() { 28 | return pontos; 29 | } 30 | 31 | public String getNome() { 32 | return nome; 33 | } 34 | 35 | public void tornaModerador() { 36 | this.moderador = true; 37 | } 38 | 39 | public String toString() { 40 | return "Usuario " + nome; 41 | } 42 | 43 | public boolean isModerador() { 44 | return moderador; 45 | } 46 | } 47 | 48 | class Grupo { 49 | private Set usuarios = new HashSet<>(); 50 | 51 | public void add(Usuario u) { 52 | usuarios.add(u); 53 | } 54 | 55 | public Set getUsuarios() { 56 | return Collections.unmodifiableSet(this.usuarios); 57 | } 58 | } -------------------------------------------------------------------------------- /src/main/java/br/com/casadocodigo/java8/Validator.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | @FunctionalInterface 4 | interface Validador { 5 | 6 | boolean valida(T t); 7 | } -------------------------------------------------------------------------------- /src/test/java/br/com/casadocodigo/java8/BuscaAlunoTest.java: -------------------------------------------------------------------------------- 1 | package br.com.casadocodigo.java8; 2 | 3 | import org.junit.*; 4 | import static org.junit.Assert.*; 5 | import java.util.*; 6 | import java.util.function.*; 7 | 8 | /** 9 | * Unit test for simple App. 10 | */ 11 | public class BuscaAlunoTest 12 | { 13 | 14 | @Test 15 | public void testApp() 16 | { 17 | List lista = Arrays.asList(1,2,3); 18 | 19 | lista.forEach(new Consumer(){ 20 | public void accept(Object a) { 21 | System.out.println(a); 22 | } 23 | }); 24 | 25 | lista.forEach((v) -> {System.out.println(v);}); 26 | 27 | assertTrue( true ); 28 | } 29 | } 30 | --------------------------------------------------------------------------------