initial commit

ModernJavaInAction-master/.gitignore

@@ -0,0 +1,13 @@
+/target
+/local
+
+# Eclipse, Netbeans and IntelliJ files
+/.*
+!.gitignore
+/nbproject
+/*.ipr
+/*.iws
+/*.iml
+
+# Repository wide ignore mac DS_Store files
+.DS_Store

ModernJavaInAction-master/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Raoul-Gabriel Urma, Mario Fusco, Alan Mycroft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ModernJavaInAction-master/README.md

@@ -0,0 +1,59 @@
+Java8InAction
+===============
+
+This repository contains all the source code for the examples and quizzes in the book Java 8 in Action: Lambdas, Streams and functional-style programming.
+
+You can purchase the book here: [http://manning.com/urma/](http://manning.com/urma/) or on Amazon
+
+The source code for all examples can be found in the directory [src/main/java/lambdasinaction](https://github.com/java8/Java8InAction/tree/master/src/main/java/lambdasinaction)
+
+* Chapter 1: Java 8: why should you care?
+* Chapter 2: Passing code with behavior parameterization
+* Chapter 3: Lambda expressions
+* Chapter 4: Working with Streams
+* Chapter 5: Processing data with streams
+* Chapter 6: Collecting data with streams
+* Chapter 7: Parallel data processing and performance
+* Chapter 8: Refactoring, testing, debugging
+* Chapter 9: Default methods
+* Chapter 10: Using Optional as a better alternative to null
+* Chapter 11: CompletableFuture: composable asynchronous programming
+* Chapter 12: New Date and Time API
+* Chapter 13: Thinking functionally
+* Chapter 14: Functional programming techniques
+* Chapter 15: Blending OOP and FP: comparing Java 8 and Scala
+* Chapter 16: Conclusions and "where next" for Java
+* Appendix A: Miscellaneous language updates
+* Appendix B: Miscellaneous library updates
+* Appendix C: Performing multiple operations in parallel on a Stream
+* Appendix D: Lambdas and JVM bytecode
+We will update the repository as we update the book. Stay tuned!
+
+### Make sure to have JDK8 installed
+The latest binary can be found here: http://www.oracle.com/technetwork/java/javase/overview/java8-2100321.html
+
+$ java -version
+
+java version "1.8.0_05"
+Java(TM) SE Runtime Environment (build 1.8.0_05-b13)
+Java HotSpot(TM) 64-Bit Server VM (build 25.5-b02, mixed mode)
+
+
+You can download a preview version here: https://jdk8.java.net/
+
+### Compile/Run the examples
+Using maven:
+
+$ mvn compile
+
+$ cd target/classes
+
+$ java lambdasinaction/chap1/FilteringApples
+
+
+Alternatively you can compile the files manually inside the directory src/main/java
+
+You can also import the project in your favorite IDE:
+    * In IntelliJ use "File->Open" menu and navigate to the folder where the project resides
+    * In Eclipse use "File->Import->Existing Maven Projects" (also modify "Reduntant super interfaces" to report as Warnings instead of Errors
+    * In Netbeans use "File->Open Project" menu

ModernJavaInAction-master/benchmark.bat

@@ -0,0 +1 @@
+java -jar ./target/benchmarks.jar ParallelStreamBenchmark

ModernJavaInAction-master/benchmark.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+
+#Java executable for standard Linux environment
+export JAVA_EXE=java
+#Java executable for MinGW environment
+#export JAVA_EXE=/c/jdk9/bin/java.exe
+
+$JAVA_EXE -jar ./target/benchmarks.jar ParallelStreamBenchmark

ModernJavaInAction-master/pom.xml

@@ -0,0 +1,88 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+
+  <groupId>manning</groupId>
+  <artifactId>modernjavainaction</artifactId>
+  <version>2.0</version>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+  </properties>
+
+  <dependencies>
+    <dependency>
+      <groupId>org.openjdk.jmh</groupId>
+      <artifactId>jmh-core</artifactId>
+      <version>1.21</version>
+    </dependency>
+    <dependency>
+      <groupId>org.openjdk.jmh</groupId>
+      <artifactId>jmh-generator-annprocess</artifactId>
+      <version>1.21</version>
+    </dependency>
+    <dependency>
+      <groupId>io.reactivex.rxjava2</groupId>
+      <artifactId>rxjava</artifactId>
+      <version>2.2.2</version>
+    </dependency>
+    <dependency>
+      <groupId>com.typesafe.akka</groupId>
+      <artifactId>akka-actor_2.12</artifactId>
+      <version>2.5.16</version>
+    </dependency>
+    <dependency>
+      <groupId>com.typesafe.akka</groupId>
+      <artifactId>akka-stream_2.12</artifactId>
+      <version>2.5.16</version>
+    </dependency>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+    </dependency>
+  </dependencies>
+
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.8.0</version>
+        <configuration>
+          <release>10</release>
+        </configuration>
+        <dependencies>
+          <dependency>
+            <groupId>org.ow2.asm</groupId>
+            <artifactId>asm</artifactId>
+            <version>6.2.1</version> <!-- Use newer version of ASM -->
+          </dependency>
+        </dependencies>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-shade-plugin</artifactId>
+        <version>3.1.1</version>
+        <executions>
+          <execution>
+            <phase>package</phase>
+            <goals>
+              <goal>shade</goal>
+            </goals>
+            <configuration>
+              <finalName>benchmarks</finalName>
+              <transformers>
+                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                  <mainClass>org.openjdk.jmh.Main</mainClass>
+                </transformer>
+              </transformers>
+            </configuration>
+          </execution>
+        </executions>
+      </plugin>
+    </plugins>
+  </build>
+</project>

ModernJavaInAction-master/src/main/java/modernjavainaction/appa/Author.java

@@ -0,0 +1,13 @@
+package modernjavainaction.appa;
+
+import java.lang.annotation.Repeatable;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Repeatable(Authors.class)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Author {
+
+    String name();
+
+}

ModernJavaInAction-master/src/main/java/modernjavainaction/appa/Authors.java

@@ -0,0 +1,11 @@
+package modernjavainaction.appa;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Authors {
+
+    Author[] value();
+
+}

ModernJavaInAction-master/src/main/java/modernjavainaction/appa/Book.java

@@ -0,0 +1,17 @@
+package modernjavainaction.appa;
+
+import java.util.Arrays;
+
+@Author(name = "Raoul")
+@Author(name = "Mario")
+@Author(name = "Alan")
+public class Book {
+
+    public static void main(String[] args) {
+        Author[] authors = Book.class.getAnnotationsByType(Author.class);
+        Arrays.asList(authors).stream().forEach(a -> {
+            System.out.println(a.name());
+        });
+    }
+
+}

ModernJavaInAction-master/src/main/java/modernjavainaction/appc/StreamForker.java

@@ -0,0 +1,138 @@
+package modernjavainaction.appc;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.util.function.*;
+import java.util.stream.*;
+
+/**
+ * Adapted from http://mail.openjdk.java.net/pipermail/lambda-dev/2013-November/011516.html
+ */
+public class StreamForker<T> {
+
+    private final Stream<T> stream;
+    private final Map<Object, Function<Stream<T>, ?>> forks = new HashMap<>();
+
+    public StreamForker(Stream<T> stream) {
+        this.stream = stream;
+    }
+
+    public StreamForker<T> fork(Object key, Function<Stream<T>, ?> f) {
+        forks.put(key, f);
+        return this;
+    }
+
+    public Results getResults() {
+        ForkingStreamConsumer<T> consumer = build();
+        try {
+            stream.sequential().forEach(consumer);
+        } finally {
+            consumer.finish();
+        }
+        return consumer;
+    }
+
+    private ForkingStreamConsumer<T> build() {
+        List<BlockingQueue<T>> queues = new ArrayList<>();
+
+        Map<Object, Future<?>> actions =
+                forks.entrySet().stream().reduce(
+                        new HashMap<Object, Future<?>>(),
+                        (map, e) -> {
+                            map.put(e.getKey(),
+                                    getOperationResult(queues, e.getValue()));
+                            return map;
+                        },
+                        (m1, m2) -> {
+                            m1.putAll(m2);
+                            return m1;
+                        });
+
+        return new ForkingStreamConsumer<>(queues, actions);
+    }
+
+    private Future<?> getOperationResult(List<BlockingQueue<T>> queues, Function<Stream<T>, ?> f) {
+        BlockingQueue<T> queue = new LinkedBlockingQueue<>();
+        queues.add(queue);
+        Spliterator<T> spliterator = new BlockingQueueSpliterator<>(queue);
+        Stream<T> source = StreamSupport.stream(spliterator, false);
+        return CompletableFuture.supplyAsync( () -> f.apply(source) );
+    }
+
+    public static interface Results {
+        public <R> R get(Object key);
+    }
+
+    private static class ForkingStreamConsumer<T> implements Consumer<T>, Results {
+        static final Object END_OF_STREAM = new Object();
+
+        private final List<BlockingQueue<T>> queues;
+        private final Map<Object, Future<?>> actions;
+
+        ForkingStreamConsumer(List<BlockingQueue<T>> queues, Map<Object, Future<?>> actions) {
+            this.queues = queues;
+            this.actions = actions;
+        }
+
+        @Override
+        public void accept(T t) {
+            queues.forEach(q -> q.add(t));
+        }
+
+        @Override
+        public <R> R get(Object key) {
+            try {
+                return ((Future<R>) actions.get(key)).get();
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        void finish() {
+            accept((T) END_OF_STREAM);
+        }
+    }
+
+    private static class BlockingQueueSpliterator<T> implements Spliterator<T> {
+        private final BlockingQueue<T> q;
+
+        BlockingQueueSpliterator(BlockingQueue<T> q) {
+            this.q = q;
+        }
+
+        @Override
+        public boolean tryAdvance(Consumer<? super T> action) {
+            T t;
+            while (true) {
+                try {
+                    t = q.take();
+                    break;
+                }
+                catch (InterruptedException e) {
+                }
+            }
+
+            if (t != ForkingStreamConsumer.END_OF_STREAM) {
+                action.accept(t);
+                return true;
+            }
+
+            return false;
+        }
+
+        @Override
+        public Spliterator<T> trySplit() {
+            return null;
+        }
+
+        @Override
+        public long estimateSize() {
+            return 0;
+        }
+
+        @Override
+        public int characteristics() {
+            return 0;
+        }
+    }
+}