pax_global_header00006660000000000000000000000064137400404470014515gustar00rootroot0000000000000052 comment=cc94cad71818816524c14f48ec075c3582804869 OnJava8-Examples-1.0/000077500000000000000000000000001374004044700143775ustar00rootroot00000000000000OnJava8-Examples-1.0/.gitattributes000066400000000000000000000005721374004044700172760ustar00rootroot00000000000000# Auto detect text files and perform LF normalization * text=auto # Custom for Visual Studio *.cs diff=csharp # Standard to msysgit *.doc diff=astextplain *.DOC diff=astextplain *.docx diff=astextplain *.DOCX diff=astextplain *.dot diff=astextplain *.DOT diff=astextplain *.pdf diff=astextplain *.PDF diff=astextplain *.rtf diff=astextplain *.RTF diff=astextplain OnJava8-Examples-1.0/.gitignore000066400000000000000000000031421374004044700163670ustar00rootroot00000000000000# Windows image file caches Thumbs.db ehthumbs.db # Folder config file Desktop.ini # Recycle Bin used on file shares $RECYCLE.BIN/ # Windows Installer files *.cab *.msi *.msm *.msp # Windows shortcuts *.lnk # ========================= # Operating System Files # ========================= # OSX # ========================= .DS_Store .AppleDouble .LSOverride # Thumbnails ._* # Files that might appear on external disk .Spotlight-V100 .Trashes # Directories potentially created on remote AFP share .AppleDB .AppleDesktop Network Trash Folder Temporary Items .apdisk *.class *output.txt Generated.txt *-control.txt *-results.txt *-out.txt OutputErrors.txt report.txt failures People.xml annotations/Test0.txt annotations/Test1.txt annotations/Test2.txt io/*.out io/*.txt io/*.dat io/*.tmp io/test.zip io/test.gz io/X.file *.pyc *.out *.err /files/bytes.dat /files/test/ /exceptions/Results.txt /files/Cheese.txt /files/StreamInAndOut.txt .gradle /*.iml /.idea/ /serialization/Blip3.serialized /serialization/Blips.serialized build/ buildSrc/ /compression/test.gz /compression/test.zip /iostreams/BasicFileOutput.dat /iostreams/Data.txt /iostreams/FileOutputShortcut.dat /iostreams/rtest.dat /logging/LogToFile.xml /logging/LogToFile2.txt /logging/MultipleHandlers.xml /logging/MultipleHandlers2.xml /logging/java0.log /logging/java1.log /logging/java2.log /newio/TransferTo.txt /newio/data2.txt /newio/file.txt /newio/test.dat /newio/test.txt /serialization/CADState.dat /serialization/worm.dat /serialization/Logon.dat /serialization/X.file /standardio/Redirecting.txt /threads/PSP2.txt /threads/primes.txt _* config.py OnJava8-Examples-1.0/.travis.yml000066400000000000000000000003071374004044700165100ustar00rootroot00000000000000language: java jdk: - oraclejdk11 install: true script: - ./gradlew --no-daemon --stacktrace run # - ./gradlew --parallel --stacktrace run # - ./gradlew --parallel --stacktrace :validating:jmh OnJava8-Examples-1.0/Copyright.txt000066400000000000000000000063011374004044700171100ustar00rootroot00000000000000// Copyright.txt This computer source code is Copyright ©2020 MindView LLC. All Rights Reserved. Permission to use, copy, modify, and distribute this computer source code (Source Code) and its documentation without fee and without a written agreement for the purposes set forth below is hereby granted, provided that the above copyright notice, this paragraph and the following five numbered paragraphs appear in all copies. 1. Permission is granted to compile the Source Code and to include the compiled code, in executable format only, in personal and commercial software programs. 2. Permission is granted to use the Source Code without modification in classroom situations, including in presentation materials, provided that the book "On Java 8" is cited as the origin. 3. Permission to incorporate the Source Code into printed media may be obtained by contacting: MindView LLC, PO Box 969, Crested Butte, CO 81224 MindViewInc@gmail.com 4. The Source Code and documentation are copyrighted by MindView LLC. The Source code is provided without express or implied warranty of any kind, including any implied warranty of merchantability, fitness for a particular purpose or non-infringement. MindView LLC does not warrant that the operation of any program that includes the Source Code will be uninterrupted or error-free. MindView LLC makes no representation about the suitability of the Source Code or of any software that includes the Source Code for any purpose. The entire risk as to the quality and performance of any program that includes the Source Code is with the user of the Source Code. The user understands that the Source Code was developed for research and instructional purposes and is advised not to rely exclusively for any reason on the Source Code or any program that includes the Source Code. Should the Source Code or any resulting software prove defective, the user assumes the cost of all necessary servicing, repair, or correction. 5. IN NO EVENT SHALL MINDVIEW LLC, OR ITS PUBLISHER BE LIABLE TO ANY PARTY UNDER ANY LEGAL THEORY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS, OR FOR PERSONAL INJURIES, ARISING OUT OF THE USE OF THIS SOURCE CODE AND ITS DOCUMENTATION, OR ARISING OUT OF THE INABILITY TO USE ANY RESULTING PROGRAM, EVEN IF MINDVIEW LLC, OR ITS PUBLISHER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. MINDVIEW LLC SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE SOURCE CODE AND DOCUMENTATION PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, WITHOUT ANY ACCOMPANYING SERVICES FROM MINDVIEW LLC, AND MINDVIEW LLC HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. Please note that MindView LLC maintains a Web site which is the sole distribution point for electronic copies of the Source Code, https://github.com/BruceEckel/OnJava8-examples, where it is freely available under the terms stated above. If you think you've found an error in the Source Code, please submit a correction at: https://github.com/BruceEckel/OnJava8-examples/issues OnJava8-Examples-1.0/README.md000066400000000000000000000030051374004044700156540ustar00rootroot00000000000000[comment]: <> [![](https://travis-ci.org/BruceEckel/OnJava8-Examples.svg?branch=master)](https://travis-ci.org/BruceEckel/OnJava8-Examples) [comment]: <> [![](https://ci.appveyor.com/api/projects/status/github/BruceEckel/OnJava8-Examples)](https://ci.appveyor.com/project/BruceEckel/onjava-examples) To compile and run these programs, you only need JDK 8 installed. Invoking `gradlew` will automatically download and install Gradle. Gradle will also install all additional libraries necessary to compile and run the Java examples in the book. To compile and run everything, the command is: `gradlew run` If you are on a Unix/Linux based system, you must select the local directory for all commands, for example: `./gradlew run` To only compile everything, the command is: `gradlew compileJava` To compile only a single chapter (including dependencies), use for example: `gradlew :strings:compileJava` To run only a single chapter, say: `gradlew :strings:run` Gradle can also be used to run a single program. Here, we run the **ReplacingStringTokenizer.java** program in the **strings** chapter subdirectory: `gradlew :strings:ReplacingStringTokenizer` However, if the file name is unique throughout the book (the majority are), you can just give the program name, like this: `gradlew ReplacingStringTokenizer` Note that all commands are run from the base directory where the example code is installed, and where you find the `gradlew` script. You can learn about other options by just typing `gradlew` with no arguments. OnJava8-Examples-1.0/annotations/000077500000000000000000000000001374004044700167345ustar00rootroot00000000000000OnJava8-Examples-1.0/annotations/AUComposition.java000066400000000000000000000013551374004044700223340ustar00rootroot00000000000000// annotations/AUComposition.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating non-embedded tests // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AUComposition.class} package annotations; import onjava.atunit.*; import onjava.*; public class AUComposition { AtUnitExample1 testObject = new AtUnitExample1(); @Test boolean tMethodOne() { return testObject.methodOne() .equals("This is methodOne"); } @Test boolean tMethodTwo() { return testObject.methodTwo() == 2; } } /* Output: annotations.AUComposition . tMethodTwo This is methodTwo . tMethodOne OK (2 tests) */ OnJava8-Examples-1.0/annotations/AUExternalTest.java000066400000000000000000000012671374004044700224550ustar00rootroot00000000000000// annotations/AUExternalTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating non-embedded tests // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AUExternalTest.class} package annotations; import onjava.atunit.*; import onjava.*; public class AUExternalTest extends AtUnitExample1 { @Test boolean tMethodOne() { return methodOne().equals("This is methodOne"); } @Test boolean tMethodTwo() { return methodTwo() == 2; } } /* Output: annotations.AUExternalTest . tMethodOne . tMethodTwo This is methodTwo OK (2 tests) */ OnJava8-Examples-1.0/annotations/AtUnitExample1.java000066400000000000000000000022021374004044700223740ustar00rootroot00000000000000// annotations/AtUnitExample1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AtUnitExample1.class} package annotations; import onjava.atunit.*; import onjava.*; public class AtUnitExample1 { public String methodOne() { return "This is methodOne"; } public int methodTwo() { System.out.println("This is methodTwo"); return 2; } @Test boolean methodOneTest() { return methodOne().equals("This is methodOne"); } @Test boolean m2() { return methodTwo() == 2; } @Test private boolean m3() { return true; } // Shows output for failure: @Test boolean failureTest() { return false; } @Test boolean anotherDisappointment() { return false; } } /* Output: annotations.AtUnitExample1 . m3 . methodOneTest . m2 This is methodTwo . failureTest (failed) . anotherDisappointment (failed) (5 tests) >>> 2 FAILURES <<< annotations.AtUnitExample1: failureTest annotations.AtUnitExample1: anotherDisappointment */ OnJava8-Examples-1.0/annotations/AtUnitExample2.java000066400000000000000000000027641374004044700224120ustar00rootroot00000000000000// annotations/AtUnitExample2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Assertions and exceptions can be used in @Tests // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AtUnitExample2.class} package annotations; import java.io.*; import onjava.atunit.*; import onjava.*; public class AtUnitExample2 { public String methodOne() { return "This is methodOne"; } public int methodTwo() { System.out.println("This is methodTwo"); return 2; } @Test void assertExample() { assert methodOne().equals("This is methodOne"); } @Test void assertFailureExample() { assert 1 == 2: "What a surprise!"; } @Test void exceptionExample() throws IOException { try(FileInputStream fis = new FileInputStream("nofile.txt")) {} // Throws } @Test boolean assertAndReturn() { // Assertion with message: assert methodTwo() == 2: "methodTwo must equal 2"; return methodOne().equals("This is methodOne"); } } /* Output: annotations.AtUnitExample2 . exceptionExample java.io.FileNotFoundException: nofile.txt (The system cannot find the file specified) (failed) . assertExample . assertAndReturn This is methodTwo . assertFailureExample java.lang.AssertionError: What a surprise! (failed) (4 tests) >>> 2 FAILURES <<< annotations.AtUnitExample2: exceptionExample annotations.AtUnitExample2: assertFailureExample */ OnJava8-Examples-1.0/annotations/AtUnitExample3.java000066400000000000000000000020271374004044700224030ustar00rootroot00000000000000// annotations/AtUnitExample3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AtUnitExample3.class} package annotations; import onjava.atunit.*; import onjava.*; public class AtUnitExample3 { private int n; public AtUnitExample3(int n) { this.n = n; } public int getN() { return n; } public String methodOne() { return "This is methodOne"; } public int methodTwo() { System.out.println("This is methodTwo"); return 2; } @TestObjectCreate static AtUnitExample3 create() { return new AtUnitExample3(47); } @Test boolean initialization() { return n == 47; } @Test boolean methodOneTest() { return methodOne().equals("This is methodOne"); } @Test boolean m2() { return methodTwo() == 2; } } /* Output: annotations.AtUnitExample3 . initialization . m2 This is methodTwo . methodOneTest OK (3 tests) */ OnJava8-Examples-1.0/annotations/AtUnitExample4.java000066400000000000000000000043631374004044700224110ustar00rootroot00000000000000// annotations/AtUnitExample4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AtUnitExample4.class} // {VisuallyInspectOutput} package annotations; import java.util.*; import onjava.atunit.*; import onjava.*; public class AtUnitExample4 { static String theory = "All brontosauruses " + "are thin at one end, much MUCH thicker in the " + "middle, and then thin again at the far end."; private String word; private Random rand = new Random(); // Time-based seed public AtUnitExample4(String word) { this.word = word; } public String getWord() { return word; } public String scrambleWord() { List chars = Arrays.asList( ConvertTo.boxed(word.toCharArray())); Collections.shuffle(chars, rand); StringBuilder result = new StringBuilder(); for(char ch : chars) result.append(ch); return result.toString(); } @TestProperty static List input = Arrays.asList(theory.split(" ")); @TestProperty static Iterator words = input.iterator(); @TestObjectCreate static AtUnitExample4 create() { if(words.hasNext()) return new AtUnitExample4(words.next()); else return null; } @Test boolean words() { System.out.println("'" + getWord() + "'"); return getWord().equals("are"); } @Test boolean scramble1() { // Use specific seed to get verifiable results: rand = new Random(47); System.out.println("'" + getWord() + "'"); String scrambled = scrambleWord(); System.out.println(scrambled); return scrambled.equals("lAl"); } @Test boolean scramble2() { rand = new Random(74); System.out.println("'" + getWord() + "'"); String scrambled = scrambleWord(); System.out.println(scrambled); return scrambled.equals("tsaeborornussu"); } } /* Output: annotations.AtUnitExample4 . words 'All' (failed) . scramble1 'brontosauruses' ntsaueorosurbs (failed) . scramble2 'are' are (failed) (3 tests) >>> 3 FAILURES <<< annotations.AtUnitExample4: words annotations.AtUnitExample4: scramble1 annotations.AtUnitExample4: scramble2 */ OnJava8-Examples-1.0/annotations/AtUnitExample5.java000066400000000000000000000025641374004044700224130ustar00rootroot00000000000000// annotations/AtUnitExample5.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/AtUnitExample5.class} package annotations; import java.io.*; import onjava.atunit.*; import onjava.*; public class AtUnitExample5 { private String text; public AtUnitExample5(String text) { this.text = text; } @Override public String toString() { return text; } @TestProperty static PrintWriter output; @TestProperty static int counter; @TestObjectCreate static AtUnitExample5 create() { String id = Integer.toString(counter++); try { output = new PrintWriter("Test" + id + ".txt"); } catch(IOException e) { throw new RuntimeException(e); } return new AtUnitExample5(id); } @TestObjectCleanup static void cleanup(AtUnitExample5 tobj) { System.out.println("Running cleanup"); output.close(); } @Test boolean test1() { output.print("test1"); return true; } @Test boolean test2() { output.print("test2"); return true; } @Test boolean test3() { output.print("test3"); return true; } } /* Output: annotations.AtUnitExample5 . test1 Running cleanup . test3 Running cleanup . test2 Running cleanup OK (3 tests) */ OnJava8-Examples-1.0/annotations/DemoProcessFiles.java000066400000000000000000000020751374004044700230110ustar00rootroot00000000000000// annotations/DemoProcessFiles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.ProcessFiles; public class DemoProcessFiles { public static void main(String[] args) { new ProcessFiles(file -> System.out.println(file), "java").start(args); } } /* Output: .\AtUnitExample1.java .\AtUnitExample2.java .\AtUnitExample3.java .\AtUnitExample4.java .\AtUnitExample5.java .\AUComposition.java .\AUExternalTest.java .\database\Constraints.java .\database\DBTable.java .\database\Member.java .\database\SQLInteger.java .\database\SQLString.java .\database\TableCreator.java .\database\Uniqueness.java .\DemoProcessFiles.java .\HashSetTest.java .\ifx\ExtractInterface.java .\ifx\IfaceExtractorProcessor.java .\ifx\Multiplier.java .\PasswordUtils.java .\simplest\Simple.java .\simplest\SimpleProcessor.java .\simplest\SimpleTest.java .\SimulatingNull.java .\StackL.java .\StackLStringTst.java .\Testable.java .\UseCase.java .\UseCaseTracker.java */ OnJava8-Examples-1.0/annotations/HashSetTest.java000066400000000000000000000014751374004044700220050ustar00rootroot00000000000000// annotations/HashSetTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/HashSetTest.class} package annotations; import java.util.*; import onjava.atunit.*; import onjava.*; public class HashSetTest { HashSet testObject = new HashSet<>(); @Test void initialization() { assert testObject.isEmpty(); } @Test void tContains() { testObject.add("one"); assert testObject.contains("one"); } @Test void tRemove() { testObject.add("one"); testObject.remove("one"); assert testObject.isEmpty(); } } /* Output: annotations.HashSetTest . initialization . tRemove . tContains OK (3 tests) */ OnJava8-Examples-1.0/annotations/PasswordUtils.java000066400000000000000000000014231374004044700224220ustar00rootroot00000000000000// annotations/PasswordUtils.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class PasswordUtils { @UseCase(id = 47, description = "Passwords must contain at least one numeric") public boolean validatePassword(String passwd) { return (passwd.matches("\\w*\\d\\w*")); } @UseCase(id = 48) public String encryptPassword(String passwd) { return new StringBuilder(passwd) .reverse().toString(); } @UseCase(id = 49, description = "New passwords can't equal previously used ones") public boolean checkForNewPassword( List prevPasswords, String passwd) { return !prevPasswords.contains(passwd); } } OnJava8-Examples-1.0/annotations/SimulatingNull.java000066400000000000000000000006041374004044700225460ustar00rootroot00000000000000// annotations/SimulatingNull.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface SimulatingNull { int id() default -1; String description() default ""; } OnJava8-Examples-1.0/annotations/StackL.java000066400000000000000000000007411374004044700207620ustar00rootroot00000000000000// annotations/StackL.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A stack built on a LinkedList package annotations; import java.util.*; public class StackL { private LinkedList list = new LinkedList<>(); public void push(T v) { list.addFirst(v); } public T top() { return list.getFirst(); } public T pop() { return list.removeFirst(); } } OnJava8-Examples-1.0/annotations/StackLStringTst.java000066400000000000000000000015751374004044700226520ustar00rootroot00000000000000// annotations/StackLStringTst.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Applying @Unit to generics // {java onjava.atunit.AtUnit // build/classes/java/main/annotations/StackLStringTst.class} package annotations; import onjava.atunit.*; import onjava.*; public class StackLStringTst extends StackL { @Test void tPush() { push("one"); assert top().equals("one"); push("two"); assert top().equals("two"); } @Test void tPop() { push("one"); push("two"); assert pop().equals("two"); assert pop().equals("one"); } @Test void tTop() { push("A"); push("B"); assert top().equals("B"); assert top().equals("B"); } } /* Output: annotations.StackLStringTst . tTop . tPush . tPop OK (3 tests) */ OnJava8-Examples-1.0/annotations/Testable.java000066400000000000000000000005701374004044700213440ustar00rootroot00000000000000// annotations/Testable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package annotations; import onjava.atunit.*; public class Testable { public void execute() { System.out.println("Executing.."); } @Test void testExecute() { execute(); } } OnJava8-Examples-1.0/annotations/UseCase.java000066400000000000000000000005711374004044700211320ustar00rootroot00000000000000// annotations/UseCase.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface UseCase { int id(); String description() default "no description"; } OnJava8-Examples-1.0/annotations/UseCaseTracker.java000066400000000000000000000021621374004044700224440ustar00rootroot00000000000000// annotations/UseCaseTracker.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.lang.reflect.*; public class UseCaseTracker { public static void trackUseCases(List useCases, Class cl) { for(Method m : cl.getDeclaredMethods()) { UseCase uc = m.getAnnotation(UseCase.class); if(uc != null) { System.out.println("Found Use Case " + uc.id() + "\n " + uc.description()); useCases.remove(Integer.valueOf(uc.id())); } } useCases.forEach(i -> System.out.println("Missing use case " + i)); } public static void main(String[] args) { List useCases = IntStream.range(47, 51) .boxed().collect(Collectors.toList()); trackUseCases(useCases, PasswordUtils.class); } } /* Output: Found Use Case 48 no description Found Use Case 47 Passwords must contain at least one numeric Found Use Case 49 New passwords can't equal previously used ones Missing use case 50 */ OnJava8-Examples-1.0/annotations/database/000077500000000000000000000000001374004044700205005ustar00rootroot00000000000000OnJava8-Examples-1.0/annotations/database/Constraints.java000066400000000000000000000007261374004044700236570ustar00rootroot00000000000000// annotations/database/Constraints.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package annotations.database; import java.lang.annotation.*; @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface Constraints { boolean primaryKey() default false; boolean allowNull() default true; boolean unique() default false; } OnJava8-Examples-1.0/annotations/database/DBTable.java000066400000000000000000000006301374004044700225770ustar00rootroot00000000000000// annotations/database/DBTable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package annotations.database; import java.lang.annotation.*; @Target(ElementType.TYPE) // Applies to classes only @Retention(RetentionPolicy.RUNTIME) public @interface DBTable { String name() default ""; } OnJava8-Examples-1.0/annotations/database/Member.java000066400000000000000000000013631374004044700225550ustar00rootroot00000000000000// annotations/database/Member.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package annotations.database; @DBTable(name = "MEMBER") public class Member { @SQLString(30) String firstName; @SQLString(50) String lastName; @SQLInteger Integer age; @SQLString(value = 30, constraints = @Constraints(primaryKey = true)) String reference; static int memberCount; public String getReference() { return reference; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } @Override public String toString() { return reference; } public Integer getAge() { return age; } } OnJava8-Examples-1.0/annotations/database/SQLInteger.java000066400000000000000000000006661374004044700233300ustar00rootroot00000000000000// annotations/database/SQLInteger.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package annotations.database; import java.lang.annotation.*; @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface SQLInteger { String name() default ""; Constraints constraints() default @Constraints; } OnJava8-Examples-1.0/annotations/database/SQLString.java000066400000000000000000000007151374004044700231740ustar00rootroot00000000000000// annotations/database/SQLString.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package annotations.database; import java.lang.annotation.*; @Target(ElementType.FIELD) @Retention(RetentionPolicy.RUNTIME) public @interface SQLString { int value() default 0; String name() default ""; Constraints constraints() default @Constraints; } OnJava8-Examples-1.0/annotations/database/TableCreator.java000066400000000000000000000067611374004044700237240ustar00rootroot00000000000000// annotations/database/TableCreator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Reflection-based annotation processor // {java annotations.database.TableCreator // annotations.database.Member} package annotations.database; import java.lang.annotation.*; import java.lang.reflect.*; import java.util.*; public class TableCreator { public static void main(String[] args) throws Exception { if(args.length < 1) { System.out.println( "arguments: annotated classes"); System.exit(0); } for(String className : args) { Class cl = Class.forName(className); DBTable dbTable = cl.getAnnotation(DBTable.class); if(dbTable == null) { System.out.println( "No DBTable annotations in class " + className); continue; } String tableName = dbTable.name(); // If the name is empty, use the Class name: if(tableName.length() < 1) tableName = cl.getName().toUpperCase(); List columnDefs = new ArrayList<>(); for(Field field : cl.getDeclaredFields()) { String columnName = null; Annotation[] anns = field.getDeclaredAnnotations(); if(anns.length < 1) continue; // Not a db table column if(anns[0] instanceof SQLInteger) { SQLInteger sInt = (SQLInteger) anns[0]; // Use field name if name not specified if(sInt.name().length() < 1) columnName = field.getName().toUpperCase(); else columnName = sInt.name(); columnDefs.add(columnName + " INT" + getConstraints(sInt.constraints())); } if(anns[0] instanceof SQLString) { SQLString sString = (SQLString) anns[0]; // Use field name if name not specified. if(sString.name().length() < 1) columnName = field.getName().toUpperCase(); else columnName = sString.name(); columnDefs.add(columnName + " VARCHAR(" + sString.value() + ")" + getConstraints(sString.constraints())); } StringBuilder createCommand = new StringBuilder( "CREATE TABLE " + tableName + "("); for(String columnDef : columnDefs) createCommand.append( "\n " + columnDef + ","); // Remove trailing comma String tableCreate = createCommand.substring( 0, createCommand.length() - 1) + ");"; System.out.println("Table Creation SQL for " + className + " is:\n" + tableCreate); } } } private static String getConstraints(Constraints con) { String constraints = ""; if(!con.allowNull()) constraints += " NOT NULL"; if(con.primaryKey()) constraints += " PRIMARY KEY"; if(con.unique()) constraints += " UNIQUE"; return constraints; } } /* Output: Table Creation SQL for annotations.database.Member is: CREATE TABLE MEMBER( FIRSTNAME VARCHAR(30)); Table Creation SQL for annotations.database.Member is: CREATE TABLE MEMBER( FIRSTNAME VARCHAR(30), LASTNAME VARCHAR(50)); Table Creation SQL for annotations.database.Member is: CREATE TABLE MEMBER( FIRSTNAME VARCHAR(30), LASTNAME VARCHAR(50), AGE INT); Table Creation SQL for annotations.database.Member is: CREATE TABLE MEMBER( FIRSTNAME VARCHAR(30), LASTNAME VARCHAR(50), AGE INT, REFERENCE VARCHAR(30) PRIMARY KEY); */ OnJava8-Examples-1.0/annotations/database/Uniqueness.java000066400000000000000000000005551374004044700235070ustar00rootroot00000000000000// annotations/database/Uniqueness.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Sample of nested annotations package annotations.database; public @interface Uniqueness { Constraints constraints() default @Constraints(unique = true); } OnJava8-Examples-1.0/annotations/ifx/000077500000000000000000000000001374004044700175225ustar00rootroot00000000000000OnJava8-Examples-1.0/annotations/ifx/ExtractInterface.java000066400000000000000000000006661374004044700236300ustar00rootroot00000000000000// annotations/ifx/ExtractInterface.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // javac-based annotation processing package annotations.ifx; import java.lang.annotation.*; @Target(ElementType.TYPE) @Retention(RetentionPolicy.SOURCE) public @interface ExtractInterface { String interfaceName() default "-!!-"; } OnJava8-Examples-1.0/annotations/ifx/IfaceExtractorProcessor.java000066400000000000000000000055721374004044700252010ustar00rootroot00000000000000// annotations/ifx/IfaceExtractorProcessor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // javac-based annotation processing package annotations.ifx; import javax.annotation.processing.*; import javax.lang.model.SourceVersion; import javax.lang.model.element.*; import javax.lang.model.util.*; import java.util.*; import java.util.stream.*; import java.io.*; @SupportedAnnotationTypes( "annotations.ifx.ExtractInterface") @SupportedSourceVersion(SourceVersion.RELEASE_8) public class IfaceExtractorProcessor extends AbstractProcessor { private ArrayList interfaceMethods = new ArrayList<>(); Elements elementUtils; private ProcessingEnvironment processingEnv; @Override public void init( ProcessingEnvironment processingEnv) { this.processingEnv = processingEnv; elementUtils = processingEnv.getElementUtils(); } @Override public boolean process( Set annotations, RoundEnvironment env) { for(Element elem:env.getElementsAnnotatedWith( ExtractInterface.class)) { String interfaceName = elem.getAnnotation( ExtractInterface.class).interfaceName(); for(Element enclosed : elem.getEnclosedElements()) { if(enclosed.getKind() .equals(ElementKind.METHOD) && enclosed.getModifiers() .contains(Modifier.PUBLIC) && !enclosed.getModifiers() .contains(Modifier.STATIC)) { interfaceMethods.add(enclosed); } } if(interfaceMethods.size() > 0) writeInterfaceFile(interfaceName); } return false; } private void writeInterfaceFile(String interfaceName) { try( Writer writer = processingEnv.getFiler() .createSourceFile(interfaceName) .openWriter() ) { String packageName = elementUtils .getPackageOf(interfaceMethods .get(0)).toString(); writer.write( "package " + packageName + ";\n"); writer.write("public interface " + interfaceName + " {\n"); for(Element elem : interfaceMethods) { ExecutableElement method = (ExecutableElement)elem; String signature = " public "; signature += method.getReturnType() + " "; signature += method.getSimpleName(); signature += createArgList( method.getParameters()); System.out.println(signature); writer.write(signature + ";\n"); } writer.write("}"); } catch(Exception e) { throw new RuntimeException(e); } } private String createArgList( List parameters) { String args = parameters.stream() .map(p -> p.asType() + " " + p.getSimpleName()) .collect(Collectors.joining(", ")); return "(" + args + ")"; } } OnJava8-Examples-1.0/annotations/ifx/Multiplier.java000066400000000000000000000016061374004044700225160ustar00rootroot00000000000000// annotations/ifx/Multiplier.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // javac-based annotation processing // {java annotations.ifx.Multiplier} package annotations.ifx; @ExtractInterface(interfaceName="IMultiplier") public class Multiplier { public boolean flag = false; private int n = 0; public int multiply(int x, int y) { int total = 0; for(int i = 0; i < x; i++) total = add(total, y); return total; } public int fortySeven() { return 47; } private int add(int x, int y) { return x + y; } public double timesTen(double arg) { return arg * 10; } public static void main(String[] args) { Multiplier m = new Multiplier(); System.out.println( "11 * 16 = " + m.multiply(11, 16)); } } /* Output: 11 * 16 = 176 */ OnJava8-Examples-1.0/annotations/simplest/000077500000000000000000000000001374004044700205745ustar00rootroot00000000000000OnJava8-Examples-1.0/annotations/simplest/Simple.java000066400000000000000000000013271374004044700226730ustar00rootroot00000000000000// annotations/simplest/Simple.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A bare-bones annotation package annotations.simplest; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; import java.lang.annotation.Target; import java.lang.annotation.ElementType; @Retention(RetentionPolicy.SOURCE) @Target({ElementType.TYPE, ElementType.METHOD, ElementType.CONSTRUCTOR, ElementType.ANNOTATION_TYPE, ElementType.PACKAGE, ElementType.FIELD, ElementType.LOCAL_VARIABLE}) public @interface Simple { String value() default "-default-"; } OnJava8-Examples-1.0/annotations/simplest/SimpleProcessor.java000066400000000000000000000030651374004044700245740ustar00rootroot00000000000000// annotations/simplest/SimpleProcessor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A bare-bones annotation processor package annotations.simplest; import javax.annotation.processing.*; import javax.lang.model.SourceVersion; import javax.lang.model.element.*; import java.util.*; @SupportedAnnotationTypes( "annotations.simplest.Simple") @SupportedSourceVersion(SourceVersion.RELEASE_8) public class SimpleProcessor extends AbstractProcessor { @Override public boolean process( Set annotations, RoundEnvironment env) { for(TypeElement t : annotations) System.out.println(t); for(Element el : env.getElementsAnnotatedWith(Simple.class)) display(el); return false; } private void display(Element el) { System.out.println("==== " + el + " ===="); System.out.println(el.getKind() + " : " + el.getModifiers() + " : " + el.getSimpleName() + " : " + el.asType()); if(el.getKind().equals(ElementKind.CLASS)) { TypeElement te = (TypeElement)el; System.out.println(te.getQualifiedName()); System.out.println(te.getSuperclass()); System.out.println(te.getEnclosedElements()); } if(el.getKind().equals(ElementKind.METHOD)) { ExecutableElement ex = (ExecutableElement)el; System.out.print(ex.getReturnType() + " "); System.out.print(ex.getSimpleName() + "("); System.out.println(ex.getParameters() + ")"); } } } OnJava8-Examples-1.0/annotations/simplest/SimpleTest.java000066400000000000000000000013351374004044700235320ustar00rootroot00000000000000// annotations/simplest/SimpleTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Test the "Simple" annotation // {java annotations.simplest.SimpleTest} package annotations.simplest; @Simple public class SimpleTest { @Simple int i; @Simple public SimpleTest() {} @Simple public void foo() { System.out.println("SimpleTest.foo()"); } @Simple public void bar(String s, int i, float f) { System.out.println("SimpleTest.bar()"); } @Simple public static void main(String[] args) { @Simple SimpleTest st = new SimpleTest(); st.foo(); } } /* Output: SimpleTest.foo() */ OnJava8-Examples-1.0/appveyorXX.yml000066400000000000000000000001061374004044700172440ustar00rootroot00000000000000build_script: - gradlew.bat --no-daemon --stacktrace run test: off OnJava8-Examples-1.0/arrays/000077500000000000000000000000001374004044700157005ustar00rootroot00000000000000OnJava8-Examples-1.0/arrays/AlphabeticSearch.java000066400000000000000000000016711374004044700217320ustar00rootroot00000000000000// arrays/AlphabeticSearch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Searching with a Comparator import import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class AlphabeticSearch { public static void main(String[] args) { String[] sa = new Rand.String().array(30); Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER); show(sa); int index = Arrays.binarySearch(sa, sa[10], String.CASE_INSENSITIVE_ORDER); System.out.println( "Index: "+ index + "\n"+ sa[index]); } } /* Output: [anmkkyh, bhmupju, btpenpc, cjwzmmr, cuxszgv, eloztdv, ewcippc, ezdeklu, fcjpthl, fqmlgsh, gmeinne, hyoubzl, jbvlgwc, jlxpqds, ljlbynx, mvducuj, qgekgly, skddcat, taprwxz, uybypgp, vjsszkn, vniyapk, vqqakbm, vwodhcf, ydpulcq, ygpoalk, yskvett, zehpfmm, zofmmvm, zrxmclh] Index: 10 gmeinne */ OnJava8-Examples-1.0/arrays/ArrayCopying.java000066400000000000000000000043001374004044700211470ustar00rootroot00000000000000// arrays/ArrayCopying.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrate Arrays.copy() and Arrays.copyOf() import java.util.*; import onjava.*; import static onjava.ArrayShow.*; class Sup { // Superclass private int id; Sup(int n) { id = n; } @Override public String toString() { return getClass().getSimpleName() + id; } } class Sub extends Sup { // Subclass Sub(int n) { super(n); } } public class ArrayCopying { public static final int SZ = 15; public static void main(String[] args) { int[] a1 = new int[SZ]; Arrays.setAll(a1, new Count.Integer()::get); show("a1", a1); int[] a2 = Arrays.copyOf(a1, a1.length); // [1] // Prove they are distinct arrays: Arrays.fill(a1, 1); show("a1", a1); show("a2", a2); // Create a shorter result: a2 = Arrays.copyOf(a2, a2.length/2); // [2] show("a2", a2); // Allocate more space: a2 = Arrays.copyOf(a2, a2.length + 5); show("a2", a2); // Also copies wrapped arrays: Integer[] a3 = new Integer[SZ]; // [3] Arrays.setAll(a3, new Count.Integer()::get); Integer[] a4 = Arrays.copyOfRange(a3, 4, 12); show("a4", a4); Sub[] d = new Sub[SZ/2]; Arrays.setAll(d, Sub::new); // Produce Sup[] from Sub[]: Sup[] b = Arrays.copyOf(d, d.length, Sup[].class); // [4] show(b); // This "downcast" works fine: Sub[] d2 = Arrays.copyOf(b, b.length, Sub[].class); // [5] show(d2); // Bad "downcast" compiles but throws exception: Sup[] b2 = new Sup[SZ/2]; Arrays.setAll(b2, Sup::new); try { Sub[] d3 = Arrays.copyOf( b2, b2.length, Sub[].class); // [6] } catch(Exception e) { System.out.println(e); } } } /* Output: a1: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] a1: [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] a2: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] a2: [0, 1, 2, 3, 4, 5, 6] a2: [0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0] a4: [4, 5, 6, 7, 8, 9, 10, 11] [Sub0, Sub1, Sub2, Sub3, Sub4, Sub5, Sub6] [Sub0, Sub1, Sub2, Sub3, Sub4, Sub5, Sub6] java.lang.ArrayStoreException */ OnJava8-Examples-1.0/arrays/ArrayOfGenericType.java000066400000000000000000000010371374004044700222460ustar00rootroot00000000000000// arrays/ArrayOfGenericType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ArrayOfGenericType { T[] array; // OK @SuppressWarnings("unchecked") public ArrayOfGenericType(int size) { // error: generic array creation: //- array = new T[size]; array = (T[])new Object[size]; // unchecked cast } // error: generic array creation: //- public U[] makeArray() { return new U[10]; } } OnJava8-Examples-1.0/arrays/ArrayOfGenerics.java000066400000000000000000000021621374004044700215670ustar00rootroot00000000000000// arrays/ArrayOfGenerics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ArrayOfGenerics { @SuppressWarnings("unchecked") public static void main(String[] args) { List[] ls; List[] la = new List[10]; ls = (List[])la; // Unchecked cast ls[0] = new ArrayList<>(); //- ls[1] = new ArrayList(); // error: incompatible types: ArrayList // cannot be converted to List // ls[1] = new ArrayList(); // ^ // The problem: List is a subtype of Object Object[] objects = ls; // So assignment is OK // Compiles and runs without complaint: objects[1] = new ArrayList<>(); // However, if your needs are straightforward it is // possible to create an array of generics, albeit // with an "unchecked cast" warning: List[] spheres = (List[])new List[10]; Arrays.setAll(spheres, n -> new ArrayList<>()); } } OnJava8-Examples-1.0/arrays/ArrayOptions.java000066400000000000000000000043151374004044700212000ustar00rootroot00000000000000// arrays/ArrayOptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Initialization & re-assignment of arrays import java.util.*; import static onjava.ArrayShow.*; public class ArrayOptions { public static void main(String[] args) { // Arrays of objects: BerylliumSphere[] a; // Uninitialized local BerylliumSphere[] b = new BerylliumSphere[5]; // The references inside the array are // automatically initialized to null: show("b", b); BerylliumSphere[] c = new BerylliumSphere[4]; for(int i = 0; i < c.length; i++) if(c[i] == null) // Can test for null reference c[i] = new BerylliumSphere(); // Aggregate initialization: BerylliumSphere[] d = { new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere() }; // Dynamic aggregate initialization: a = new BerylliumSphere[]{ new BerylliumSphere(), new BerylliumSphere(), }; // (Trailing comma is optional) System.out.println("a.length = " + a.length); System.out.println("b.length = " + b.length); System.out.println("c.length = " + c.length); System.out.println("d.length = " + d.length); a = d; System.out.println("a.length = " + a.length); // Arrays of primitives: int[] e; // Null reference int[] f = new int[5]; // The primitives inside the array are // automatically initialized to zero: show("f", f); int[] g = new int[4]; for(int i = 0; i < g.length; i++) g[i] = i*i; int[] h = { 11, 47, 93 }; // Compile error: variable e not initialized: //- System.out.println("e.length = " + e.length); System.out.println("f.length = " + f.length); System.out.println("g.length = " + g.length); System.out.println("h.length = " + h.length); e = h; System.out.println("e.length = " + e.length); e = new int[]{ 1, 2 }; System.out.println("e.length = " + e.length); } } /* Output: b: [null, null, null, null, null] a.length = 2 b.length = 5 c.length = 4 d.length = 3 a.length = 3 f: [0, 0, 0, 0, 0] f.length = 5 g.length = 4 h.length = 3 e.length = 3 e.length = 2 */ OnJava8-Examples-1.0/arrays/ArraySearching.java000066400000000000000000000017711374004044700214530ustar00rootroot00000000000000// arrays/ArraySearching.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using Arrays.binarySearch() import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class ArraySearching { public static void main(String[] args) { Rand.Pint rand = new Rand.Pint(); int[] a = new Rand.Pint().array(25); Arrays.sort(a); show("Sorted array", a); while(true) { int r = rand.getAsInt(); int location = Arrays.binarySearch(a, r); if(location >= 0) { System.out.println( "Location of " + r + " is " + location + ", a[" + location + "] is " + a[location]); break; // Out of while loop } } } } /* Output: Sorted array: [125, 267, 635, 650, 1131, 1506, 1634, 2400, 2766, 3063, 3768, 3941, 4720, 4762, 4948, 5070, 5682, 5807, 6177, 6193, 6656, 7021, 8479, 8737, 9954] Location of 635 is 2, a[2] is 635 */ OnJava8-Examples-1.0/arrays/AssemblingMultidimensionalArrays.java000066400000000000000000000012261374004044700252500ustar00rootroot00000000000000// arrays/AssemblingMultidimensionalArrays.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating multidimensional arrays import java.util.*; public class AssemblingMultidimensionalArrays { public static void main(String[] args) { Integer[][] a; a = new Integer[3][]; for(int i = 0; i < a.length; i++) { a[i] = new Integer[3]; for(int j = 0; j < a[i].length; j++) a[i][j] = i * j; // Autoboxing } System.out.println(Arrays.deepToString(a)); } } /* Output: [[0, 0, 0], [0, 1, 2], [0, 2, 4]] */ OnJava8-Examples-1.0/arrays/AutoboxingArrays.java000066400000000000000000000013611374004044700220450ustar00rootroot00000000000000// arrays/AutoboxingArrays.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class AutoboxingArrays { public static void main(String[] args) { Integer[][] a = { // Autoboxing: { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, { 21, 22, 23, 24, 25, 26, 27, 28, 29, 30 }, { 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 }, { 71, 72, 73, 74, 75, 76, 77, 78, 79, 80 }, }; System.out.println(Arrays.deepToString(a)); } } /* Output: [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [21, 22, 23, 24, 25, 26, 27, 28, 29, 30], [51, 52, 53, 54, 55, 56, 57, 58, 59, 60], [71, 72, 73, 74, 75, 76, 77, 78, 79, 80]] */ OnJava8-Examples-1.0/arrays/CollectionComparison.java000066400000000000000000000025551374004044700227000ustar00rootroot00000000000000// arrays/CollectionComparison.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; import static onjava.ArrayShow.*; class BerylliumSphere { private static long counter; private final long id = counter++; @Override public String toString() { return "Sphere " + id; } } public class CollectionComparison { public static void main(String[] args) { BerylliumSphere[] spheres = new BerylliumSphere[10]; for(int i = 0; i < 5; i++) spheres[i] = new BerylliumSphere(); show(spheres); System.out.println(spheres[4]); List sphereList = Suppliers.create( ArrayList::new, BerylliumSphere::new, 5); System.out.println(sphereList); System.out.println(sphereList.get(4)); int[] integers = { 0, 1, 2, 3, 4, 5 }; show(integers); System.out.println(integers[4]); List intList = new ArrayList<>( Arrays.asList(0, 1, 2, 3, 4, 5)); intList.add(97); System.out.println(intList); System.out.println(intList.get(4)); } } /* Output: [Sphere 0, Sphere 1, Sphere 2, Sphere 3, Sphere 4, null, null, null, null, null] Sphere 4 [Sphere 5, Sphere 6, Sphere 7, Sphere 8, Sphere 9] Sphere 9 [0, 1, 2, 3, 4, 5] 4 [0, 1, 2, 3, 4, 5, 97] 4 */ OnJava8-Examples-1.0/arrays/CompType.java000066400000000000000000000031101374004044700202760ustar00rootroot00000000000000// arrays/CompType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Implementing Comparable in a class import java.util.*; import java.util.function.*; import onjava.*; import static onjava.ArrayShow.*; public class CompType implements Comparable { int i; int j; private static int count = 1; public CompType(int n1, int n2) { i = n1; j = n2; } @Override public String toString() { String result = "[i = " + i + ", j = " + j + "]"; if(count++ % 3 == 0) result += "\n"; return result; } @Override public int compareTo(CompType rv) { return (i < rv.i ? -1 : (i == rv.i ? 0 : 1)); } private static SplittableRandom r = new SplittableRandom(47); public static CompType get() { return new CompType(r.nextInt(100), r.nextInt(100)); } public static void main(String[] args) { CompType[] a = new CompType[12]; Arrays.setAll(a, n -> get()); show("Before sorting", a); Arrays.sort(a); show("After sorting", a); } } /* Output: Before sorting: [[i = 35, j = 37], [i = 41, j = 20], [i = 77, j = 79] , [i = 56, j = 68], [i = 48, j = 93], [i = 70, j = 7] , [i = 0, j = 25], [i = 62, j = 34], [i = 50, j = 82] , [i = 31, j = 67], [i = 66, j = 54], [i = 21, j = 6] ] After sorting: [[i = 0, j = 25], [i = 21, j = 6], [i = 31, j = 67] , [i = 35, j = 37], [i = 41, j = 20], [i = 48, j = 93] , [i = 50, j = 82], [i = 56, j = 68], [i = 62, j = 34] , [i = 66, j = 54], [i = 70, j = 7], [i = 77, j = 79] ] */ OnJava8-Examples-1.0/arrays/ComparatorTest.java000066400000000000000000000023071374004044700215140ustar00rootroot00000000000000// arrays/ComparatorTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Implementing a Comparator for a class import java.util.*; import onjava.*; import static onjava.ArrayShow.*; class CompTypeComparator implements Comparator { public int compare(CompType o1, CompType o2) { return (o1.j < o2.j ? -1 : (o1.j == o2.j ? 0 : 1)); } } public class ComparatorTest { public static void main(String[] args) { CompType[] a = new CompType[12]; Arrays.setAll(a, n -> CompType.get()); show("Before sorting", a); Arrays.sort(a, new CompTypeComparator()); show("After sorting", a); } } /* Output: Before sorting: [[i = 35, j = 37], [i = 41, j = 20], [i = 77, j = 79] , [i = 56, j = 68], [i = 48, j = 93], [i = 70, j = 7] , [i = 0, j = 25], [i = 62, j = 34], [i = 50, j = 82] , [i = 31, j = 67], [i = 66, j = 54], [i = 21, j = 6] ] After sorting: [[i = 21, j = 6], [i = 70, j = 7], [i = 41, j = 20] , [i = 0, j = 25], [i = 62, j = 34], [i = 35, j = 37] , [i = 66, j = 54], [i = 31, j = 67], [i = 56, j = 68] , [i = 77, j = 79], [i = 50, j = 82], [i = 48, j = 93] ] */ OnJava8-Examples-1.0/arrays/ComparingArrays.java000066400000000000000000000037301374004044700216470ustar00rootroot00000000000000// arrays/ComparingArrays.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using Arrays.equals() import java.util.*; import onjava.*; public class ComparingArrays { public static final int SZ = 15; static String[][] twoDArray() { String[][] md = new String[5][]; Arrays.setAll(md, n -> new String[n]); for(int i = 0; i < md.length; i++) Arrays.setAll(md[i], new Rand.String()::get); return md; } public static void main(String[] args) { int[] a1 = new int[SZ], a2 = new int[SZ]; Arrays.setAll(a1, new Count.Integer()::get); Arrays.setAll(a2, new Count.Integer()::get); System.out.println( "a1 == a2: " + Arrays.equals(a1, a2)); a2[3] = 11; System.out.println( "a1 == a2: " + Arrays.equals(a1, a2)); Integer[] a1w = new Integer[SZ], a2w = new Integer[SZ]; Arrays.setAll(a1w, new Count.Integer()::get); Arrays.setAll(a2w, new Count.Integer()::get); System.out.println( "a1w == a2w: " + Arrays.equals(a1w, a2w)); a2w[3] = 11; System.out.println( "a1w == a2w: " + Arrays.equals(a1w, a2w)); String[][] md1 = twoDArray(), md2 = twoDArray(); System.out.println(Arrays.deepToString(md1)); System.out.println("deepEquals(md1, md2): " + Arrays.deepEquals(md1, md2)); System.out.println( "md1 == md2: " + Arrays.equals(md1, md2)); md1[4][1] = "#$#$#$#"; System.out.println(Arrays.deepToString(md1)); System.out.println("deepEquals(md1, md2): " + Arrays.deepEquals(md1, md2)); } } /* Output: a1 == a2: true a1 == a2: false a1w == a2w: true a1w == a2w: false [[], [btpenpc], [btpenpc, cuxszgv], [btpenpc, cuxszgv, gmeinne], [btpenpc, cuxszgv, gmeinne, eloztdv]] deepEquals(md1, md2): true md1 == md2: false [[], [btpenpc], [btpenpc, cuxszgv], [btpenpc, cuxszgv, gmeinne], [btpenpc, #$#$#$#, gmeinne, eloztdv]] deepEquals(md1, md2): false */ OnJava8-Examples-1.0/arrays/CountUpward.java000066400000000000000000000013041374004044700210140ustar00rootroot00000000000000// arrays/CountUpward.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import static onjava.ArrayShow.*; public class CountUpward { static long[] fillCounted(int size) { return LongStream.iterate(0, i -> i + 1) .limit(size).toArray(); } public static void main(String[] args) { long[] l1 = fillCounted(20); // No problem show(l1); // On my machine, this runs out of heap space: //- long[] l2 = fillCounted(10_000_000); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19] */ OnJava8-Examples-1.0/arrays/FillingArrays.java000066400000000000000000000030151374004044700213100ustar00rootroot00000000000000// arrays/FillingArrays.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using Arrays.fill() import java.util.*; import static onjava.ArrayShow.*; public class FillingArrays { public static void main(String[] args) { int size = 6; boolean[] a1 = new boolean[size]; byte[] a2 = new byte[size]; char[] a3 = new char[size]; short[] a4 = new short[size]; int[] a5 = new int[size]; long[] a6 = new long[size]; float[] a7 = new float[size]; double[] a8 = new double[size]; String[] a9 = new String[size]; Arrays.fill(a1, true); show("a1", a1); Arrays.fill(a2, (byte)11); show("a2", a2); Arrays.fill(a3, 'x'); show("a3", a3); Arrays.fill(a4, (short)17); show("a4", a4); Arrays.fill(a5, 19); show("a5", a5); Arrays.fill(a6, 23); show("a6", a6); Arrays.fill(a7, 29); show("a7", a7); Arrays.fill(a8, 47); show("a8", a8); Arrays.fill(a9, "Hello"); show("a9", a9); // Manipulating ranges: Arrays.fill(a9, 3, 5, "World"); show("a9", a9); } } /* Output: a1: [true, true, true, true, true, true] a2: [11, 11, 11, 11, 11, 11] a3: [x, x, x, x, x, x] a4: [17, 17, 17, 17, 17, 17] a5: [19, 19, 19, 19, 19, 19] a6: [23, 23, 23, 23, 23, 23] a7: [29.0, 29.0, 29.0, 29.0, 29.0, 29.0] a8: [47.0, 47.0, 47.0, 47.0, 47.0, 47.0] a9: [Hello, Hello, Hello, Hello, Hello, Hello] a9: [Hello, Hello, Hello, World, World, Hello] */ OnJava8-Examples-1.0/arrays/IceCreamFlavors.java000066400000000000000000000026111374004044700215500ustar00rootroot00000000000000// arrays/IceCreamFlavors.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Returning arrays from methods import java.util.*; import static onjava.ArrayShow.*; public class IceCreamFlavors { private static SplittableRandom rand = new SplittableRandom(47); static final String[] FLAVORS = { "Chocolate", "Strawberry", "Vanilla Fudge Swirl", "Mint Chip", "Mocha Almond Fudge", "Rum Raisin", "Praline Cream", "Mud Pie" }; public static String[] flavorSet(int n) { if(n > FLAVORS.length) throw new IllegalArgumentException("Set too big"); String[] results = new String[n]; boolean[] picked = new boolean[FLAVORS.length]; for(int i = 0; i < n; i++) { int t; do t = rand.nextInt(FLAVORS.length); while(picked[t]); results[i] = FLAVORS[t]; picked[t] = true; } return results; } public static void main(String[] args) { for(int i = 0; i < 7; i++) show(flavorSet(3)); } } /* Output: [Praline Cream, Mint Chip, Vanilla Fudge Swirl] [Strawberry, Vanilla Fudge Swirl, Mud Pie] [Chocolate, Strawberry, Vanilla Fudge Swirl] [Rum Raisin, Praline Cream, Chocolate] [Mint Chip, Rum Raisin, Mocha Almond Fudge] [Mocha Almond Fudge, Mud Pie, Vanilla Fudge Swirl] [Mocha Almond Fudge, Mud Pie, Mint Chip] */ OnJava8-Examples-1.0/arrays/ModifyExisting.java000066400000000000000000000012161374004044700215050ustar00rootroot00000000000000// arrays/ModifyExisting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class ModifyExisting { public static void main(String[] args) { double[] da = new double[7]; Arrays.setAll(da, new Rand.Double()::get); show(da); Arrays.setAll(da, n -> da[n] / 100); // [1] show(da); } } /* Output: [4.83, 2.89, 2.9, 1.97, 3.01, 0.18, 0.99] [0.0483, 0.028900000000000002, 0.028999999999999998, 0.0197, 0.0301, 0.0018, 0.009899999999999999] */ OnJava8-Examples-1.0/arrays/MultiDimWrapperArray.java000066400000000000000000000021741374004044700226330ustar00rootroot00000000000000// arrays/MultiDimWrapperArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Multidimensional arrays of "wrapper" objects import java.util.*; public class MultiDimWrapperArray { public static void main(String[] args) { Integer[][] a1 = { // Autoboxing { 1, 2, 3, }, { 4, 5, 6, }, }; Double[][][] a2 = { // Autoboxing { { 1.1, 2.2 }, { 3.3, 4.4 } }, { { 5.5, 6.6 }, { 7.7, 8.8 } }, { { 9.9, 1.2 }, { 2.3, 3.4 } }, }; String[][] a3 = { { "The", "Quick", "Sly", "Fox" }, { "Jumped", "Over" }, { "The", "Lazy", "Brown", "Dog", "&", "friend" }, }; System.out.println( "a1: " + Arrays.deepToString(a1)); System.out.println( "a2: " + Arrays.deepToString(a2)); System.out.println( "a3: " + Arrays.deepToString(a3)); } } /* Output: a1: [[1, 2, 3], [4, 5, 6]] a2: [[[1.1, 2.2], [3.3, 4.4]], [[5.5, 6.6], [7.7, 8.8]], [[9.9, 1.2], [2.3, 3.4]]] a3: [[The, Quick, Sly, Fox], [Jumped, Over], [The, Lazy, Brown, Dog, &, friend]] */ OnJava8-Examples-1.0/arrays/MultidimensionalObjectArrays.java000066400000000000000000000017061374004044700243750ustar00rootroot00000000000000// arrays/MultidimensionalObjectArrays.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class MultidimensionalObjectArrays { public static void main(String[] args) { BerylliumSphere[][] spheres = { { new BerylliumSphere(), new BerylliumSphere() }, { new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere() }, { new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere(), new BerylliumSphere() }, }; System.out.println(Arrays.deepToString(spheres)); } } /* Output: [[Sphere 0, Sphere 1], [Sphere 2, Sphere 3, Sphere 4, Sphere 5], [Sphere 6, Sphere 7, Sphere 8, Sphere 9, Sphere 10, Sphere 11, Sphere 12, Sphere 13]] */ OnJava8-Examples-1.0/arrays/MultidimensionalPrimitiveArray.java000066400000000000000000000007321374004044700247520ustar00rootroot00000000000000// arrays/MultidimensionalPrimitiveArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class MultidimensionalPrimitiveArray { public static void main(String[] args) { int[][] a = { { 1, 2, 3, }, { 4, 5, 6, }, }; System.out.println(Arrays.deepToString(a)); } } /* Output: [[1, 2, 3], [4, 5, 6]] */ OnJava8-Examples-1.0/arrays/ParallelPrefix1.java000066400000000000000000000013611374004044700215370ustar00rootroot00000000000000// arrays/ParallelPrefix1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class ParallelPrefix1 { public static void main(String[] args) { int[] nums = new Count.Pint().array(10); show(nums); System.out.println(Arrays.stream(nums) .reduce(Integer::sum).getAsInt()); Arrays.parallelPrefix(nums, Integer::sum); show(nums); System.out.println(Arrays.stream( new Count.Pint().array(6)) .reduce(Integer::sum).getAsInt()); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 45 [0, 1, 3, 6, 10, 15, 21, 28, 36, 45] 15 */ OnJava8-Examples-1.0/arrays/ParallelPrefix2.java000066400000000000000000000011041374004044700215330ustar00rootroot00000000000000// arrays/ParallelPrefix2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class ParallelPrefix2 { public static void main(String[] args) { String[] strings = new Rand.String(1).array(8); show(strings); Arrays.parallelPrefix(strings, (a, b) -> a + b); show(strings); } } /* Output: [b, t, p, e, n, p, c, c] [b, bt, btp, btpe, btpen, btpenp, btpenpc, btpenpcc] */ OnJava8-Examples-1.0/arrays/ParallelPrefix3.java000066400000000000000000000012601374004044700215370ustar00rootroot00000000000000// arrays/ParallelPrefix3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromTravisCI} import java.util.*; public class ParallelPrefix3 { static final int SIZE = 10_000_000; public static void main(String[] args) { long[] nums = new long[SIZE]; Arrays.setAll(nums, n -> n); Arrays.parallelPrefix(nums, Long::sum); System.out.println("First 20: " + nums[19]); System.out.println("First 200: " + nums[199]); System.out.println("All: " + nums[nums.length-1]); } } /* Output: First 20: 190 First 200: 19900 All: 49999995000000 */ OnJava8-Examples-1.0/arrays/ParallelSetAll.java000066400000000000000000000012771374004044700214130ustar00rootroot00000000000000// arrays/ParallelSetAll.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; public class ParallelSetAll { static final int SIZE = 10_000_000; static void intArray() { int[] ia = new int[SIZE]; Arrays.setAll(ia, new Rand.Pint()::get); Arrays.parallelSetAll(ia, new Rand.Pint()::get); } static void longArray() { long[] la = new long[SIZE]; Arrays.setAll(la, new Rand.Plong()::get); Arrays.parallelSetAll(la, new Rand.Plong()::get); } public static void main(String[] args) { intArray(); longArray(); } } OnJava8-Examples-1.0/arrays/ParameterizedArrayType.java000066400000000000000000000013511374004044700232000ustar00rootroot00000000000000// arrays/ParameterizedArrayType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class ClassParameter { public T[] f(T[] arg) { return arg; } } class MethodParameter { public static T[] f(T[] arg) { return arg; } } public class ParameterizedArrayType { public static void main(String[] args) { Integer[] ints = { 1, 2, 3, 4, 5 }; Double[] doubles = { 1.1, 2.2, 3.3, 4.4, 5.5 }; Integer[] ints2 = new ClassParameter().f(ints); Double[] doubles2 = new ClassParameter().f(doubles); ints2 = MethodParameter.f(ints); doubles2 = MethodParameter.f(doubles); } } OnJava8-Examples-1.0/arrays/PythonLists.py000066400000000000000000000017761374004044700205650ustar00rootroot00000000000000# arrays/PythonLists.py # (c)2020 MindView LLC: see Copyright.txt # We make no guarantees that this code is fit for any purpose. # Visit http://OnJava8.com for more book information. aList = [1, 2, 3, 4, 5] print(type(aList)) # print(aList) # [1, 2, 3, 4, 5] print(aList[4]) # 5 Basic list indexing aList.append(6) # lists can be resized aList += [7, 8] # Add a list to a list print(aList) # [1, 2, 3, 4, 5, 6, 7, 8] aSlice = aList[2:4] print(aSlice) # [3, 4] class MyList(list): # Inherit from list # Define a method; 'this' pointer is explicit: def getReversed(self): reversed = self[:] # Copy list using slices reversed.reverse() # Built-in list method return reversed # No 'new' necessary for object creation: list2 = MyList(aList) print(type(list2)) # print(list2.getReversed()) # [8, 7, 6, 5, 4, 3, 2, 1] output = """ [1, 2, 3, 4, 5] 5 [1, 2, 3, 4, 5, 6, 7, 8] [3, 4] [8, 7, 6, 5, 4, 3, 2, 1] """ OnJava8-Examples-1.0/arrays/RaggedArray.java000066400000000000000000000014601374004044700207340ustar00rootroot00000000000000// arrays/RaggedArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class RaggedArray { static int val = 1; public static void main(String[] args) { SplittableRandom rand = new SplittableRandom(47); // 3-D array with varied-length vectors: int[][][] a = new int[rand.nextInt(7)][][]; for(int i = 0; i < a.length; i++) { a[i] = new int[rand.nextInt(5)][]; for(int j = 0; j < a[i].length; j++) { a[i][j] = new int[rand.nextInt(5)]; Arrays.setAll(a[i][j], n -> val++); // [1] } } System.out.println(Arrays.deepToString(a)); } } /* Output: [[[1], []], [[2, 3, 4, 5], [6]], [[7, 8, 9], [10, 11, 12], []]] */ OnJava8-Examples-1.0/arrays/Reverse.java000066400000000000000000000020241374004044700201540ustar00rootroot00000000000000// arrays/Reverse.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The Collections.reverseOrder() Comparator import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class Reverse { public static void main(String[] args) { CompType[] a = new CompType[12]; Arrays.setAll(a, n -> CompType.get()); show("Before sorting", a); Arrays.sort(a, Collections.reverseOrder()); show("After sorting", a); } } /* Output: Before sorting: [[i = 35, j = 37], [i = 41, j = 20], [i = 77, j = 79] , [i = 56, j = 68], [i = 48, j = 93], [i = 70, j = 7] , [i = 0, j = 25], [i = 62, j = 34], [i = 50, j = 82] , [i = 31, j = 67], [i = 66, j = 54], [i = 21, j = 6] ] After sorting: [[i = 77, j = 79], [i = 70, j = 7], [i = 66, j = 54] , [i = 62, j = 34], [i = 56, j = 68], [i = 50, j = 82] , [i = 48, j = 93], [i = 41, j = 20], [i = 35, j = 37] , [i = 31, j = 67], [i = 21, j = 6], [i = 0, j = 25] ] */ OnJava8-Examples-1.0/arrays/SimpleSetAll.java000066400000000000000000000027131374004044700211040ustar00rootroot00000000000000// arrays/SimpleSetAll.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import static onjava.ArrayShow.*; class Bob { final int id; Bob(int n) { id = n; } @Override public String toString() { return "Bob" + id; } } public class SimpleSetAll { public static final int SZ = 8; static int val = 1; static char[] chars = "abcdefghijklmnopqrstuvwxyz" .toCharArray(); static char getChar(int n) { return chars[n]; } public static void main(String[] args) { int[] ia = new int[SZ]; long[] la = new long[SZ]; double[] da = new double[SZ]; Arrays.setAll(ia, n -> n); // [1] Arrays.setAll(la, n -> n); Arrays.setAll(da, n -> n); show(ia); show(la); show(da); Arrays.setAll(ia, n -> val++); // [2] Arrays.setAll(la, n -> val++); Arrays.setAll(da, n -> val++); show(ia); show(la); show(da); Bob[] ba = new Bob[SZ]; Arrays.setAll(ba, Bob::new); // [3] show(ba); Character[] ca = new Character[SZ]; Arrays.setAll(ca, SimpleSetAll::getChar); // [4] show(ca); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7] [0, 1, 2, 3, 4, 5, 6, 7] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0] [1, 2, 3, 4, 5, 6, 7, 8] [9, 10, 11, 12, 13, 14, 15, 16] [17.0, 18.0, 19.0, 20.0, 21.0, 22.0, 23.0, 24.0] [Bob0, Bob1, Bob2, Bob3, Bob4, Bob5, Bob6, Bob7] [a, b, c, d, e, f, g, h] */ OnJava8-Examples-1.0/arrays/StreamFromArray.java000066400000000000000000000022701374004044700216220ustar00rootroot00000000000000// arrays/StreamFromArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; public class StreamFromArray { public static void main(String[] args) { String[] s = new Rand.String().array(10); Arrays.stream(s) .skip(3) .limit(5) .map(ss -> ss + "!") .forEach(System.out::println); int[] ia = new Rand.Pint().array(10); Arrays.stream(ia) .skip(3) .limit(5) .map(i -> i * 10) .forEach(System.out::println); Arrays.stream(new long[10]); Arrays.stream(new double[10]); // Only int, long and double work: //- Arrays.stream(new boolean[10]); //- Arrays.stream(new byte[10]); //- Arrays.stream(new char[10]); //- Arrays.stream(new short[10]); //- Arrays.stream(new float[10]); // For the other types you must use wrapped arrays: float[] fa = new Rand.Pfloat().array(10); Arrays.stream(ConvertTo.boxed(fa)); Arrays.stream(new Rand.Float().array(10)); } } /* Output: eloztdv! ewcippc! ygpoalk! ljlbynx! taprwxz! 47200 61770 84790 66560 37680 */ OnJava8-Examples-1.0/arrays/StringSorting.java000066400000000000000000000026731374004044700213670ustar00rootroot00000000000000// arrays/StringSorting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Sorting an array of Strings import java.util.*; import onjava.*; import static onjava.ArrayShow.*; public class StringSorting { public static void main(String[] args) { String[] sa = new Rand.String().array(20); show("Before sort", sa); Arrays.sort(sa); show("After sort", sa); Arrays.sort(sa, Collections.reverseOrder()); show("Reverse sort", sa); Arrays.sort(sa, String.CASE_INSENSITIVE_ORDER); show("Case-insensitive sort", sa); } } /* Output: Before sort: [btpenpc, cuxszgv, gmeinne, eloztdv, ewcippc, ygpoalk, ljlbynx, taprwxz, bhmupju, cjwzmmr, anmkkyh, fcjpthl, skddcat, jbvlgwc, mvducuj, ydpulcq, zehpfmm, zrxmclh, qgekgly, hyoubzl] After sort: [anmkkyh, bhmupju, btpenpc, cjwzmmr, cuxszgv, eloztdv, ewcippc, fcjpthl, gmeinne, hyoubzl, jbvlgwc, ljlbynx, mvducuj, qgekgly, skddcat, taprwxz, ydpulcq, ygpoalk, zehpfmm, zrxmclh] Reverse sort: [zrxmclh, zehpfmm, ygpoalk, ydpulcq, taprwxz, skddcat, qgekgly, mvducuj, ljlbynx, jbvlgwc, hyoubzl, gmeinne, fcjpthl, ewcippc, eloztdv, cuxszgv, cjwzmmr, btpenpc, bhmupju, anmkkyh] Case-insensitive sort: [anmkkyh, bhmupju, btpenpc, cjwzmmr, cuxszgv, eloztdv, ewcippc, fcjpthl, gmeinne, hyoubzl, jbvlgwc, ljlbynx, mvducuj, qgekgly, skddcat, taprwxz, ydpulcq, ygpoalk, zehpfmm, zrxmclh] */ OnJava8-Examples-1.0/arrays/TestConvertTo.java000066400000000000000000000047771374004044700213450ustar00rootroot00000000000000// arrays/TestConvertTo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.*; import static onjava.ArrayShow.*; import static onjava.ConvertTo.*; public class TestConvertTo { static final int SIZE = 6; public static void main(String[] args) { Boolean[] a1 = new Boolean[SIZE]; Arrays.setAll(a1, new Rand.Boolean()::get); boolean[] a1p = primitive(a1); show("a1p", a1p); Boolean[] a1b = boxed(a1p); show("a1b", a1b); Byte[] a2 = new Byte[SIZE]; Arrays.setAll(a2, new Rand.Byte()::get); byte[] a2p = primitive(a2); show("a2p", a2p); Byte[] a2b = boxed(a2p); show("a2b", a2b); Character[] a3 = new Character[SIZE]; Arrays.setAll(a3, new Rand.Character()::get); char[] a3p = primitive(a3); show("a3p", a3p); Character[] a3b = boxed(a3p); show("a3b", a3b); Short[] a4 = new Short[SIZE]; Arrays.setAll(a4, new Rand.Short()::get); short[] a4p = primitive(a4); show("a4p", a4p); Short[] a4b = boxed(a4p); show("a4b", a4b); Integer[] a5 = new Integer[SIZE]; Arrays.setAll(a5, new Rand.Integer()::get); int[] a5p = primitive(a5); show("a5p", a5p); Integer[] a5b = boxed(a5p); show("a5b", a5b); Long[] a6 = new Long[SIZE]; Arrays.setAll(a6, new Rand.Long()::get); long[] a6p = primitive(a6); show("a6p", a6p); Long[] a6b = boxed(a6p); show("a6b", a6b); Float[] a7 = new Float[SIZE]; Arrays.setAll(a7, new Rand.Float()::get); float[] a7p = primitive(a7); show("a7p", a7p); Float[] a7b = boxed(a7p); show("a7b", a7b); Double[] a8 = new Double[SIZE]; Arrays.setAll(a8, new Rand.Double()::get); double[] a8p = primitive(a8); show("a8p", a8p); Double[] a8b = boxed(a8p); show("a8b", a8b); } } /* Output: a1p: [true, false, true, true, true, false] a1b: [true, false, true, true, true, false] a2p: [123, 33, 101, 112, 33, 31] a2b: [123, 33, 101, 112, 33, 31] a3p: [b, t, p, e, n, p] a3b: [b, t, p, e, n, p] a4p: [635, 8737, 3941, 4720, 6177, 8479] a4b: [635, 8737, 3941, 4720, 6177, 8479] a5p: [635, 8737, 3941, 4720, 6177, 8479] a5b: [635, 8737, 3941, 4720, 6177, 8479] a6p: [6882, 3765, 692, 9575, 4439, 2638] a6b: [6882, 3765, 692, 9575, 4439, 2638] a7p: [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] a7b: [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] a8p: [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] a8b: [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] */ OnJava8-Examples-1.0/arrays/TestCount.java000066400000000000000000000107351374004044700205010ustar00rootroot00000000000000// arrays/TestCount.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Test counting generators import java.util.*; import java.util.stream.*; import onjava.*; import static onjava.ArrayShow.*; public class TestCount { static final int SZ = 5; public static void main(String[] args) { System.out.println("Boolean"); Boolean[] a1 = new Boolean[SZ]; Arrays.setAll(a1, new Count.Boolean()::get); show(a1); a1 = Stream.generate(new Count.Boolean()) .limit(SZ + 1).toArray(Boolean[]::new); show(a1); a1 = new Count.Boolean().array(SZ + 2); show(a1); boolean[] a1b = new Count.Pboolean().array(SZ + 3); show(a1b); System.out.println("Byte"); Byte[] a2 = new Byte[SZ]; Arrays.setAll(a2, new Count.Byte()::get); show(a2); a2 = Stream.generate(new Count.Byte()) .limit(SZ + 1).toArray(Byte[]::new); show(a2); a2 = new Count.Byte().array(SZ + 2); show(a2); byte[] a2b = new Count.Pbyte().array(SZ + 3); show(a2b); System.out.println("Character"); Character[] a3 = new Character[SZ]; Arrays.setAll(a3, new Count.Character()::get); show(a3); a3 = Stream.generate(new Count.Character()) .limit(SZ + 1).toArray(Character[]::new); show(a3); a3 = new Count.Character().array(SZ + 2); show(a3); char[] a3b = new Count.Pchar().array(SZ + 3); show(a3b); System.out.println("Short"); Short[] a4 = new Short[SZ]; Arrays.setAll(a4, new Count.Short()::get); show(a4); a4 = Stream.generate(new Count.Short()) .limit(SZ + 1).toArray(Short[]::new); show(a4); a4 = new Count.Short().array(SZ + 2); show(a4); short[] a4b = new Count.Pshort().array(SZ + 3); show(a4b); System.out.println("Integer"); int[] a5 = new int[SZ]; Arrays.setAll(a5, new Count.Integer()::get); show(a5); Integer[] a5b = Stream.generate(new Count.Integer()) .limit(SZ + 1).toArray(Integer[]::new); show(a5b); a5b = new Count.Integer().array(SZ + 2); show(a5b); a5 = IntStream.generate(new Count.Pint()) .limit(SZ + 1).toArray(); show(a5); a5 = new Count.Pint().array(SZ + 3); show(a5); System.out.println("Long"); long[] a6 = new long[SZ]; Arrays.setAll(a6, new Count.Long()::get); show(a6); Long[] a6b = Stream.generate(new Count.Long()) .limit(SZ + 1).toArray(Long[]::new); show(a6b); a6b = new Count.Long().array(SZ + 2); show(a6b); a6 = LongStream.generate(new Count.Plong()) .limit(SZ + 1).toArray(); show(a6); a6 = new Count.Plong().array(SZ + 3); show(a6); System.out.println("Float"); Float[] a7 = new Float[SZ]; Arrays.setAll(a7, new Count.Float()::get); show(a7); a7 = Stream.generate(new Count.Float()) .limit(SZ + 1).toArray(Float[]::new); show(a7); a7 = new Count.Float().array(SZ + 2); show(a7); float[] a7b = new Count.Pfloat().array(SZ + 3); show(a7b); System.out.println("Double"); double[] a8 = new double[SZ]; Arrays.setAll(a8, new Count.Double()::get); show(a8); Double[] a8b = Stream.generate(new Count.Double()) .limit(SZ + 1).toArray(Double[]::new); show(a8b); a8b = new Count.Double().array(SZ + 2); show(a8b); a8 = DoubleStream.generate(new Count.Pdouble()) .limit(SZ + 1).toArray(); show(a8); a8 = new Count.Pdouble().array(SZ + 3); show(a8); } } /* Output: Boolean [false, true, false, true, false] [false, true, false, true, false, true] [false, true, false, true, false, true, false] [false, true, false, true, false, true, false, true] Byte [0, 1, 2, 3, 4] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4, 5, 6, 7] Character [b, c, d, e, f] [b, c, d, e, f, g] [b, c, d, e, f, g, h] [b, c, d, e, f, g, h, i] Short [0, 1, 2, 3, 4] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4, 5, 6, 7] Integer [0, 1, 2, 3, 4] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6, 7] Long [0, 1, 2, 3, 4] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6] [0, 1, 2, 3, 4, 5] [0, 1, 2, 3, 4, 5, 6, 7] Float [0.0, 1.0, 2.0, 3.0, 4.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0] Double [0.0, 1.0, 2.0, 3.0, 4.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0] [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0] */ OnJava8-Examples-1.0/arrays/TestRand.java000066400000000000000000000127611374004044700202760ustar00rootroot00000000000000// arrays/TestRand.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Test random generators import java.util.*; import java.util.stream.*; import onjava.*; import static onjava.ArrayShow.*; public class TestRand { static final int SZ = 5; public static void main(String[] args) { System.out.println("Boolean"); Boolean[] a1 = new Boolean[SZ]; Arrays.setAll(a1, new Rand.Boolean()::get); show(a1); a1 = Stream.generate(new Rand.Boolean()) .limit(SZ + 1).toArray(Boolean[]::new); show(a1); a1 = new Rand.Boolean().array(SZ + 2); show(a1); boolean[] a1b = new Rand.Pboolean().array(SZ + 3); show(a1b); System.out.println("Byte"); Byte[] a2 = new Byte[SZ]; Arrays.setAll(a2, new Rand.Byte()::get); show(a2); a2 = Stream.generate(new Rand.Byte()) .limit(SZ + 1).toArray(Byte[]::new); show(a2); a2 = new Rand.Byte().array(SZ + 2); show(a2); byte[] a2b = new Rand.Pbyte().array(SZ + 3); show(a2b); System.out.println("Character"); Character[] a3 = new Character[SZ]; Arrays.setAll(a3, new Rand.Character()::get); show(a3); a3 = Stream.generate(new Rand.Character()) .limit(SZ + 1).toArray(Character[]::new); show(a3); a3 = new Rand.Character().array(SZ + 2); show(a3); char[] a3b = new Rand.Pchar().array(SZ + 3); show(a3b); System.out.println("Short"); Short[] a4 = new Short[SZ]; Arrays.setAll(a4, new Rand.Short()::get); show(a4); a4 = Stream.generate(new Rand.Short()) .limit(SZ + 1).toArray(Short[]::new); show(a4); a4 = new Rand.Short().array(SZ + 2); show(a4); short[] a4b = new Rand.Pshort().array(SZ + 3); show(a4b); System.out.println("Integer"); int[] a5 = new int[SZ]; Arrays.setAll(a5, new Rand.Integer()::get); show(a5); Integer[] a5b = Stream.generate(new Rand.Integer()) .limit(SZ + 1).toArray(Integer[]::new); show(a5b); a5b = new Rand.Integer().array(SZ + 2); show(a5b); a5 = IntStream.generate(new Rand.Pint()) .limit(SZ + 1).toArray(); show(a5); a5 = new Rand.Pint().array(SZ + 3); show(a5); System.out.println("Long"); long[] a6 = new long[SZ]; Arrays.setAll(a6, new Rand.Long()::get); show(a6); Long[] a6b = Stream.generate(new Rand.Long()) .limit(SZ + 1).toArray(Long[]::new); show(a6b); a6b = new Rand.Long().array(SZ + 2); show(a6b); a6 = LongStream.generate(new Rand.Plong()) .limit(SZ + 1).toArray(); show(a6); a6 = new Rand.Plong().array(SZ + 3); show(a6); System.out.println("Float"); Float[] a7 = new Float[SZ]; Arrays.setAll(a7, new Rand.Float()::get); show(a7); a7 = Stream.generate(new Rand.Float()) .limit(SZ + 1).toArray(Float[]::new); show(a7); a7 = new Rand.Float().array(SZ + 2); show(a7); float[] a7b = new Rand.Pfloat().array(SZ + 3); show(a7b); System.out.println("Double"); double[] a8 = new double[SZ]; Arrays.setAll(a8, new Rand.Double()::get); show(a8); Double[] a8b = Stream.generate(new Rand.Double()) .limit(SZ + 1).toArray(Double[]::new); show(a8b); a8b = new Rand.Double().array(SZ + 2); show(a8b); a8 = DoubleStream.generate(new Rand.Pdouble()) .limit(SZ + 1).toArray(); show(a8); a8 = new Rand.Pdouble().array(SZ + 3); show(a8); System.out.println("String"); String[] s = new String[SZ - 1]; Arrays.setAll(s, new Rand.String()::get); show(s); s = Stream.generate(new Rand.String()) .limit(SZ).toArray(String[]::new); show(s); s = new Rand.String().array(SZ + 1); show(s); Arrays.setAll(s, new Rand.String(4)::get); show(s); s = Stream.generate(new Rand.String(4)) .limit(SZ).toArray(String[]::new); show(s); s = new Rand.String(4).array(SZ + 1); show(s); } } /* Output: Boolean [true, false, true, true, true] [true, false, true, true, true, false] [true, false, true, true, true, false, false] [true, false, true, true, true, false, false, true] Byte [123, 33, 101, 112, 33] [123, 33, 101, 112, 33, 31] [123, 33, 101, 112, 33, 31, 0] [123, 33, 101, 112, 33, 31, 0, -72] Character [b, t, p, e, n] [b, t, p, e, n, p] [b, t, p, e, n, p, c] [b, t, p, e, n, p, c, c] Short [635, 8737, 3941, 4720, 6177] [635, 8737, 3941, 4720, 6177, 8479] [635, 8737, 3941, 4720, 6177, 8479, 6656] [635, 8737, 3941, 4720, 6177, 8479, 6656, 3768] Integer [635, 8737, 3941, 4720, 6177] [635, 8737, 3941, 4720, 6177, 8479] [635, 8737, 3941, 4720, 6177, 8479, 6656] [635, 8737, 3941, 4720, 6177, 8479] [635, 8737, 3941, 4720, 6177, 8479, 6656, 3768] Long [6882, 3765, 692, 9575, 4439] [6882, 3765, 692, 9575, 4439, 2638] [6882, 3765, 692, 9575, 4439, 2638, 4011] [6882, 3765, 692, 9575, 4439, 2638] [6882, 3765, 692, 9575, 4439, 2638, 4011, 9610] Float [4.83, 2.89, 2.9, 1.97, 3.01] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18, 0.99] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18, 0.99, 8.28] Double [4.83, 2.89, 2.9, 1.97, 3.01] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18, 0.99] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18] [4.83, 2.89, 2.9, 1.97, 3.01, 0.18, 0.99, 8.28] String [btpenpc, cuxszgv, gmeinne, eloztdv] [btpenpc, cuxszgv, gmeinne, eloztdv, ewcippc] [btpenpc, cuxszgv, gmeinne, eloztdv, ewcippc, ygpoalk] [btpe, npcc, uxsz, gvgm, einn, eelo] [btpe, npcc, uxsz, gvgm, einn] [btpe, npcc, uxsz, gvgm, einn, eelo] */ OnJava8-Examples-1.0/arrays/ThreeDWithNew.java000066400000000000000000000007451374004044700212320ustar00rootroot00000000000000// arrays/ThreeDWithNew.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ThreeDWithNew { public static void main(String[] args) { // 3-D array with fixed length: int[][][] a = new int[2][2][4]; System.out.println(Arrays.deepToString(a)); } } /* Output: [[[0, 0, 0, 0], [0, 0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]]] */ OnJava8-Examples-1.0/arrays/jmh/000077500000000000000000000000001374004044700164565ustar00rootroot00000000000000OnJava8-Examples-1.0/arrays/jmh/ParallelSort.java000066400000000000000000000011031374004044700217200ustar00rootroot00000000000000// arrays/jmh/ParallelSort.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package arrays.jmh; import java.util.*; import onjava.*; import org.openjdk.jmh.annotations.*; @State(Scope.Thread) public class ParallelSort { private long[] la; @Setup public void setup() { la = new Rand.Plong().array(100_000); } @Benchmark public void sort() { Arrays.sort(la); } @Benchmark public void parallelSort() { Arrays.parallelSort(la); } } OnJava8-Examples-1.0/build.gradle000066400000000000000000000012651374004044700166620ustar00rootroot00000000000000buildscript { repositories { maven { url 'https://plugins.gradle.org/m2/' } } dependencies { classpath 'me.champeau.gradle:jmh-gradle-plugin:0.5.2' } } apply plugin: 'com.mindviewinc.example-output-verification' subprojects { apply from: "$rootProject.projectDir/gradle/java.gradle" apply from: "$rootProject.projectDir/gradle/junit-jupiter.gradle" apply from: "$rootProject.projectDir/gradle/jmh.gradle" // apply from: "$rootProject.projectDir/gradle/checkstyle.gradle" apply from: "$rootProject.projectDir/gradle/findbugs.gradle" apply plugin: 'com.mindviewinc.tagging' } apply from: 'gradle/subprojects.gradle' OnJava8-Examples-1.0/buildSrc/000077500000000000000000000000001374004044700161465ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/000077500000000000000000000000001374004044700167355ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/000077500000000000000000000000001374004044700176615ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/groovy/000077500000000000000000000000001374004044700212065ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/groovy/com/000077500000000000000000000000001374004044700217645ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/groovy/com/mindviewinc/000077500000000000000000000000001374004044700243005ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/groovy/com/mindviewinc/plugins/000077500000000000000000000000001374004044700257615ustar00rootroot00000000000000ExampleOutputVerificationPlugin.groovy000066400000000000000000000010011374004044700354770ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/groovy/com/mindviewinc/pluginspackage com.mindviewinc.plugins import org.gradle.api.Project import org.gradle.api.Plugin import org.gradle.api.tasks.Exec class ExampleOutputVerificationPlugin implements Plugin { void apply(Project project) { project.tasks.create('verify', Exec) { description 'Uses Python tool to verify example output' commandLine 'python', '_verify_output.py' doFirst { println("execute 'gradlew run' first") } } } }OnJava8-Examples-1.0/buildSrc/src/main/groovy/com/mindviewinc/plugins/TaggingPlugin.groovy000066400000000000000000000104761374004044700317770ustar00rootroot00000000000000package com.mindviewinc.plugins import org.gradle.api.Project import org.gradle.api.Plugin import org.gradle.api.tasks.JavaExec import org.gradle.internal.jvm.Jvm import org.apache.tools.ant.util.TeeOutputStream class TaggingPlugin implements Plugin { private final static String DEBUG_PROJECT_PROPERTY_KEY = 'debug' void apply(Project project) { boolean debug = project.hasProperty(DEBUG_PROJECT_PROPERTY_KEY) ? Boolean.valueOf(project.getProperty(DEBUG_PROJECT_PROPERTY_KEY)) : false List createdTasks = [] boolean runningInCI = System.getenv('CI') boolean runningInTravis = System.getenv('TRAVIS') boolean runningInAppveyor = System.getenv('APPVEYOR') // println "runningInCI: " + runningInCI project.projectDir.eachFileRecurse { file -> if (file.name.endsWith('.java')) { Tags tags = new Tags(file) if(debug && tags.hasTags()) println tags // Exclude java sources that will not compile if (tags.willNotCompile || (tags.lowLevelAppendix && runningInAppveyor) // Exclude entire lowlevel appendix || (tags.excludeFromAppveyorCI && runningInAppveyor) || (tags.excludeFromTravisCI && runningInTravis) || (tags.excludeFromCI && runningInCI) ) { project.sourceSets.main.java.excludes.add(file.name) } else { JavaExec javaTask = null // Add tasks for java sources with main methods if (tags.hasMainMethod || tags.javaCmd) { javaTask = project.tasks.create(name: tags.fileRoot, type: JavaExec, dependsOn: tags.runFirst) { main = tags.mainClass classpath = project.sourceSets.main.runtimeClasspath args = tags.args jvmArgs = tags.jVMArgs } } else if (tags.javap) { // Create task for running javap javaTask = project.tasks.create(name: "${tags.fileRoot}", type: JavaExec, dependsOn: tags.runFirst) { main = "com.sun.tools.javap.Main" classpath = project.sourceSets.main.runtimeClasspath + project.files(Jvm.current().toolsJar) // Assuming javap represents all the args and there's no need to jVMArgs args tags.javap.split() } } if (javaTask) { def baseName = file.name.substring(0, file.name.lastIndexOf('.')) File outFile = new File(file.parentFile, baseName + '.out') File errFile = new File(file.parentFile, baseName + '.err') javaTask.configure { ignoreExitValue = tags.excludeFromGradle || tags.throwsException doFirst { if(outFile.exists()) outFile.delete() if(tags.outputLine) outFile << tags.outputLine + "\n" standardOutput = new TeeOutputStream(new FileOutputStream(outFile, true), System.out) errorOutput = new TeeOutputStream(new FileOutputStream(errFile), System.err) } doLast { if(outFile.size() == 0) outFile.delete() else if(!outFile.text.contains("/* Output:")) outFile.delete() if(errFile.size() == 0) errFile.delete() } } if (!tags.excludeFromGradle) { // Only add tasks that we know we can run successfully to the task list createdTasks.add(javaTask) } } } } } project.tasks.create('run') { dependsOn createdTasks } } } OnJava8-Examples-1.0/buildSrc/src/main/groovy/com/mindviewinc/plugins/Tags.groovy000066400000000000000000000073531374004044700301360ustar00rootroot00000000000000package com.mindviewinc.plugins class Tags { Boolean hasMainMethod = false Boolean willNotCompile = false Boolean excludeFromTravisCI = false Boolean excludeFromAppveyorCI = false Boolean excludeFromCI = false Boolean lowLevelAppendix = false Boolean throwsException = false Boolean errorOutputExpected = false Boolean excludeFromGradle = false Boolean ignoreOutput = false // This tag isn't used in the build... String fileRoot String mainClass String javaCmd = null List args = [] List jVMArgs = [] String javap = null String runFirst = null String outputLine = null private String block def Tags(File file) { block = file.text hasMainMethod = block.contains('main(String[] args)') def firstLine = block.substring(0, block.indexOf("\n")) fileRoot = (firstLine.split("/")[-1] - ".java").trim() // Remove \r if it exists mainClass = fileRoot javaCmd = extract('java') if(javaCmd) { def pieces = javaCmd.split() mainClass = pieces[0] if(pieces.size() > 1) for(p in pieces[1..-1]) if(p.startsWith("-")) jVMArgs << p else args << p } willNotCompile = hasTag('WillNotCompile') excludeFromTravisCI = hasTag('ExcludeFromTravisCI') excludeFromAppveyorCI = hasTag('ExcludeFromAppveyorCI') excludeFromCI = hasTag('ExcludeFromCI') lowLevelAppendix = firstLine.contains("// lowlevel/") throwsException = hasTag('ThrowsException') errorOutputExpected = hasTag('ErrorOutputExpected') excludeFromGradle = hasTag('ExcludeFromGradle') ignoreOutput = hasTag('IgnoreOutput') javap = extract('javap') // Includes only arguments to command runFirst = extract('RunFirst:') outputLine = extractOutputLine() } private def hasTag(String marker) { return block.contains("// {" + marker + "}") } def extractOutputLine() { def matcher = (block =~ /(?m)^(\/\* Output:.*)$/) if (matcher) { return matcher[0][1] } else { return null } } private def extract(String marker) { // Assume some whitespace is after marker if(!block.contains("// {${marker} ")) return null def matcher = (block =~ /\/\/ \{${marker}\s+([^}]+)/) if (matcher) { def matched = matcher[0][1].trim() return matched.replaceAll("\n?//", "") } else { println "Searching for: " + matcher println block System.exit(1) } } public boolean hasTags() { return willNotCompile || excludeFromTravisCI || excludeFromAppveyorCI || excludeFromCI || throwsException || errorOutputExpected || excludeFromGradle || ignoreOutput || javaCmd || args || jVMArgs || javap || runFirst } public String toString() { String result = "" block.eachLine{ ln -> if(ln.startsWith("//") || ln.startsWith("package ")) result += ln + "\n" } """ hasMainMethod willNotCompile excludeFromTravisCI excludeFromAppveyorCI excludeFromCI throwsException errorOutputExpected excludeFromGradle ignoreOutput fileRoot mainClass javaCmd args jVMArgs javap runFirst """.split().each { str -> if(this[str]) result += str + ": " + this[str] + "\n" } result } } OnJava8-Examples-1.0/buildSrc/src/main/resources/000077500000000000000000000000001374004044700216735ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/resources/META-INF/000077500000000000000000000000001374004044700230335ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/resources/META-INF/gradle-plugins/000077500000000000000000000000001374004044700257505ustar00rootroot00000000000000com.mindviewinc.example-output-verification.properties000066400000000000000000000001141374004044700405440ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/resources/META-INF/gradle-pluginsimplementation-class=com.mindviewinc.plugins.ExampleOutputVerificationPlugincom.mindviewinc.tagging.properties000066400000000000000000000000721374004044700345160ustar00rootroot00000000000000OnJava8-Examples-1.0/buildSrc/src/main/resources/META-INF/gradle-pluginsimplementation-class=com.mindviewinc.plugins.TaggingPluginOnJava8-Examples-1.0/checkstyle.xml000066400000000000000000000153151374004044700172640ustar00rootroot00000000000000 OnJava8-Examples-1.0/chkstyle.bat000066400000000000000000000001201374004044700167060ustar00rootroot00000000000000@echo run gradlew clean first! gradlew checkstyleMain 1> checkstyleout.txt 2>&1 OnJava8-Examples-1.0/collections/000077500000000000000000000000001374004044700167155ustar00rootroot00000000000000OnJava8-Examples-1.0/collections/AdapterMethodIdiom.java000066400000000000000000000025541374004044700232710ustar00rootroot00000000000000// collections/AdapterMethodIdiom.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The "Adapter Method" idiom uses for-in // with additional kinds of Iterables import java.util.*; class ReversibleArrayList extends ArrayList { ReversibleArrayList(Collection c) { super(c); } public Iterable reversed() { return new Iterable() { public Iterator iterator() { return new Iterator() { int current = size() - 1; public boolean hasNext() { return current > -1; } public T next() { return get(current--); } public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } }; } } public class AdapterMethodIdiom { public static void main(String[] args) { ReversibleArrayList ral = new ReversibleArrayList( Arrays.asList("To be or not to be".split(" "))); // Grabs the ordinary iterator via iterator(): for(String s : ral) System.out.print(s + " "); System.out.println(); // Hand it the Iterable of your choice for(String s : ral.reversed()) System.out.print(s + " "); } } /* Output: To be or not to be be to not or be To */ OnJava8-Examples-1.0/collections/AddingGroups.java000066400000000000000000000017111374004044700221460ustar00rootroot00000000000000// collections/AddingGroups.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Adding groups of elements to Collection objects import java.util.*; public class AddingGroups { public static void main(String[] args) { Collection collection = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5)); Integer[] moreInts = { 6, 7, 8, 9, 10 }; collection.addAll(Arrays.asList(moreInts)); // Runs significantly faster, but you can't // construct a Collection this way: Collections.addAll(collection, 11, 12, 13, 14, 15); Collections.addAll(collection, moreInts); // Produces a list "backed by" an array: List list = Arrays.asList(16,17,18,19,20); list.set(1, 99); // OK -- modify an element // list.add(21); // Runtime error; the underlying // array cannot be resized. } } OnJava8-Examples-1.0/collections/ApplesAndOrangesWithGenerics.java000066400000000000000000000011201374004044700252540ustar00rootroot00000000000000// collections/ApplesAndOrangesWithGenerics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ApplesAndOrangesWithGenerics { public static void main(String[] args) { ArrayList apples = new ArrayList<>(); for(int i = 0; i < 3; i++) apples.add(new Apple()); // Compile-time error: // apples.add(new Orange()); for(Apple apple : apples) { System.out.println(apple.id()); } } } /* Output: 0 1 2 */ OnJava8-Examples-1.0/collections/ApplesAndOrangesWithoutGenerics.java000066400000000000000000000020731374004044700260140ustar00rootroot00000000000000// collections/ApplesAndOrangesWithoutGenerics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple collection use (suppressing compiler warnings) // {ThrowsException} import java.util.*; class Apple { private static long counter; private final long id = counter++; public long id() { return id; } } class Orange {} public class ApplesAndOrangesWithoutGenerics { @SuppressWarnings("unchecked") public static void main(String[] args) { ArrayList apples = new ArrayList(); for(int i = 0; i < 3; i++) apples.add(new Apple()); // No problem adding an Orange to apples: apples.add(new Orange()); for(Object apple : apples) { ((Apple) apple).id(); // Orange is detected only at run time } } } /* Output: ___[ Error Output ]___ Exception in thread "main" java.lang.ClassCastException: Orange cannot be cast to Apple at ApplesAndOrangesWithoutGenerics.main(ApplesA ndOrangesWithoutGenerics.java:23) */ OnJava8-Examples-1.0/collections/ArrayIsNotIterable.java000066400000000000000000000012361374004044700232650ustar00rootroot00000000000000// collections/ArrayIsNotIterable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ArrayIsNotIterable { static void test(Iterable ib) { for(T t : ib) System.out.print(t + " "); } public static void main(String[] args) { test(Arrays.asList(1, 2, 3)); String[] strings = { "A", "B", "C" }; // An array works in for-in, but it's not Iterable: //- test(strings); // You must explicitly convert it to an Iterable: test(Arrays.asList(strings)); } } /* Output: 1 2 3 A B C */ OnJava8-Examples-1.0/collections/AsListInference.java000066400000000000000000000020321374004044700225730ustar00rootroot00000000000000// collections/AsListInference.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class Snow {} class Powder extends Snow {} class Light extends Powder {} class Heavy extends Powder {} class Crusty extends Snow {} class Slush extends Snow {} public class AsListInference { public static void main(String[] args) { List snow1 = Arrays.asList( new Crusty(), new Slush(), new Powder()); //- snow1.add(new Heavy()); // Exception List snow2 = Arrays.asList( new Light(), new Heavy()); //- snow2.add(new Slush()); // Exception List snow3 = new ArrayList<>(); Collections.addAll(snow3, new Light(), new Heavy(), new Powder()); snow3.add(new Crusty()); // Hint with explicit type argument specification: List snow4 = Arrays.asList( new Light(), new Heavy(), new Slush()); //- snow4.add(new Powder()); // Exception } } OnJava8-Examples-1.0/collections/CollectionDifferences.java000066400000000000000000000052341374004044700240150ustar00rootroot00000000000000// collections/CollectionDifferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; public class CollectionDifferences { public static void main(String[] args) { CollectionMethodDifferences.main(args); } } /* Output: Collection: [add, addAll, clear, contains, containsAll, equals, forEach, hashCode, isEmpty, iterator, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, stream, toArray] Interfaces in Collection: [Iterable] Set extends Collection, adds: [] Interfaces in Set: [Collection] HashSet extends Set, adds: [] Interfaces in HashSet: [Set, Cloneable, Serializable] LinkedHashSet extends HashSet, adds: [] Interfaces in LinkedHashSet: [Set, Cloneable, Serializable] TreeSet extends Set, adds: [headSet, descendingIterator, descendingSet, pollLast, subSet, floor, tailSet, ceiling, last, lower, comparator, pollFirst, first, higher] Interfaces in TreeSet: [NavigableSet, Cloneable, Serializable] List extends Collection, adds: [replaceAll, get, indexOf, subList, set, sort, lastIndexOf, listIterator] Interfaces in List: [Collection] ArrayList extends List, adds: [trimToSize, ensureCapacity] Interfaces in ArrayList: [List, RandomAccess, Cloneable, Serializable] LinkedList extends List, adds: [offerFirst, poll, getLast, offer, getFirst, removeFirst, element, removeLastOccurrence, peekFirst, peekLast, push, pollFirst, removeFirstOccurrence, descendingIterator, pollLast, removeLast, pop, addLast, peek, offerLast, addFirst] Interfaces in LinkedList: [List, Deque, Cloneable, Serializable] Queue extends Collection, adds: [poll, peek, offer, element] Interfaces in Queue: [Collection] PriorityQueue extends Queue, adds: [comparator] Interfaces in PriorityQueue: [Serializable] Map: [clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, replace, replaceAll, size, values] HashMap extends Map, adds: [] Interfaces in HashMap: [Map, Cloneable, Serializable] LinkedHashMap extends HashMap, adds: [] Interfaces in LinkedHashMap: [Map] SortedMap extends Map, adds: [lastKey, subMap, comparator, firstKey, headMap, tailMap] Interfaces in SortedMap: [Map] TreeMap extends Map, adds: [descendingKeySet, navigableKeySet, higherEntry, higherKey, floorKey, subMap, ceilingKey, pollLastEntry, firstKey, lowerKey, headMap, tailMap, lowerEntry, ceilingEntry, descendingMap, pollFirstEntry, lastKey, firstEntry, floorEntry, comparator, lastEntry] Interfaces in TreeMap: [NavigableMap, Cloneable, Serializable] */ OnJava8-Examples-1.0/collections/CollectionSequence.java000066400000000000000000000021511374004044700233430ustar00rootroot00000000000000// collections/CollectionSequence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class CollectionSequence extends AbstractCollection { private Pet[] pets = Pets.array(8); @Override public int size() { return pets.length; } @Override public Iterator iterator() { return new Iterator() { // [1] private int index = 0; @Override public boolean hasNext() { return index < pets.length; } @Override public Pet next() { return pets[index++]; } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { CollectionSequence c = new CollectionSequence(); InterfaceVsIterator.display(c); InterfaceVsIterator.display(c.iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx */ OnJava8-Examples-1.0/collections/CrossCollectionIteration.java000066400000000000000000000020631374004044700245450ustar00rootroot00000000000000// collections/CrossCollectionIteration.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class CrossCollectionIteration { public static void display(Iterator it) { while(it.hasNext()) { Pet p = it.next(); System.out.print(p.id() + ":" + p + " "); } System.out.println(); } public static void main(String[] args) { List pets = Pets.list(8); LinkedList petsLL = new LinkedList<>(pets); HashSet petsHS = new HashSet<>(pets); TreeSet petsTS = new TreeSet<>(pets); display(pets.iterator()); display(petsLL.iterator()); display(petsHS.iterator()); display(petsTS.iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 5:Cymric 2:Cymric 7:Manx 1:Manx 3:Mutt 6:Pug 4:Pug 0:Rat */ OnJava8-Examples-1.0/collections/CrossCollectionIteration2.java000066400000000000000000000020571374004044700246320ustar00rootroot00000000000000// collections/CrossCollectionIteration2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class CrossCollectionIteration2 { public static void display(Iterable ip) { Iterator it = ip.iterator(); while(it.hasNext()) { Pet p = it.next(); System.out.print(p.id() + ":" + p + " "); } System.out.println(); } public static void main(String[] args) { List pets = Pets.list(8); LinkedList petsLL = new LinkedList<>(pets); HashSet petsHS = new HashSet<>(pets); TreeSet petsTS = new TreeSet<>(pets); display(pets); display(petsLL); display(petsHS); display(petsTS); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 5:Cymric 2:Cymric 7:Manx 1:Manx 3:Mutt 6:Pug 4:Pug 0:Rat */ OnJava8-Examples-1.0/collections/EnvironmentVariables.java000066400000000000000000000007311374004044700237160ustar00rootroot00000000000000// collections/EnvironmentVariables.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.util.*; public class EnvironmentVariables { public static void main(String[] args) { for(Map.Entry entry: System.getenv().entrySet()) { System.out.println(entry.getKey() + ": " + entry.getValue()); } } } OnJava8-Examples-1.0/collections/ForInCollections.java000066400000000000000000000010661374004044700227770ustar00rootroot00000000000000// collections/ForInCollections.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // All collections work with for-in import java.util.*; public class ForInCollections { public static void main(String[] args) { Collection cs = new LinkedList<>(); Collections.addAll(cs, "Take the long way home".split(" ")); for(String s : cs) System.out.print("'" + s + "' "); } } /* Output: 'Take' 'the' 'long' 'way' 'home' */ OnJava8-Examples-1.0/collections/GenericsAndUpcasting.java000066400000000000000000000013551374004044700236240ustar00rootroot00000000000000// collections/GenericsAndUpcasting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class GrannySmith extends Apple {} class Gala extends Apple {} class Fuji extends Apple {} class Braeburn extends Apple {} public class GenericsAndUpcasting { public static void main(String[] args) { ArrayList apples = new ArrayList<>(); apples.add(new GrannySmith()); apples.add(new Gala()); apples.add(new Fuji()); apples.add(new Braeburn()); for(Apple apple : apples) System.out.println(apple); } } /* Output: GrannySmith@15db9742 Gala@6d06d69c Fuji@7852e922 Braeburn@4e25154f */ OnJava8-Examples-1.0/collections/InterfaceVsIterator.java000066400000000000000000000033331374004044700235050ustar00rootroot00000000000000// collections/InterfaceVsIterator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class InterfaceVsIterator { public static void display(Iterator it) { while(it.hasNext()) { Pet p = it.next(); System.out.print(p.id() + ":" + p + " "); } System.out.println(); } public static void display(Collection pets) { for(Pet p : pets) System.out.print(p.id() + ":" + p + " "); System.out.println(); } public static void main(String[] args) { List petList = Pets.list(8); Set petSet = new HashSet<>(petList); Map petMap = new LinkedHashMap<>(); String[] names = ("Ralph, Eric, Robin, Lacey, " + "Britney, Sam, Spot, Fluffy").split(", "); for(int i = 0; i < names.length; i++) petMap.put(names[i], petList.get(i)); display(petList); display(petSet); display(petList.iterator()); display(petSet.iterator()); System.out.println(petMap); System.out.println(petMap.keySet()); display(petMap.values()); display(petMap.values().iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx {Ralph=Rat, Eric=Manx, Robin=Cymric, Lacey=Mutt, Britney=Pug, Sam=Cymric, Spot=Pug, Fluffy=Manx} [Ralph, Eric, Robin, Lacey, Britney, Sam, Spot, Fluffy] 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx */ OnJava8-Examples-1.0/collections/IterableClass.java000066400000000000000000000020101374004044700222660ustar00rootroot00000000000000// collections/IterableClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Anything Iterable works with for-in import java.util.*; public class IterableClass implements Iterable { protected String[] words = ("And that is how " + "we know the Earth to be banana-shaped." ).split(" "); @Override public Iterator iterator() { return new Iterator() { private int index = 0; @Override public boolean hasNext() { return index < words.length; } @Override public String next() { return words[index++]; } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { for(String s : new IterableClass()) System.out.print(s + " "); } } /* Output: And that is how we know the Earth to be banana-shaped. */ OnJava8-Examples-1.0/collections/LinkedListFeatures.java000066400000000000000000000033631374004044700233260ustar00rootroot00000000000000// collections/LinkedListFeatures.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class LinkedListFeatures { public static void main(String[] args) { LinkedList pets = new LinkedList<>(Pets.list(5)); System.out.println(pets); // Identical: System.out.println( "pets.getFirst(): " + pets.getFirst()); System.out.println( "pets.element(): " + pets.element()); // Only differs in empty-list behavior: System.out.println("pets.peek(): " + pets.peek()); // Identical; remove and return the first element: System.out.println( "pets.remove(): " + pets.remove()); System.out.println( "pets.removeFirst(): " + pets.removeFirst()); // Only differs in empty-list behavior: System.out.println("pets.poll(): " + pets.poll()); System.out.println(pets); pets.addFirst(new Rat()); System.out.println("After addFirst(): " + pets); pets.offer(Pets.get()); System.out.println("After offer(): " + pets); pets.add(Pets.get()); System.out.println("After add(): " + pets); pets.addLast(new Hamster()); System.out.println("After addLast(): " + pets); System.out.println( "pets.removeLast(): " + pets.removeLast()); } } /* Output: [Rat, Manx, Cymric, Mutt, Pug] pets.getFirst(): Rat pets.element(): Rat pets.peek(): Rat pets.remove(): Rat pets.removeFirst(): Manx pets.poll(): Cymric [Mutt, Pug] After addFirst(): [Rat, Mutt, Pug] After offer(): [Rat, Mutt, Pug, Cymric] After add(): [Rat, Mutt, Pug, Cymric, Pug] After addLast(): [Rat, Mutt, Pug, Cymric, Pug, Hamster] pets.removeLast(): Hamster */ OnJava8-Examples-1.0/collections/ListFeatures.java000066400000000000000000000062141374004044700221750ustar00rootroot00000000000000// collections/ListFeatures.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class ListFeatures { public static void main(String[] args) { Random rand = new Random(47); List pets = Pets.list(7); System.out.println("1: " + pets); Hamster h = new Hamster(); pets.add(h); // Automatically resizes System.out.println("2: " + pets); System.out.println("3: " + pets.contains(h)); pets.remove(h); // Remove by object Pet p = pets.get(2); System.out.println( "4: " + p + " " + pets.indexOf(p)); Pet cymric = new Cymric(); System.out.println("5: " + pets.indexOf(cymric)); System.out.println("6: " + pets.remove(cymric)); // Must be the exact object: System.out.println("7: " + pets.remove(p)); System.out.println("8: " + pets); pets.add(3, new Mouse()); // Insert at an index System.out.println("9: " + pets); List sub = pets.subList(1, 4); System.out.println("subList: " + sub); System.out.println("10: " + pets.containsAll(sub)); Collections.sort(sub); // In-place sort System.out.println("sorted subList: " + sub); // Order is not important in containsAll(): System.out.println("11: " + pets.containsAll(sub)); Collections.shuffle(sub, rand); // Mix it up System.out.println("shuffled subList: " + sub); System.out.println("12: " + pets.containsAll(sub)); List copy = new ArrayList<>(pets); sub = Arrays.asList(pets.get(1), pets.get(4)); System.out.println("sub: " + sub); copy.retainAll(sub); System.out.println("13: " + copy); copy = new ArrayList<>(pets); // Get a fresh copy copy.remove(2); // Remove by index System.out.println("14: " + copy); copy.removeAll(sub); // Only removes exact objects System.out.println("15: " + copy); copy.set(1, new Mouse()); // Replace an element System.out.println("16: " + copy); copy.addAll(2, sub); // Insert a list in the middle System.out.println("17: " + copy); System.out.println("18: " + pets.isEmpty()); pets.clear(); // Remove all elements System.out.println("19: " + pets); System.out.println("20: " + pets.isEmpty()); pets.addAll(Pets.list(4)); System.out.println("21: " + pets); Object[] o = pets.toArray(); System.out.println("22: " + o[3]); Pet[] pa = pets.toArray(new Pet[0]); System.out.println("23: " + pa[3].id()); } } /* Output: 1: [Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug] 2: [Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Hamster] 3: true 4: Cymric 2 5: -1 6: false 7: true 8: [Rat, Manx, Mutt, Pug, Cymric, Pug] 9: [Rat, Manx, Mutt, Mouse, Pug, Cymric, Pug] subList: [Manx, Mutt, Mouse] 10: true sorted subList: [Manx, Mouse, Mutt] 11: true shuffled subList: [Mouse, Manx, Mutt] 12: true sub: [Mouse, Pug] 13: [Mouse, Pug] 14: [Rat, Mouse, Mutt, Pug, Cymric, Pug] 15: [Rat, Mutt, Cymric, Pug] 16: [Rat, Mouse, Cymric, Pug] 17: [Rat, Mouse, Mouse, Pug, Cymric, Pug] 18: false 19: [] 20: true 21: [Manx, Cymric, Rat, EgyptianMau] 22: EgyptianMau 23: 14 */ OnJava8-Examples-1.0/collections/ListIteration.java000066400000000000000000000021071374004044700223520ustar00rootroot00000000000000// collections/ListIteration.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class ListIteration { public static void main(String[] args) { List pets = Pets.list(8); ListIterator it = pets.listIterator(); while(it.hasNext()) System.out.print(it.next() + ", " + it.nextIndex() + ", " + it.previousIndex() + "; "); System.out.println(); // Backwards: while(it.hasPrevious()) System.out.print(it.previous().id() + " "); System.out.println(); System.out.println(pets); it = pets.listIterator(3); while(it.hasNext()) { it.next(); it.set(Pets.get()); } System.out.println(pets); } } /* Output: Rat, 1, 0; Manx, 2, 1; Cymric, 3, 2; Mutt, 4, 3; Pug, 5, 4; Cymric, 6, 5; Pug, 7, 6; Manx, 8, 7; 7 6 5 4 3 2 1 0 [Rat, Manx, Cymric, Mutt, Pug, Cymric, Pug, Manx] [Rat, Manx, Cymric, Cymric, Rat, EgyptianMau, Hamster, EgyptianMau] */ OnJava8-Examples-1.0/collections/MapOfList.java000066400000000000000000000036371374004044700214270ustar00rootroot00000000000000// collections/MapOfList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java collections.MapOfList} package collections; import typeinfo.pets.*; import java.util.*; public class MapOfList { public static final Map> petPeople = new HashMap<>(); static { petPeople.put(new Person("Dawn"), Arrays.asList( new Cymric("Molly"), new Mutt("Spot"))); petPeople.put(new Person("Kate"), Arrays.asList(new Cat("Shackleton"), new Cat("Elsie May"), new Dog("Margrett"))); petPeople.put(new Person("Marilyn"), Arrays.asList( new Pug("Louie aka Louis Snorkelstein Dupree"), new Cat("Stanford"), new Cat("Pinkola"))); petPeople.put(new Person("Luke"), Arrays.asList( new Rat("Fuzzy"), new Rat("Fizzy"))); petPeople.put(new Person("Isaac"), Arrays.asList(new Rat("Freckly"))); } public static void main(String[] args) { System.out.println("People: " + petPeople.keySet()); System.out.println("Pets: " + petPeople.values()); for(Person person : petPeople.keySet()) { System.out.println(person + " has:"); for(Pet pet : petPeople.get(person)) System.out.println(" " + pet); } } } /* Output: People: [Person Dawn, Person Kate, Person Isaac, Person Marilyn, Person Luke] Pets: [[Cymric Molly, Mutt Spot], [Cat Shackleton, Cat Elsie May, Dog Margrett], [Rat Freckly], [Pug Louie aka Louis Snorkelstein Dupree, Cat Stanford, Cat Pinkola], [Rat Fuzzy, Rat Fizzy]] Person Dawn has: Cymric Molly Mutt Spot Person Kate has: Cat Shackleton Cat Elsie May Dog Margrett Person Isaac has: Rat Freckly Person Marilyn has: Pug Louie aka Louis Snorkelstein Dupree Cat Stanford Cat Pinkola Person Luke has: Rat Fuzzy Rat Fizzy */ OnJava8-Examples-1.0/collections/ModifyingArraysAsList.java000066400000000000000000000022671374004044700240160ustar00rootroot00000000000000// collections/ModifyingArraysAsList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ModifyingArraysAsList { public static void main(String[] args) { Random rand = new Random(47); Integer[] ia = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; List list1 = new ArrayList<>(Arrays.asList(ia)); System.out.println("Before shuffling: " + list1); Collections.shuffle(list1, rand); System.out.println("After shuffling: " + list1); System.out.println("array: " + Arrays.toString(ia)); List list2 = Arrays.asList(ia); System.out.println("Before shuffling: " + list2); Collections.shuffle(list2, rand); System.out.println("After shuffling: " + list2); System.out.println("array: " + Arrays.toString(ia)); } } /* Output: Before shuffling: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] After shuffling: [4, 6, 3, 1, 8, 7, 2, 5, 10, 9] array: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] Before shuffling: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] After shuffling: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8] array: [9, 1, 6, 3, 7, 2, 5, 10, 4, 8] */ OnJava8-Examples-1.0/collections/MultiIterableClass.java000066400000000000000000000032101374004044700233040ustar00rootroot00000000000000// collections/MultiIterableClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Adding several Adapter Methods import java.util.*; public class MultiIterableClass extends IterableClass { public Iterable reversed() { return new Iterable() { public Iterator iterator() { return new Iterator() { int current = words.length - 1; public boolean hasNext() { return current > -1; } public String next() { return words[current--]; } public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } }; } public Iterable randomized() { return new Iterable() { public Iterator iterator() { List shuffled = new ArrayList(Arrays.asList(words)); Collections.shuffle(shuffled, new Random(47)); return shuffled.iterator(); } }; } public static void main(String[] args) { MultiIterableClass mic = new MultiIterableClass(); for(String s : mic.reversed()) System.out.print(s + " "); System.out.println(); for(String s : mic.randomized()) System.out.print(s + " "); System.out.println(); for(String s : mic) System.out.print(s + " "); } } /* Output: banana-shaped. be to Earth the know we how is that And is banana-shaped. Earth that how the be And we know to And that is how we know the Earth to be banana-shaped. */ OnJava8-Examples-1.0/collections/NonCollectionSequence.java000066400000000000000000000017421374004044700240230ustar00rootroot00000000000000// collections/NonCollectionSequence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; class PetSequence { protected Pet[] pets = Pets.array(8); } public class NonCollectionSequence extends PetSequence { public Iterator iterator() { return new Iterator() { private int index = 0; @Override public boolean hasNext() { return index < pets.length; } @Override public Pet next() { return pets[index++]; } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { NonCollectionSequence nc = new NonCollectionSequence(); InterfaceVsIterator.display(nc.iterator()); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx */ OnJava8-Examples-1.0/collections/PetMap.java000066400000000000000000000014321374004044700207460ustar00rootroot00000000000000// collections/PetMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class PetMap { public static void main(String[] args) { Map petMap = new HashMap<>(); petMap.put("My Cat", new Cat("Molly")); petMap.put("My Dog", new Dog("Ginger")); petMap.put("My Hamster", new Hamster("Bosco")); System.out.println(petMap); Pet dog = petMap.get("My Dog"); System.out.println(dog); System.out.println(petMap.containsKey("My Dog")); System.out.println(petMap.containsValue(dog)); } } /* Output: {My Dog=Dog Ginger, My Cat=Cat Molly, My Hamster=Hamster Bosco} Dog Ginger true true */ OnJava8-Examples-1.0/collections/PrintingCollections.java000066400000000000000000000024501374004044700235520ustar00rootroot00000000000000// collections/PrintingCollections.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Collections print themselves automatically import java.util.*; public class PrintingCollections { static Collection fill(Collection collection) { collection.add("rat"); collection.add("cat"); collection.add("dog"); collection.add("dog"); return collection; } static Map fill(Map map) { map.put("rat", "Fuzzy"); map.put("cat", "Rags"); map.put("dog", "Bosco"); map.put("dog", "Spot"); return map; } public static void main(String[] args) { System.out.println(fill(new ArrayList<>())); System.out.println(fill(new LinkedList<>())); System.out.println(fill(new HashSet<>())); System.out.println(fill(new TreeSet<>())); System.out.println(fill(new LinkedHashSet<>())); System.out.println(fill(new HashMap<>())); System.out.println(fill(new TreeMap<>())); System.out.println(fill(new LinkedHashMap<>())); } } /* Output: [rat, cat, dog, dog] [rat, cat, dog, dog] [rat, cat, dog] [cat, dog, rat] [rat, cat, dog] {rat=Fuzzy, cat=Rags, dog=Spot} {cat=Rags, dog=Spot, rat=Fuzzy} {rat=Fuzzy, cat=Rags, dog=Spot} */ OnJava8-Examples-1.0/collections/PriorityQueueDemo.java000066400000000000000000000033621374004044700232170ustar00rootroot00000000000000// collections/PriorityQueueDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class PriorityQueueDemo { public static void main(String[] args) { PriorityQueue priorityQueue = new PriorityQueue<>(); Random rand = new Random(47); for(int i = 0; i < 10; i++) priorityQueue.offer(rand.nextInt(i + 10)); QueueDemo.printQ(priorityQueue); List ints = Arrays.asList(25, 22, 20, 18, 14, 9, 3, 1, 1, 2, 3, 9, 14, 18, 21, 23, 25); priorityQueue = new PriorityQueue<>(ints); QueueDemo.printQ(priorityQueue); priorityQueue = new PriorityQueue<>( ints.size(), Collections.reverseOrder()); priorityQueue.addAll(ints); QueueDemo.printQ(priorityQueue); String fact = "EDUCATION SHOULD ESCHEW OBFUSCATION"; List strings = Arrays.asList(fact.split("")); PriorityQueue stringPQ = new PriorityQueue<>(strings); QueueDemo.printQ(stringPQ); stringPQ = new PriorityQueue<>( strings.size(), Collections.reverseOrder()); stringPQ.addAll(strings); QueueDemo.printQ(stringPQ); Set charSet = new HashSet<>(); for(char c : fact.toCharArray()) charSet.add(c); // Autoboxing PriorityQueue characterPQ = new PriorityQueue<>(charSet); QueueDemo.printQ(characterPQ); } } /* Output: 0 1 1 1 1 1 3 5 8 14 1 1 2 3 3 9 9 14 14 18 18 20 21 22 23 25 25 25 25 23 22 21 20 18 18 14 14 9 9 3 3 2 1 1 A A B C C C D D E E E F H H I I L N N O O O O S S S T T U U U W W U U U T T S S S O O O O N N L I I H H F E E E D D C C C B A A A B C D E F H I L N O S T U W */ OnJava8-Examples-1.0/collections/QueueDemo.java000066400000000000000000000015101374004044700214460ustar00rootroot00000000000000// collections/QueueDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Upcasting to a Queue from a LinkedList import java.util.*; public class QueueDemo { public static void printQ(Queue queue) { while(queue.peek() != null) System.out.print(queue.remove() + " "); System.out.println(); } public static void main(String[] args) { Queue queue = new LinkedList<>(); Random rand = new Random(47); for(int i = 0; i < 10; i++) queue.offer(rand.nextInt(i + 10)); printQ(queue); Queue qc = new LinkedList<>(); for(char c : "Brontosaurus".toCharArray()) qc.offer(c); printQ(qc); } } /* Output: 8 1 1 1 5 14 3 1 0 1 B r o n t o s a u r u s */ OnJava8-Examples-1.0/collections/SetOfInteger.java000066400000000000000000000011261374004044700221160ustar00rootroot00000000000000// collections/SetOfInteger.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SetOfInteger { public static void main(String[] args) { Random rand = new Random(47); Set intset = new HashSet<>(); for(int i = 0; i < 10000; i++) intset.add(rand.nextInt(30)); System.out.println(intset); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] */ OnJava8-Examples-1.0/collections/SetOfString.java000066400000000000000000000012361374004044700217710ustar00rootroot00000000000000// collections/SetOfString.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SetOfString { public static void main(String[] args) { Set colors = new HashSet<>(); for(int i = 0; i < 100; i++) { colors.add("Yellow"); colors.add("Blue"); colors.add("Red"); colors.add("Red"); colors.add("Orange"); colors.add("Yellow"); colors.add("Blue"); colors.add("Purple"); } System.out.println(colors); } } /* Output: [Red, Yellow, Blue, Purple, Orange] */ OnJava8-Examples-1.0/collections/SetOperations.java000066400000000000000000000023571374004044700223660ustar00rootroot00000000000000// collections/SetOperations.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SetOperations { public static void main(String[] args) { Set set1 = new HashSet<>(); Collections.addAll(set1, "A B C D E F G H I J K L".split(" ")); set1.add("M"); System.out.println("H: " + set1.contains("H")); System.out.println("N: " + set1.contains("N")); Set set2 = new HashSet<>(); Collections.addAll(set2, "H I J K L".split(" ")); System.out.println( "set2 in set1: " + set1.containsAll(set2)); set1.remove("H"); System.out.println("set1: " + set1); System.out.println( "set2 in set1: " + set1.containsAll(set2)); set1.removeAll(set2); System.out.println( "set2 removed from set1: " + set1); Collections.addAll(set1, "X Y Z".split(" ")); System.out.println( "'X Y Z' added to set1: " + set1); } } /* Output: H: true N: false set2 in set1: true set1: [A, B, C, D, E, F, G, I, J, K, L, M] set2 in set1: false set2 removed from set1: [A, B, C, D, E, F, G, M] 'X Y Z' added to set1: [A, B, C, D, E, F, G, M, X, Y, Z] */ OnJava8-Examples-1.0/collections/SimpleCollection.java000066400000000000000000000007771374004044700230400ustar00rootroot00000000000000// collections/SimpleCollection.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SimpleCollection { public static void main(String[] args) { Collection c = new ArrayList<>(); for(int i = 0; i < 10; i++) c.add(i); // Autoboxing for(Integer i : c) System.out.print(i + ", "); } } /* Output: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, */ OnJava8-Examples-1.0/collections/SimpleIteration.java000066400000000000000000000021151374004044700226670ustar00rootroot00000000000000// collections/SimpleIteration.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import java.util.*; public class SimpleIteration { public static void main(String[] args) { List pets = Pets.list(12); Iterator it = pets.iterator(); while(it.hasNext()) { Pet p = it.next(); System.out.print(p.id() + ":" + p + " "); } System.out.println(); // A simpler approach, when possible: for(Pet p : pets) System.out.print(p.id() + ":" + p + " "); System.out.println(); // An Iterator can also remove elements: it = pets.iterator(); for(int i = 0; i < 6; i++) { it.next(); it.remove(); } System.out.println(pets); } } /* Output: 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 8:Cymric 9:Rat 10:EgyptianMau 11:Hamster 0:Rat 1:Manx 2:Cymric 3:Mutt 4:Pug 5:Cymric 6:Pug 7:Manx 8:Cymric 9:Rat 10:EgyptianMau 11:Hamster [Pug, Manx, Cymric, Rat, EgyptianMau, Hamster] */ OnJava8-Examples-1.0/collections/SortedSetOfString.java000066400000000000000000000012521374004044700231500ustar00rootroot00000000000000// collections/SortedSetOfString.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SortedSetOfString { public static void main(String[] args) { Set colors = new TreeSet<>(); for(int i = 0; i < 100; i++) { colors.add("Yellow"); colors.add("Blue"); colors.add("Red"); colors.add("Red"); colors.add("Orange"); colors.add("Yellow"); colors.add("Blue"); colors.add("Purple"); } System.out.println(colors); } } /* Output: [Blue, Orange, Purple, Red, Yellow] */ OnJava8-Examples-1.0/collections/StackCollision.java000066400000000000000000000013671374004044700225100ustar00rootroot00000000000000// collections/StackCollision.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class StackCollision { public static void main(String[] args) { onjava.Stack stack = new onjava.Stack<>(); for(String s : "My dog has fleas".split(" ")) stack.push(s); while(!stack.isEmpty()) System.out.print(stack.pop() + " "); System.out.println(); java.util.Stack stack2 = new java.util.Stack<>(); for(String s : "My dog has fleas".split(" ")) stack2.push(s); while(!stack2.empty()) System.out.print(stack2.pop() + " "); } } /* Output: fleas has dog My fleas has dog My */ OnJava8-Examples-1.0/collections/StackTest.java000066400000000000000000000007721374004044700214730ustar00rootroot00000000000000// collections/StackTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class StackTest { public static void main(String[] args) { Deque stack = new ArrayDeque<>(); for(String s : "My dog has fleas".split(" ")) stack.push(s); while(!stack.isEmpty()) System.out.print(stack.pop() + " "); } } /* Output: fleas has dog My */ OnJava8-Examples-1.0/collections/StackTest2.java000066400000000000000000000007641374004044700215560ustar00rootroot00000000000000// collections/StackTest2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; public class StackTest2 { public static void main(String[] args) { Stack stack = new Stack<>(); for(String s : "My dog has fleas".split(" ")) stack.push(s); while(!stack.isEmpty()) System.out.print(stack.pop() + " "); } } /* Output: fleas has dog My */ OnJava8-Examples-1.0/collections/Statistics.java000066400000000000000000000014371374004044700217170ustar00rootroot00000000000000// collections/Statistics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple demonstration of HashMap import java.util.*; public class Statistics { public static void main(String[] args) { Random rand = new Random(47); Map m = new HashMap<>(); for(int i = 0; i < 10000; i++) { // Produce a number between 0 and 20: int r = rand.nextInt(20); Integer freq = m.get(r); // [1] m.put(r, freq == null ? 1 : freq + 1); } System.out.println(m); } } /* Output: {0=481, 1=502, 2=489, 3=508, 4=481, 5=503, 6=519, 7=471, 8=468, 9=549, 10=513, 11=531, 12=521, 13=506, 14=477, 15=497, 16=533, 17=509, 18=478, 19=464} */ OnJava8-Examples-1.0/collections/UniqueWords.java000066400000000000000000000017121374004044700220460ustar00rootroot00000000000000// collections/UniqueWords.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.nio.file.*; public class UniqueWords { public static void main(String[] args) throws Exception { List lines = Files.readAllLines( Paths.get("SetOperations.java")); Set words = new TreeSet<>(); for(String line : lines) for(String word : line.split("\\W+")) if(word.trim().length() > 0) words.add(word); System.out.println(words); } } /* Output: [A, B, C, Collections, D, E, F, G, H, HashSet, I, J, K, L, M, N, Output, Set, SetOperations, String, System, X, Y, Z, add, addAll, added, args, class, collections, contains, containsAll, false, from, import, in, java, main, new, out, println, public, remove, removeAll, removed, set1, set2, split, static, to, true, util, void] */ OnJava8-Examples-1.0/collections/UniqueWordsAlphabetic.java000066400000000000000000000020271374004044700240230ustar00rootroot00000000000000// collections/UniqueWordsAlphabetic.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Producing an alphabetic listing import java.util.*; import java.nio.file.*; public class UniqueWordsAlphabetic { public static void main(String[] args) throws Exception { List lines = Files.readAllLines( Paths.get("SetOperations.java")); Set words = new TreeSet<>(String.CASE_INSENSITIVE_ORDER); for(String line : lines) for(String word : line.split("\\W+")) if(word.trim().length() > 0) words.add(word); System.out.println(words); } } /* Output: [A, add, addAll, added, args, B, C, class, collections, contains, containsAll, D, E, F, false, from, G, H, HashSet, I, import, in, J, java, K, L, M, main, N, new, out, Output, println, public, remove, removeAll, removed, Set, set1, set2, SetOperations, split, static, String, System, to, true, util, void, X, Y, Z] */ OnJava8-Examples-1.0/collectiontopics/000077500000000000000000000000001374004044700177545ustar00rootroot00000000000000OnJava8-Examples-1.0/collectiontopics/AssociativeArray.java000066400000000000000000000033401374004044700240700ustar00rootroot00000000000000// collectiontopics/AssociativeArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Associates keys with values public class AssociativeArray { private Object[][] pairs; private int index; public AssociativeArray(int length) { pairs = new Object[length][2]; } public void put(K key, V value) { if(index >= pairs.length) throw new ArrayIndexOutOfBoundsException(); pairs[index++] = new Object[]{ key, value }; } @SuppressWarnings("unchecked") public V get(K key) { for(int i = 0; i < index; i++) if(key.equals(pairs[i][0])) return (V)pairs[i][1]; return null; // Did not find key } @Override public String toString() { StringBuilder result = new StringBuilder(); for(int i = 0; i < index; i++) { result.append(pairs[i][0].toString()); result.append(" : "); result.append(pairs[i][1].toString()); if(i < index - 1) result.append("\n"); } return result.toString(); } public static void main(String[] args) { AssociativeArray map = new AssociativeArray<>(6); map.put("sky", "blue"); map.put("grass", "green"); map.put("ocean", "dancing"); map.put("tree", "tall"); map.put("earth", "brown"); map.put("sun", "warm"); try { map.put("extra", "object"); // Past the end } catch(ArrayIndexOutOfBoundsException e) { System.out.println("Too many objects!"); } System.out.println(map); System.out.println(map.get("ocean")); } } /* Output: Too many objects! sky : blue grass : green ocean : dancing tree : tall earth : brown sun : warm dancing */ OnJava8-Examples-1.0/collectiontopics/Bits.java000066400000000000000000000042571374004044700215300ustar00rootroot00000000000000// collectiontopics/Bits.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of BitSet import java.util.*; public class Bits { public static void printBitSet(BitSet b) { System.out.println("bits: " + b); StringBuilder bbits = new StringBuilder(); for(int j = 0; j < b.size() ; j++) bbits.append(b.get(j) ? "1" : "0"); System.out.println("bit pattern: " + bbits); } public static void main(String[] args) { Random rand = new Random(47); // Take the LSB of nextInt(): byte bt = (byte)rand.nextInt(); BitSet bb = new BitSet(); for(int i = 7; i >= 0; i--) if(((1 << i) & bt) != 0) bb.set(i); else bb.clear(i); System.out.println("byte value: " + bt); printBitSet(bb); short st = (short)rand.nextInt(); BitSet bs = new BitSet(); for(int i = 15; i >= 0; i--) if(((1 << i) & st) != 0) bs.set(i); else bs.clear(i); System.out.println("short value: " + st); printBitSet(bs); int it = rand.nextInt(); BitSet bi = new BitSet(); for(int i = 31; i >= 0; i--) if(((1 << i) & it) != 0) bi.set(i); else bi.clear(i); System.out.println("int value: " + it); printBitSet(bi); // Test bitsets >= 64 bits: BitSet b127 = new BitSet(); b127.set(127); System.out.println("set bit 127: " + b127); BitSet b255 = new BitSet(65); b255.set(255); System.out.println("set bit 255: " + b255); BitSet b1023 = new BitSet(512); b1023.set(1023); b1023.set(1024); System.out.println("set bit 1023: " + b1023); } } /* Output: byte value: -107 bits: {0, 2, 4, 7} bit pattern: 101010010000000000000000000000000000000000 0000000000000000000000 short value: 1302 bits: {1, 2, 4, 8, 10} bit pattern: 011010001010000000000000000000000000000000 0000000000000000000000 int value: -2014573909 bits: {0, 1, 3, 5, 7, 9, 11, 18, 19, 21, 22, 23, 24, 25, 26, 31} bit pattern: 110101010101000000110111111000010000000000 0000000000000000000000 set bit 127: {127} set bit 255: {255} set bit 1023: {1023, 1024} */ OnJava8-Examples-1.0/collectiontopics/CanonicalMapping.java000066400000000000000000000026501374004044700240250ustar00rootroot00000000000000// collectiontopics/CanonicalMapping.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates WeakHashMap import java.util.*; class Element { private String ident; Element(String id) { ident = id; } @Override public String toString() { return ident; } @Override public int hashCode() { return Objects.hashCode(ident); } @Override public boolean equals(Object r) { return r instanceof Element && Objects.equals(ident, ((Element)r).ident); } @SuppressWarnings("deprecation") @Override protected void finalize() { System.out.println("Finalizing " + getClass().getSimpleName() + " " + ident); } } class Key extends Element { Key(String id) { super(id); } } class Value extends Element { Value(String id) { super(id); } } public class CanonicalMapping { public static void main(String[] args) { int size = 1000; // Or, choose size via the command line: if(args.length > 0) size = Integer.valueOf(args[0]); Key[] keys = new Key[size]; WeakHashMap map = new WeakHashMap<>(); for(int i = 0; i < size; i++) { Key k = new Key(Integer.toString(i)); Value v = new Value(Integer.toString(i)); if(i % 3 == 0) keys[i] = k; // Save as "real" references map.put(k, v); } System.gc(); } } OnJava8-Examples-1.0/collectiontopics/CollectionMethods.java000066400000000000000000000060021374004044700242340ustar00rootroot00000000000000// collectiontopics/CollectionMethods.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Things you can do with all Collections import java.util.*; import static onjava.HTMLColors.*; public class CollectionMethods { public static void main(String[] args) { Collection c = new ArrayList<>(LIST.subList(0, 4)); c.add("ten"); c.add("eleven"); show(c); border(); // Make an array from the List: Object[] array = c.toArray(); // Make a String array from the List: String[] str = c.toArray(new String[0]); // Find max and min elements; this means // different things depending on the way // the Comparable interface is implemented: System.out.println( "Collections.max(c) = " + Collections.max(c)); System.out.println( "Collections.min(c) = " + Collections.min(c)); border(); // Add a Collection to another Collection Collection c2 = new ArrayList<>(LIST.subList(10, 14)); c.addAll(c2); show(c); border(); c.remove(LIST.get(0)); show(c); border(); // Remove all components that are // in the argument collection: c.removeAll(c2); show(c); border(); c.addAll(c2); show(c); border(); // Is an element in this Collection? String val = LIST.get(3); System.out.println( "c.contains(" + val + ") = " + c.contains(val)); // Is a Collection in this Collection? System.out.println( "c.containsAll(c2) = " + c.containsAll(c2)); Collection c3 = ((List)c).subList(3, 5); // Keep all the elements that are in both // c2 and c3 (an intersection of sets): c2.retainAll(c3); show(c2); // Throw away all the elements // in c2 that also appear in c3: c2.removeAll(c3); System.out.println( "c2.isEmpty() = " + c2.isEmpty()); border(); // Functional operation: c = new ArrayList<>(LIST); c.removeIf(s -> !s.startsWith("P")); c.removeIf(s -> s.startsWith("Pale")); // Stream operation: c.stream().forEach(System.out::println); c.clear(); // Remove all elements System.out.println("after c.clear():" + c); } } /* Output: AliceBlue AntiqueWhite Aquamarine Azure ten eleven ****************************** Collections.max(c) = ten Collections.min(c) = AliceBlue ****************************** AliceBlue AntiqueWhite Aquamarine Azure ten eleven Brown BurlyWood CadetBlue Chartreuse ****************************** AntiqueWhite Aquamarine Azure ten eleven Brown BurlyWood CadetBlue Chartreuse ****************************** AntiqueWhite Aquamarine Azure ten eleven ****************************** AntiqueWhite Aquamarine Azure ten eleven Brown BurlyWood CadetBlue Chartreuse ****************************** c.contains(Azure) = true c.containsAll(c2) = true c2.isEmpty() = true ****************************** PapayaWhip PeachPuff Peru Pink Plum PowderBlue Purple after c.clear():[] */ OnJava8-Examples-1.0/collectiontopics/Enumerations.java000066400000000000000000000013751374004044700232760ustar00rootroot00000000000000// collectiontopics/Enumerations.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Java 1.0/1.1 Vector and Enumeration import java.util.*; import onjava.*; public class Enumerations { public static void main(String[] args) { Vector v = new Vector<>(Countries.names(10)); Enumeration e = v.elements(); while(e.hasMoreElements()) System.out.print(e.nextElement() + ", "); // Produce an Enumeration from a Collection: e = Collections.enumeration(new ArrayList<>()); } } /* Output: ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI, CAMEROON, CAPE VERDE, CENTRAL AFRICAN REPUBLIC, CHAD, */ OnJava8-Examples-1.0/collectiontopics/FailFast.java000066400000000000000000000011531374004044700223100ustar00rootroot00000000000000// collectiontopics/FailFast.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates the "fail-fast" behavior import java.util.*; public class FailFast { public static void main(String[] args) { Collection c = new ArrayList<>(); Iterator it = c.iterator(); c.add("An object"); try { String s = it.next(); } catch(ConcurrentModificationException e) { System.out.println(e); } } } /* Output: java.util.ConcurrentModificationException */ OnJava8-Examples-1.0/collectiontopics/FillMapTest.java000066400000000000000000000017511374004044700230070ustar00rootroot00000000000000// collectiontopics/FillMapTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; import onjava.*; public class FillMapTest { public static void main(String[] args) { Map mcs = FillMap.basic( new Rand.String(4), new Count.Integer(), 7); System.out.println(mcs); HashMap hashm = FillMap.create(new Rand.String(4), new Count.Integer(), HashMap::new, 7); System.out.println(hashm); LinkedHashMap linkm = FillMap.create(new Rand.String(4), new Count.Integer(), LinkedHashMap::new, 7); System.out.println(linkm); } } /* Output: {npcc=1, ztdv=6, gvgm=3, btpe=0, einn=4, eelo=5, uxsz=2} {npcc=1, ztdv=6, gvgm=3, btpe=0, einn=4, eelo=5, uxsz=2} {btpe=0, npcc=1, uxsz=2, gvgm=3, einn=4, eelo=5, ztdv=6} */ OnJava8-Examples-1.0/collectiontopics/FillingLists.java000066400000000000000000000017651374004044700232330ustar00rootroot00000000000000// collectiontopics/FillingLists.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Collections.fill() & Collections.nCopies() import java.util.*; class StringAddress { private String s; StringAddress(String s) { this.s = s; } @Override public String toString() { return super.toString() + " " + s; } } public class FillingLists { public static void main(String[] args) { List list = new ArrayList<>( Collections.nCopies(4, new StringAddress("Hello"))); System.out.println(list); Collections.fill(list, new StringAddress("World!")); System.out.println(list); } } /* Output: [StringAddress@15db9742 Hello, StringAddress@15db9742 Hello, StringAddress@15db9742 Hello, StringAddress@15db9742 Hello] [StringAddress@6d06d69c World!, StringAddress@6d06d69c World!, StringAddress@6d06d69c World!, StringAddress@6d06d69c World!] */ OnJava8-Examples-1.0/collectiontopics/FunctionalMap.java000066400000000000000000000014441374004044700233620ustar00rootroot00000000000000// collectiontopics/FunctionalMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Functional operations on a Map import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import static onjava.HTMLColors.*; public class FunctionalMap { public static void main(String[] args) { MAP.entrySet().stream() .map(Map.Entry::getValue) .filter(v -> v.startsWith("Dark")) .map(v -> v.replaceFirst("Dark", "Hot")) .forEach(System.out::println); } } /* Output: HotBlue HotCyan HotGoldenRod HotGray HotGreen HotKhaki HotMagenta HotOliveGreen HotOrange HotOrchid HotRed HotSalmon HotSeaGreen HotSlateBlue HotSlateGray HotTurquoise HotViolet */ OnJava8-Examples-1.0/collectiontopics/HTMLColorTest.java000066400000000000000000000037101374004044700232230ustar00rootroot00000000000000// collectiontopics/HTMLColorTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import static onjava.HTMLColors.*; public class HTMLColorTest { static final int DISPLAY_SIZE = 20; public static void main(String[] args) { show(MAP, DISPLAY_SIZE); border(); showInv(INVMAP, DISPLAY_SIZE); border(); show(LIST, DISPLAY_SIZE); border(); showrgb(RGBLIST, DISPLAY_SIZE); } } /* Output: 0xF0F8FF: AliceBlue 0xFAEBD7: AntiqueWhite 0x7FFFD4: Aquamarine 0xF0FFFF: Azure 0xF5F5DC: Beige 0xFFE4C4: Bisque 0x000000: Black 0xFFEBCD: BlanchedAlmond 0x0000FF: Blue 0x8A2BE2: BlueViolet 0xA52A2A: Brown 0xDEB887: BurlyWood 0x5F9EA0: CadetBlue 0x7FFF00: Chartreuse 0xD2691E: Chocolate 0xFF7F50: Coral 0x6495ED: CornflowerBlue 0xFFF8DC: Cornsilk 0xDC143C: Crimson 0x00FFFF: Cyan ****************************** AliceBlue 0xF0F8FF AntiqueWhite 0xFAEBD7 Aquamarine 0x7FFFD4 Azure 0xF0FFFF Beige 0xF5F5DC Bisque 0xFFE4C4 Black 0x000000 BlanchedAlmond 0xFFEBCD Blue 0x0000FF BlueViolet 0x8A2BE2 Brown 0xA52A2A BurlyWood 0xDEB887 CadetBlue 0x5F9EA0 Chartreuse 0x7FFF00 Chocolate 0xD2691E Coral 0xFF7F50 CornflowerBlue 0x6495ED Cornsilk 0xFFF8DC Crimson 0xDC143C Cyan 0x00FFFF ****************************** AliceBlue AntiqueWhite Aquamarine Azure Beige Bisque Black BlanchedAlmond Blue BlueViolet Brown BurlyWood CadetBlue Chartreuse Chocolate Coral CornflowerBlue Cornsilk Crimson Cyan ****************************** 0xF0F8FF 0xFAEBD7 0x7FFFD4 0xF0FFFF 0xF5F5DC 0xFFE4C4 0x000000 0xFFEBCD 0x0000FF 0x8A2BE2 0xA52A2A 0xDEB887 0x5F9EA0 0x7FFF00 0xD2691E 0xFF7F50 0x6495ED 0xFFF8DC 0xDC143C 0x00FFFF */ OnJava8-Examples-1.0/collectiontopics/LinkedHashMapDemo.java000066400000000000000000000020171374004044700240740ustar00rootroot00000000000000// collectiontopics/LinkedHashMapDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // What you can do with a LinkedHashMap import java.util.*; import onjava.*; public class LinkedHashMapDemo { public static void main(String[] args) { LinkedHashMap linkedMap = new LinkedHashMap<>(new CountMap(9)); System.out.println(linkedMap); // Least-recently-used order: linkedMap = new LinkedHashMap<>(16, 0.75f, true); linkedMap.putAll(new CountMap(9)); System.out.println(linkedMap); for(int i = 0; i < 6; i++) linkedMap.get(i); System.out.println(linkedMap); linkedMap.get(0); System.out.println(linkedMap); } } /* Output: {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0} {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0} {6=G0, 7=H0, 8=I0, 0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0} {6=G0, 7=H0, 8=I0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 0=A0} */ OnJava8-Examples-1.0/collectiontopics/ListOps.java000066400000000000000000000133561374004044700222240ustar00rootroot00000000000000// collectiontopics/ListOps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Things you can do with Lists import java.util.*; import onjava.HTMLColors; public class ListOps { // Create a short list for testing: static final List LIST = HTMLColors.LIST.subList(0, 10); private static boolean b; private static String s; private static int i; private static Iterator it; private static ListIterator lit; public static void basicTest(List a) { a.add(1, "x"); // Add at location 1 a.add("x"); // Add at end // Add a collection: a.addAll(LIST); // Add a collection starting at location 3: a.addAll(3, LIST); b = a.contains("1"); // Is it in there? // Is the entire collection in there? b = a.containsAll(LIST); // Lists allow random access, which is cheap // for ArrayList, expensive for LinkedList: s = a.get(1); // Get (typed) object at location 1 i = a.indexOf("1"); // Tell index of object b = a.isEmpty(); // Any elements inside? it = a.iterator(); // Ordinary Iterator lit = a.listIterator(); // ListIterator lit = a.listIterator(3); // Start at location 3 i = a.lastIndexOf("1"); // Last match a.remove(1); // Remove location 1 a.remove("3"); // Remove this object a.set(1, "y"); // Set location 1 to "y" // Keep everything that's in the argument // (the intersection of the two sets): a.retainAll(LIST); // Remove everything that's in the argument: a.removeAll(LIST); i = a.size(); // How big is it? a.clear(); // Remove all elements } public static void iterMotion(List a) { ListIterator it = a.listIterator(); b = it.hasNext(); b = it.hasPrevious(); s = it.next(); i = it.nextIndex(); s = it.previous(); i = it.previousIndex(); } public static void iterManipulation(List a) { ListIterator it = a.listIterator(); it.add("47"); // Must move to an element after add(): it.next(); // Remove the element after the new one: it.remove(); // Must move to an element after remove(): it.next(); // Change the element after the deleted one: it.set("47"); } public static void testVisual(List a) { System.out.println(a); List b = LIST; System.out.println("b = " + b); a.addAll(b); a.addAll(b); System.out.println(a); // Insert, remove, and replace elements // using a ListIterator: ListIterator x = a.listIterator(a.size()/2); x.add("one"); System.out.println(a); System.out.println(x.next()); x.remove(); System.out.println(x.next()); x.set("47"); System.out.println(a); // Traverse the list backwards: x = a.listIterator(a.size()); while(x.hasPrevious()) System.out.print(x.previous() + " "); System.out.println(); System.out.println("testVisual finished"); } // There are some things that only LinkedLists can do: public static void testLinkedList() { LinkedList ll = new LinkedList<>(); ll.addAll(LIST); System.out.println(ll); // Treat it like a stack, pushing: ll.addFirst("one"); ll.addFirst("two"); System.out.println(ll); // Like "peeking" at the top of a stack: System.out.println(ll.getFirst()); // Like popping a stack: System.out.println(ll.removeFirst()); System.out.println(ll.removeFirst()); // Treat it like a queue, pulling elements // off the tail end: System.out.println(ll.removeLast()); System.out.println(ll); } public static void main(String[] args) { // Make and fill a new list each time: basicTest(new LinkedList<>(LIST)); basicTest(new ArrayList<>(LIST)); iterMotion(new LinkedList<>(LIST)); iterMotion(new ArrayList<>(LIST)); iterManipulation(new LinkedList<>(LIST)); iterManipulation(new ArrayList<>(LIST)); testVisual(new LinkedList<>(LIST)); testLinkedList(); } } /* Output: [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] b = [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, one, Bisque, Black, BlanchedAlmond, Blue, BlueViolet, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] Bisque Black [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, one, 47, BlanchedAlmond, Blue, BlueViolet, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] BlueViolet Blue BlanchedAlmond Black Bisque Beige Azure Aquamarine AntiqueWhite AliceBlue BlueViolet Blue BlanchedAlmond 47 one Beige Azure Aquamarine AntiqueWhite AliceBlue BlueViolet Blue BlanchedAlmond Black Bisque Beige Azure Aquamarine AntiqueWhite AliceBlue testVisual finished [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] [two, one, AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet] two two one BlueViolet [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black, BlanchedAlmond, Blue] */ OnJava8-Examples-1.0/collectiontopics/ListSortSearch.java000066400000000000000000000036151374004044700235350ustar00rootroot00000000000000// collectiontopics/ListSortSearch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Sorting/searching Lists with Collections utilities import java.util.*; public class ListSortSearch { public static void main(String[] args) { List list = new ArrayList<>(Utilities.list); list.addAll(Utilities.list); System.out.println(list); Collections.shuffle(list, new Random(47)); System.out.println("Shuffled: " + list); // Use ListIterator to trim off last elements: ListIterator it = list.listIterator(10); while(it.hasNext()) { it.next(); it.remove(); } System.out.println("Trimmed: " + list); Collections.sort(list); System.out.println("Sorted: " + list); String key = list.get(7); int index = Collections.binarySearch(list, key); System.out.println( "Location of " + key + " is " + index + ", list.get(" + index + ") = " + list.get(index)); Collections.sort(list, String.CASE_INSENSITIVE_ORDER); System.out.println( "Case-insensitive sorted: " + list); key = list.get(7); index = Collections.binarySearch(list, key, String.CASE_INSENSITIVE_ORDER); System.out.println( "Location of " + key + " is " + index + ", list.get(" + index + ") = " + list.get(index)); } } /* Output: [one, Two, three, Four, five, six, one, one, Two, three, Four, five, six, one] Shuffled: [Four, five, one, one, Two, six, six, three, three, five, Four, Two, one, one] Trimmed: [Four, five, one, one, Two, six, six, three, three, five] Sorted: [Four, Two, five, five, one, one, six, six, three, three] Location of six is 7, list.get(7) = six Case-insensitive sorted: [five, five, Four, one, one, six, six, three, three, Two] Location of three is 7, list.get(7) = three */ OnJava8-Examples-1.0/collectiontopics/MapOps.java000066400000000000000000000046741374004044700220310ustar00rootroot00000000000000// collectiontopics/MapOps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Things you can do with Maps import java.util.concurrent.*; import java.util.*; import onjava.*; public class MapOps { public static void printKeys(Map map) { System.out.print("Size = " + map.size() + ", "); System.out.print("Keys: "); // Produce a Set of the keys: System.out.println(map.keySet()); } public static void test(Map map) { System.out.println( map.getClass().getSimpleName()); map.putAll(new CountMap(25)); // Map has 'Set' behavior for keys: map.putAll(new CountMap(25)); printKeys(map); // Producing a Collection of the values: System.out.print("Values: "); System.out.println(map.values()); System.out.println(map); System.out.println("map.containsKey(11): " + map.containsKey(11)); System.out.println( "map.get(11): " + map.get(11)); System.out.println("map.containsValue(\"F0\"): " + map.containsValue("F0")); Integer key = map.keySet().iterator().next(); System.out.println("First key in map: " + key); map.remove(key); printKeys(map); map.clear(); System.out.println( "map.isEmpty(): " + map.isEmpty()); map.putAll(new CountMap(25)); // Operations on the Set change the Map: map.keySet().removeAll(map.keySet()); System.out.println( "map.isEmpty(): " + map.isEmpty()); } public static void main(String[] args) { test(new HashMap<>()); test(new TreeMap<>()); test(new LinkedHashMap<>()); test(new IdentityHashMap<>()); test(new ConcurrentHashMap<>()); test(new WeakHashMap<>()); } } /* Output: (First 11 Lines) HashMap Size = 25, Keys: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24] Values: [A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0, L0, M0, N0, O0, P0, Q0, R0, S0, T0, U0, V0, W0, X0, Y0] {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0, 10=K0, 11=L0, 12=M0, 13=N0, 14=O0, 15=P0, 16=Q0, 17=R0, 18=S0, 19=T0, 20=U0, 21=V0, 22=W0, 23=X0, 24=Y0} map.containsKey(11): true map.get(11): L0 map.containsValue("F0"): true First key in map: 0 Size = 24, Keys: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24] map.isEmpty(): true map.isEmpty(): true ... */ OnJava8-Examples-1.0/collectiontopics/NavMap.java000066400000000000000000000043211374004044700220010ustar00rootroot00000000000000// collectiontopics/NavMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // NavigableMap produces pieces of a Map import java.util.*; import java.util.concurrent.*; import static onjava.HTMLColors.*; public class NavMap { public static final NavigableMap COLORS = new ConcurrentSkipListMap<>(MAP); public static void main(String[] args) { show(COLORS.firstEntry()); border(); show(COLORS.lastEntry()); border(); NavigableMap toLime = COLORS.headMap(rgb("Lime"), true); show(toLime); border(); show(COLORS.ceilingEntry(rgb("DeepSkyBlue") - 1)); border(); show(COLORS.floorEntry(rgb("DeepSkyBlue") - 1)); border(); show(toLime.descendingMap()); border(); show(COLORS.tailMap(rgb("MistyRose"), true)); border(); show(COLORS.subMap( rgb("Orchid"), true, rgb("DarkSalmon"), false)); } } /* Output: 0x000000: Black ****************************** 0xFFFFFF: White ****************************** 0x000000: Black 0x000080: Navy 0x00008B: DarkBlue 0x0000CD: MediumBlue 0x0000FF: Blue 0x006400: DarkGreen 0x008000: Green 0x008080: Teal 0x008B8B: DarkCyan 0x00BFFF: DeepSkyBlue 0x00CED1: DarkTurquoise 0x00FA9A: MediumSpringGreen 0x00FF00: Lime ****************************** 0x00BFFF: DeepSkyBlue ****************************** 0x008B8B: DarkCyan ****************************** 0x00FF00: Lime 0x00FA9A: MediumSpringGreen 0x00CED1: DarkTurquoise 0x00BFFF: DeepSkyBlue 0x008B8B: DarkCyan 0x008080: Teal 0x008000: Green 0x006400: DarkGreen 0x0000FF: Blue 0x0000CD: MediumBlue 0x00008B: DarkBlue 0x000080: Navy 0x000000: Black ****************************** 0xFFE4E1: MistyRose 0xFFEBCD: BlanchedAlmond 0xFFEFD5: PapayaWhip 0xFFF0F5: LavenderBlush 0xFFF5EE: SeaShell 0xFFF8DC: Cornsilk 0xFFFACD: LemonChiffon 0xFFFAF0: FloralWhite 0xFFFAFA: Snow 0xFFFF00: Yellow 0xFFFFE0: LightYellow 0xFFFFF0: Ivory 0xFFFFFF: White ****************************** 0xDA70D6: Orchid 0xDAA520: GoldenRod 0xDB7093: PaleVioletRed 0xDC143C: Crimson 0xDCDCDC: Gainsboro 0xDDA0DD: Plum 0xDEB887: BurlyWood 0xE0FFFF: LightCyan 0xE6E6FA: Lavender */ OnJava8-Examples-1.0/collectiontopics/QueueBehavior.java000066400000000000000000000033551374004044700233710ustar00rootroot00000000000000// collectiontopics/QueueBehavior.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Compares basic behavior import java.util.*; import java.util.stream.*; import java.util.concurrent.*; public class QueueBehavior { static Stream strings() { return Arrays.stream( ("one two three four five six seven " + "eight nine ten").split(" ")); } static void test(int id, Queue queue) { System.out.print(id + ": "); strings().map(queue::offer).count(); while(queue.peek() != null) System.out.print(queue.remove() + " "); System.out.println(); } public static void main(String[] args) { int count = 10; test(1, new LinkedList<>()); test(2, new PriorityQueue<>()); test(3, new ArrayBlockingQueue<>(count)); test(4, new ConcurrentLinkedQueue<>()); test(5, new LinkedBlockingQueue<>()); test(6, new PriorityBlockingQueue<>()); test(7, new ArrayDeque<>()); test(8, new ConcurrentLinkedDeque<>()); test(9, new LinkedBlockingDeque<>()); test(10, new LinkedTransferQueue<>()); test(11, new SynchronousQueue<>()); } } /* Output: 1: one two three four five six seven eight nine ten 2: eight five four nine one seven six ten three two 3: one two three four five six seven eight nine ten 4: one two three four five six seven eight nine ten 5: one two three four five six seven eight nine ten 6: eight five four nine one seven six ten three two 7: one two three four five six seven eight nine ten 8: one two three four five six seven eight nine ten 9: one two three four five six seven eight nine ten 10: one two three four five six seven eight nine ten 11: */ OnJava8-Examples-1.0/collectiontopics/ReadOnly.java000066400000000000000000000032521374004044700223360ustar00rootroot00000000000000// collectiontopics/ReadOnly.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using the Collections.unmodifiable methods import java.util.*; import onjava.*; public class ReadOnly { static Collection data = new ArrayList<>(Countries.names(6)); public static void main(String[] args) { Collection c = Collections.unmodifiableCollection( new ArrayList<>(data)); System.out.println(c); // Reading is OK //- c.add("one"); // Can't change it List a = Collections.unmodifiableList( new ArrayList<>(data)); ListIterator lit = a.listIterator(); System.out.println(lit.next()); // Reading is OK //- lit.add("one"); // Can't change it Set s = Collections.unmodifiableSet( new HashSet<>(data)); System.out.println(s); // Reading is OK //- s.add("one"); // Can't change it // For a SortedSet: Set ss = Collections.unmodifiableSortedSet( new TreeSet<>(data)); Map m = Collections.unmodifiableMap( new HashMap<>(Countries.capitals(6))); System.out.println(m); // Reading is OK //- m.put("Ralph", "Howdy!"); // For a SortedMap: Map sm = Collections.unmodifiableSortedMap( new TreeMap<>(Countries.capitals(6))); } } /* Output: [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI] ALGERIA [BENIN, BOTSWANA, ANGOLA, BURKINA FASO, ALGERIA, BURUNDI] {BENIN=Porto-Novo, BOTSWANA=Gaberone, ANGOLA=Luanda, BURKINA FASO=Ouagadougou, ALGERIA=Algiers, BURUNDI=Bujumbura} */ OnJava8-Examples-1.0/collectiontopics/References.java000066400000000000000000000056771374004044700227170ustar00rootroot00000000000000// collectiontopics/References.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates Reference objects import java.lang.ref.*; import java.util.*; class VeryBig { private static final int SIZE = 10000; private long[] la = new long[SIZE]; private String ident; VeryBig(String id) { ident = id; } @Override public String toString() { return ident; } @SuppressWarnings("deprecation") @Override protected void finalize() { System.out.println("Finalizing " + ident); } } public class References { private static ReferenceQueue rq = new ReferenceQueue<>(); public static void checkQueue() { Reference inq = rq.poll(); if(inq != null) System.out.println("In queue: " + inq.get()); } public static void main(String[] args) { int size = 10; // Or, choose size via the command line: if(args.length > 0) size = Integer.valueOf(args[0]); LinkedList> sa = new LinkedList<>(); for(int i = 0; i < size; i++) { sa.add(new SoftReference<>( new VeryBig("Soft " + i), rq)); System.out.println( "Just created: " + sa.getLast()); checkQueue(); } LinkedList> wa = new LinkedList<>(); for(int i = 0; i < size; i++) { wa.add(new WeakReference<>( new VeryBig("Weak " + i), rq)); System.out.println( "Just created: " + wa.getLast()); checkQueue(); } SoftReference s = new SoftReference<>(new VeryBig("Soft")); WeakReference w = new WeakReference<>(new VeryBig("Weak")); System.gc(); LinkedList> pa = new LinkedList<>(); for(int i = 0; i < size; i++) { pa.add(new PhantomReference<>( new VeryBig("Phantom " + i), rq)); System.out.println( "Just created: " + pa.getLast()); checkQueue(); } } } /* Output: (First and Last 10 Lines) Just created: java.lang.ref.SoftReference@15db9742 Just created: java.lang.ref.SoftReference@6d06d69c Just created: java.lang.ref.SoftReference@7852e922 Just created: java.lang.ref.SoftReference@4e25154f Just created: java.lang.ref.SoftReference@70dea4e Just created: java.lang.ref.SoftReference@5c647e05 Just created: java.lang.ref.SoftReference@33909752 Just created: java.lang.ref.SoftReference@55f96302 Just created: java.lang.ref.SoftReference@3d4eac69 Just created: java.lang.ref.SoftReference@42a57993 ...________...________...________...________... Just created: java.lang.ref.PhantomReference@45ee12a7 In queue: null Just created: java.lang.ref.PhantomReference@330bedb4 In queue: null Just created: java.lang.ref.PhantomReference@2503dbd3 In queue: null Just created: java.lang.ref.PhantomReference@4b67cf4d In queue: null Just created: java.lang.ref.PhantomReference@7ea987ac In queue: null */ OnJava8-Examples-1.0/collectiontopics/SetOrder.java000066400000000000000000000031021374004044700223420ustar00rootroot00000000000000// collectiontopics/SetOrder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.HTMLColors; public class SetOrder { static String[] sets = { "java.util.HashSet", "java.util.TreeSet", "java.util.concurrent.ConcurrentSkipListSet", "java.util.LinkedHashSet", "java.util.concurrent.CopyOnWriteArraySet", }; static final List RLIST = new ArrayList<>(HTMLColors.LIST); static { Collections.reverse(RLIST); } public static void main(String[] args) throws Exception { for(String type: sets) { System.out.format("[-> %s <-]%n", type.substring(type.lastIndexOf('.') + 1)); @SuppressWarnings({"unchecked", "deprecation"}) Set set = (Set) Class.forName(type).newInstance(); set.addAll(RLIST); set.stream() .limit(10) .forEach(System.out::println); } } } /* Output: [-> HashSet <-] MediumOrchid PaleGoldenRod Sienna LightSlateGray DarkSeaGreen Black Gainsboro Orange LightCoral DodgerBlue [-> TreeSet <-] AliceBlue AntiqueWhite Aquamarine Azure Beige Bisque Black BlanchedAlmond Blue BlueViolet [-> ConcurrentSkipListSet <-] AliceBlue AntiqueWhite Aquamarine Azure Beige Bisque Black BlanchedAlmond Blue BlueViolet [-> LinkedHashSet <-] YellowGreen Yellow WhiteSmoke White Wheat Violet Turquoise Tomato Thistle Teal [-> CopyOnWriteArraySet <-] YellowGreen Yellow WhiteSmoke White Wheat Violet Turquoise Tomato Thistle Teal */ OnJava8-Examples-1.0/collectiontopics/SimpleDeques.java000066400000000000000000000040251374004044700232200ustar00rootroot00000000000000// collectiontopics/SimpleDeques.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Very basic test of Deques import java.util.*; import java.util.concurrent.*; import java.util.function.*; class CountString implements Supplier { private int n = 0; CountString() {} CountString(int start) { n = start; } @Override public String get() { return Integer.toString(n++); } } public class SimpleDeques { static void test(Deque deque) { CountString s1 = new CountString(), s2 = new CountString(20); for(int n = 0; n < 8; n++) { deque.offerFirst(s1.get()); deque.offerLast(s2.get()); // Same as offer() } System.out.println(deque); String result = ""; while(deque.size() > 0) { System.out.print(deque.peekFirst() + " "); result += deque.pollFirst() + " "; System.out.print(deque.peekLast() + " "); result += deque.pollLast() + " "; } System.out.println("\n" + result); } public static void main(String[] args) { int count = 10; System.out.println("LinkedList"); test(new LinkedList<>()); System.out.println("ArrayDeque"); test(new ArrayDeque<>()); System.out.println("LinkedBlockingDeque"); test(new LinkedBlockingDeque<>(count)); System.out.println("ConcurrentLinkedDeque"); test(new ConcurrentLinkedDeque<>()); } } /* Output: LinkedList [7, 6, 5, 4, 3, 2, 1, 0, 20, 21, 22, 23, 24, 25, 26, 27] 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20 ArrayDeque [7, 6, 5, 4, 3, 2, 1, 0, 20, 21, 22, 23, 24, 25, 26, 27] 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20 LinkedBlockingDeque [4, 3, 2, 1, 0, 20, 21, 22, 23, 24] 4 24 3 23 2 22 1 21 0 20 4 24 3 23 2 22 1 21 0 20 ConcurrentLinkedDeque [7, 6, 5, 4, 3, 2, 1, 0, 20, 21, 22, 23, 24, 25, 26, 27] 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20 */ OnJava8-Examples-1.0/collectiontopics/SortedMapDemo.java000066400000000000000000000022621374004044700233240ustar00rootroot00000000000000// collectiontopics/SortedMapDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // What you can do with a TreeMap import java.util.*; import onjava.*; public class SortedMapDemo { public static void main(String[] args) { TreeMap sortedMap = new TreeMap<>(new CountMap(10)); System.out.println(sortedMap); Integer low = sortedMap.firstKey(); Integer high = sortedMap.lastKey(); System.out.println(low); System.out.println(high); Iterator it = sortedMap.keySet().iterator(); for(int i = 0; i <= 6; i++) { if(i == 3) low = it.next(); if(i == 6) high = it.next(); else it.next(); } System.out.println(low); System.out.println(high); System.out.println(sortedMap.subMap(low, high)); System.out.println(sortedMap.headMap(high)); System.out.println(sortedMap.tailMap(low)); } } /* Output: {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0} 0 9 3 7 {3=D0, 4=E0, 5=F0, 6=G0} {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0} {3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0} */ OnJava8-Examples-1.0/collectiontopics/SortedSetDemo.java000066400000000000000000000023431374004044700233420ustar00rootroot00000000000000// collectiontopics/SortedSetDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import static java.util.stream.Collectors.*; public class SortedSetDemo { public static void main(String[] args) { SortedSet sortedSet = Arrays.stream( "one two three four five six seven eight" .split(" ")) .collect(toCollection(TreeSet::new)); System.out.println(sortedSet); String low = sortedSet.first(); String high = sortedSet.last(); System.out.println(low); System.out.println(high); Iterator it = sortedSet.iterator(); for(int i = 0; i <= 6; i++) { if(i == 3) low = it.next(); if(i == 6) high = it.next(); else it.next(); } System.out.println(low); System.out.println(high); System.out.println(sortedSet.subSet(low, high)); System.out.println(sortedSet.headSet(high)); System.out.println(sortedSet.tailSet(low)); } } /* Output: [eight, five, four, one, seven, six, three, two] eight two one two [one, seven, six, three] [eight, five, four, one, seven, six, three] [one, seven, six, three, two] */ OnJava8-Examples-1.0/collectiontopics/Stacks.java000066400000000000000000000037521374004044700220560ustar00rootroot00000000000000// collectiontopics/Stacks.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of Stack Class import java.util.*; enum Month { JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER } public class Stacks { public static void main(String[] args) { Stack stack = new Stack<>(); for(Month m : Month.values()) stack.push(m.toString()); System.out.println("stack = " + stack); // Treating a stack as a Vector: stack.addElement("The last line"); System.out.println( "element 5 = " + stack.elementAt(5)); System.out.println("popping elements:"); while(!stack.empty()) System.out.print(stack.pop() + " "); // Using a LinkedList as a Stack: LinkedList lstack = new LinkedList<>(); for(Month m : Month.values()) lstack.addFirst(m.toString()); System.out.println("lstack = " + lstack); while(!lstack.isEmpty()) System.out.print(lstack.removeFirst() + " "); // Using the Stack class from // the Collections Chapter: onjava.Stack stack2 = new onjava.Stack<>(); for(Month m : Month.values()) stack2.push(m.toString()); System.out.println("stack2 = " + stack2); while(!stack2.isEmpty()) System.out.print(stack2.pop() + " "); } } /* Output: stack = [JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE, JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER] element 5 = JUNE popping elements: The last line NOVEMBER OCTOBER SEPTEMBER AUGUST JULY JUNE MAY APRIL MARCH FEBRUARY JANUARY lstack = [NOVEMBER, OCTOBER, SEPTEMBER, AUGUST, JULY, JUNE, MAY, APRIL, MARCH, FEBRUARY, JANUARY] NOVEMBER OCTOBER SEPTEMBER AUGUST JULY JUNE MAY APRIL MARCH FEBRUARY JANUARY stack2 = [NOVEMBER, OCTOBER, SEPTEMBER, AUGUST, JULY, JUNE, MAY, APRIL, MARCH, FEBRUARY, JANUARY] NOVEMBER OCTOBER SEPTEMBER AUGUST JULY JUNE MAY APRIL MARCH FEBRUARY JANUARY */ OnJava8-Examples-1.0/collectiontopics/StreamFillMaps.java000066400000000000000000000027661374004044700235150ustar00rootroot00000000000000// collectiontopics/StreamFillMaps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; import onjava.*; class Letters implements Supplier> { private int number = 1; private char letter = 'A'; @Override public Pair get() { return new Pair<>(number++, "" + letter++); } } public class StreamFillMaps { public static void main(String[] args) { Map m = Stream.generate(new Letters()) .limit(11) .collect(Collectors .toMap(Pair::key, Pair::value)); System.out.println(m); // Two separate Suppliers: Rand.String rs = new Rand.String(3); Count.Character cc = new Count.Character(); Map mcs = Stream.generate( () -> Pair.make(cc.get(), rs.get())) .limit(8) .collect(Collectors .toMap(Pair::key, Pair::value)); System.out.println(mcs); // A key Supplier and a single value: Map mcs2 = Stream.generate( () -> Pair.make(cc.get(), "Val")) .limit(8) .collect(Collectors .toMap(Pair::key, Pair::value)); System.out.println(mcs2); } } /* Output: {1=A, 2=B, 3=C, 4=D, 5=E, 6=F, 7=G, 8=H, 9=I, 10=J, 11=K} {b=btp, c=enp, d=ccu, e=xsz, f=gvg, g=mei, h=nne, i=elo} {p=Val, q=Val, j=Val, k=Val, l=Val, m=Val, n=Val, o=Val} */ OnJava8-Examples-1.0/collectiontopics/SuppliersCollectionTest.java000066400000000000000000000045131374004044700254640ustar00rootroot00000000000000// collectiontopics/SuppliersCollectionTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; import onjava.*; class Government implements Supplier { static String[] foundation = ( "strange women lying in ponds " + "distributing swords is no basis " + "for a system of government").split(" "); private int index; @Override public String get() { return foundation[index++]; } } public class SuppliersCollectionTest { public static void main(String[] args) { // Suppliers class from the Generics chapter: Set set = Suppliers.create( LinkedHashSet::new, new Government(), 15); System.out.println(set); List list = Suppliers.create( LinkedList::new, new Government(), 15); System.out.println(list); list = new ArrayList<>(); Suppliers.fill(list, new Government(), 15); System.out.println(list); // Or we can use Streams: set = Arrays.stream(Government.foundation) .collect(Collectors.toSet()); System.out.println(set); list = Arrays.stream(Government.foundation) .collect(Collectors.toList()); System.out.println(list); list = Arrays.stream(Government.foundation) .collect(Collectors .toCollection(LinkedList::new)); System.out.println(list); set = Arrays.stream(Government.foundation) .collect(Collectors .toCollection(LinkedHashSet::new)); System.out.println(set); } } /* Output: [strange, women, lying, in, ponds, distributing, swords, is, no, basis, for, a, system, of, government] [strange, women, lying, in, ponds, distributing, swords, is, no, basis, for, a, system, of, government] [strange, women, lying, in, ponds, distributing, swords, is, no, basis, for, a, system, of, government] [ponds, no, a, in, swords, for, is, basis, strange, system, government, distributing, of, women, lying] [strange, women, lying, in, ponds, distributing, swords, is, no, basis, for, a, system, of, government] [strange, women, lying, in, ponds, distributing, swords, is, no, basis, for, a, system, of, government] [strange, women, lying, in, ponds, distributing, swords, is, no, basis, for, a, system, of, government] */ OnJava8-Examples-1.0/collectiontopics/Synchronization.java000066400000000000000000000015171374004044700240240ustar00rootroot00000000000000// collectiontopics/Synchronization.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using the Collections.synchronized methods import java.util.*; public class Synchronization { public static void main(String[] args) { Collection c = Collections.synchronizedCollection( new ArrayList<>()); List list = Collections .synchronizedList(new ArrayList<>()); Set s = Collections .synchronizedSet(new HashSet<>()); Set ss = Collections .synchronizedSortedSet(new TreeSet<>()); Map m = Collections .synchronizedMap(new HashMap<>()); Map sm = Collections .synchronizedSortedMap(new TreeMap<>()); } } OnJava8-Examples-1.0/collectiontopics/ToDoList.java000066400000000000000000000026541374004044700223270ustar00rootroot00000000000000// collectiontopics/ToDoList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A more complex use of PriorityQueue import java.util.*; class ToDoItem implements Comparable { private char primary; private int secondary; private String item; ToDoItem(String td, char pri, int sec) { primary = pri; secondary = sec; item = td; } @Override public int compareTo(ToDoItem arg) { if(primary > arg.primary) return +1; if(primary == arg.primary) if(secondary > arg.secondary) return +1; else if(secondary == arg.secondary) return 0; return -1; } @Override public String toString() { return Character.toString(primary) + secondary + ": " + item; } } class ToDoList { public static void main(String[] args) { PriorityQueue toDo = new PriorityQueue<>(); toDo.add(new ToDoItem("Empty trash", 'C', 4)); toDo.add(new ToDoItem("Feed dog", 'A', 2)); toDo.add(new ToDoItem("Feed bird", 'B', 7)); toDo.add(new ToDoItem("Mow lawn", 'C', 3)); toDo.add(new ToDoItem("Water lawn", 'A', 1)); toDo.add(new ToDoItem("Feed cat", 'B', 1)); while(!toDo.isEmpty()) System.out.println(toDo.remove()); } } /* Output: A1: Water lawn A2: Feed dog B1: Feed cat B7: Feed bird C3: Mow lawn C4: Empty trash */ OnJava8-Examples-1.0/collectiontopics/TypesForSets.java000066400000000000000000000052351374004044700232360ustar00rootroot00000000000000// collectiontopics/TypesForSets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Methods necessary to put your own type in a Set import java.util.*; import java.util.function.*; import java.util.Objects; class SetType { protected int i; SetType(int n) { i = n; } @Override public boolean equals(Object o) { return o instanceof SetType && Objects.equals(i, ((SetType)o).i); } @Override public String toString() { return Integer.toString(i); } } class HashType extends SetType { HashType(int n) { super(n); } @Override public int hashCode() { return Objects.hashCode(i); } } class TreeType extends SetType implements Comparable { TreeType(int n) { super(n); } @Override public int compareTo(TreeType arg) { return Integer.compare(arg.i, i); // Equivalent to: // return arg.i < i ? -1 : (arg.i == i ? 0 : 1); } } public class TypesForSets { static void fill(Set set, Function type) { for(int i = 10; i >= 5; i--) // Descending set.add(type.apply(i)); for(int i = 0; i < 5; i++) // Ascending set.add(type.apply(i)); } static void test(Set set, Function type) { fill(set, type); fill(set, type); // Try to add duplicates fill(set, type); System.out.println(set); } public static void main(String[] args) { test(new HashSet<>(), HashType::new); test(new LinkedHashSet<>(), HashType::new); test(new TreeSet<>(), TreeType::new); // Things that don't work: test(new HashSet<>(), SetType::new); test(new HashSet<>(), TreeType::new); test(new LinkedHashSet<>(), SetType::new); test(new LinkedHashSet<>(), TreeType::new); try { test(new TreeSet<>(), SetType::new); } catch(Exception e) { System.out.println(e.getMessage()); } try { test(new TreeSet<>(), HashType::new); } catch(Exception e) { System.out.println(e.getMessage()); } } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] [10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4] [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0] [1, 6, 8, 6, 2, 7, 8, 9, 4, 10, 7, 5, 1, 3, 4, 9, 9, 10, 5, 3, 2, 0, 4, 1, 2, 0, 8, 3, 0, 10, 6, 5, 7] [3, 1, 4, 8, 7, 6, 9, 5, 3, 0, 10, 5, 5, 10, 7, 8, 8, 9, 1, 4, 10, 2, 6, 9, 1, 6, 0, 3, 2, 0, 7, 2, 4] [10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4] [10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4] SetType cannot be cast to java.lang.Comparable HashType cannot be cast to java.lang.Comparable */ OnJava8-Examples-1.0/collectiontopics/Unsupported.java000066400000000000000000000042351374004044700231530ustar00rootroot00000000000000// collectiontopics/Unsupported.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Unsupported operations in Java collections import java.util.*; public class Unsupported { static void check(String description, Runnable tst) { try { tst.run(); } catch(Exception e) { System.out.println(description + "(): " + e); } } static void test(String msg, List list) { System.out.println("--- " + msg + " ---"); Collection c = list; Collection subList = list.subList(1,8); // Copy of the sublist: Collection c2 = new ArrayList<>(subList); check("retainAll", () -> c.retainAll(c2)); check("removeAll", () -> c.removeAll(c2)); check("clear", () -> c.clear()); check("add", () -> c.add("X")); check("addAll", () -> c.addAll(c2)); check("remove", () -> c.remove("C")); // The List.set() method modifies the value but // doesn't change the size of the data structure: check("List.set", () -> list.set(0, "X")); } public static void main(String[] args) { List list = Arrays.asList( "A B C D E F G H I J K L".split(" ")); test("Modifiable Copy", new ArrayList<>(list)); test("Arrays.asList()", list); test("unmodifiableList()", Collections.unmodifiableList( new ArrayList<>(list))); } } /* Output: --- Modifiable Copy --- --- Arrays.asList() --- retainAll(): java.lang.UnsupportedOperationException removeAll(): java.lang.UnsupportedOperationException clear(): java.lang.UnsupportedOperationException add(): java.lang.UnsupportedOperationException addAll(): java.lang.UnsupportedOperationException remove(): java.lang.UnsupportedOperationException --- unmodifiableList() --- retainAll(): java.lang.UnsupportedOperationException removeAll(): java.lang.UnsupportedOperationException clear(): java.lang.UnsupportedOperationException add(): java.lang.UnsupportedOperationException addAll(): java.lang.UnsupportedOperationException remove(): java.lang.UnsupportedOperationException List.set(): java.lang.UnsupportedOperationException */ OnJava8-Examples-1.0/collectiontopics/Utilities.java000066400000000000000000000062111374004044700225720ustar00rootroot00000000000000// collectiontopics/Utilities.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple demonstrations of the Collections utilities import java.util.*; public class Utilities { static List list = Arrays.asList( "one Two three Four five six one".split(" ")); public static void main(String[] args) { System.out.println(list); System.out.println("'list' disjoint (Four)?: " + Collections.disjoint(list, Collections.singletonList("Four"))); System.out.println( "max: " + Collections.max(list)); System.out.println( "min: " + Collections.min(list)); System.out.println( "max w/ comparator: " + Collections.max(list, String.CASE_INSENSITIVE_ORDER)); System.out.println( "min w/ comparator: " + Collections.min(list, String.CASE_INSENSITIVE_ORDER)); List sublist = Arrays.asList("Four five six".split(" ")); System.out.println("indexOfSubList: " + Collections.indexOfSubList(list, sublist)); System.out.println("lastIndexOfSubList: " + Collections.lastIndexOfSubList(list, sublist)); Collections.replaceAll(list, "one", "Yo"); System.out.println("replaceAll: " + list); Collections.reverse(list); System.out.println("reverse: " + list); Collections.rotate(list, 3); System.out.println("rotate: " + list); List source = Arrays.asList("in the matrix".split(" ")); Collections.copy(list, source); System.out.println("copy: " + list); Collections.swap(list, 0, list.size() - 1); System.out.println("swap: " + list); Collections.shuffle(list, new Random(47)); System.out.println("shuffled: " + list); Collections.fill(list, "pop"); System.out.println("fill: " + list); System.out.println("frequency of 'pop': " + Collections.frequency(list, "pop")); List dups = Collections.nCopies(3, "snap"); System.out.println("dups: " + dups); System.out.println("'list' disjoint 'dups'?: " + Collections.disjoint(list, dups)); // Getting an old-style Enumeration: Enumeration e = Collections.enumeration(dups); Vector v = new Vector<>(); while(e.hasMoreElements()) v.addElement(e.nextElement()); // Converting an old-style Vector // to a List via an Enumeration: ArrayList arrayList = Collections.list(v.elements()); System.out.println("arrayList: " + arrayList); } } /* Output: [one, Two, three, Four, five, six, one] 'list' disjoint (Four)?: false max: three min: Four max w/ comparator: Two min w/ comparator: five indexOfSubList: 3 lastIndexOfSubList: 3 replaceAll: [Yo, Two, three, Four, five, six, Yo] reverse: [Yo, six, five, Four, three, Two, Yo] rotate: [three, Two, Yo, Yo, six, five, Four] copy: [in, the, matrix, Yo, six, five, Four] swap: [Four, the, matrix, Yo, six, five, in] shuffled: [six, matrix, the, Four, Yo, five, in] fill: [pop, pop, pop, pop, pop, pop, pop] frequency of 'pop': 7 dups: [snap, snap, snap] 'list' disjoint 'dups'?: true arrayList: [snap, snap, snap] */ OnJava8-Examples-1.0/com/000077500000000000000000000000001374004044700151555ustar00rootroot00000000000000OnJava8-Examples-1.0/com/mindviewinc/000077500000000000000000000000001374004044700174715ustar00rootroot00000000000000OnJava8-Examples-1.0/com/mindviewinc/simple/000077500000000000000000000000001374004044700207625ustar00rootroot00000000000000OnJava8-Examples-1.0/com/mindviewinc/simple/List.java000066400000000000000000000005401374004044700225370ustar00rootroot00000000000000// com/mindviewinc/simple/List.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating a package package com.mindviewinc.simple; public class List { public List() { System.out.println("com.mindviewinc.simple.List"); } } OnJava8-Examples-1.0/com/mindviewinc/simple/Vector.java000066400000000000000000000005501374004044700230670ustar00rootroot00000000000000// com/mindviewinc/simple/Vector.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating a package package com.mindviewinc.simple; public class Vector { public Vector() { System.out.println("com.mindviewinc.simple.Vector"); } } OnJava8-Examples-1.0/compression/000077500000000000000000000000001374004044700167405ustar00rootroot00000000000000OnJava8-Examples-1.0/compression/GZIPcompress.java000066400000000000000000000024721374004044700221350ustar00rootroot00000000000000// compression/GZIPcompress.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java GZIPcompress GZIPcompress.java} // {VisuallyInspectOutput} import java.util.zip.*; import java.io.*; public class GZIPcompress { public static void main(String[] args) { if(args.length == 0) { System.out.println( "Usage: \nGZIPcompress file\n" + "\tUses GZIP compression to compress " + "the file to test.gz"); System.exit(1); } try( InputStream in = new BufferedInputStream( new FileInputStream(args[0])); BufferedOutputStream out = new BufferedOutputStream( new GZIPOutputStream( new FileOutputStream("test.gz"))) ) { System.out.println("Writing file"); int c; while((c = in.read()) != -1) out.write(c); } catch(IOException e) { throw new RuntimeException(e); } System.out.println("Reading file"); try( BufferedReader in2 = new BufferedReader( new InputStreamReader(new GZIPInputStream( new FileInputStream("test.gz")))) ) { in2.lines().forEach(System.out::println); } catch(IOException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/compression/ZipCompress.java000066400000000000000000000050561374004044700220670ustar00rootroot00000000000000// compression/ZipCompress.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Uses Zip compression to compress any // number of files given on the command line // {java ZipCompress ZipCompress.java} // {VisuallyInspectOutput} import java.util.zip.*; import java.io.*; import java.util.*; public class ZipCompress { public static void main(String[] args) { try( FileOutputStream f = new FileOutputStream("test.zip"); CheckedOutputStream csum = new CheckedOutputStream(f, new Adler32()); ZipOutputStream zos = new ZipOutputStream(csum); BufferedOutputStream out = new BufferedOutputStream(zos) ) { zos.setComment("A test of Java Zipping"); // No corresponding getComment(), though. for(String arg : args) { System.out.println("Writing file " + arg); try( InputStream in = new BufferedInputStream( new FileInputStream(arg)) ) { zos.putNextEntry(new ZipEntry(arg)); int c; while((c = in.read()) != -1) out.write(c); } out.flush(); } // Checksum valid only after the file is closed! System.out.println( "Checksum: " + csum.getChecksum().getValue()); } catch(IOException e) { throw new RuntimeException(e); } // Now extract the files: System.out.println("Reading file"); try( FileInputStream fi = new FileInputStream("test.zip"); CheckedInputStream csumi = new CheckedInputStream(fi, new Adler32()); ZipInputStream in2 = new ZipInputStream(csumi); BufferedInputStream bis = new BufferedInputStream(in2) ) { ZipEntry ze; while((ze = in2.getNextEntry()) != null) { System.out.println("Reading file " + ze); int x; while((x = bis.read()) != -1) System.out.write(x); } if(args.length == 1) System.out.println( "Checksum: "+csumi.getChecksum().getValue()); } catch(IOException e) { throw new RuntimeException(e); } // Alternative way to open and read Zip files: try( ZipFile zf = new ZipFile("test.zip") ) { Enumeration e = zf.entries(); while(e.hasMoreElements()) { ZipEntry ze2 = (ZipEntry)e.nextElement(); System.out.println("File: " + ze2); // ... and extract the data as before } } catch(IOException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/concurrent/000077500000000000000000000000001374004044700165615ustar00rootroot00000000000000OnJava8-Examples-1.0/concurrent/Baked.java000066400000000000000000000015061374004044700204340ustar00rootroot00000000000000// concurrent/Baked.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; import onjava.Nap; public class Baked { static class Pan {} static Pan pan(Batter b) { new Nap(0.1); return new Pan(); } static Baked heat(Pan p) { new Nap(0.1); return new Baked(); } static CompletableFuture bake(CompletableFuture cfb) { return cfb .thenApplyAsync(Baked::pan) .thenApplyAsync(Baked::heat); } public static Stream> batch() { CompletableFuture batter = Batter.mix(); return Stream.of(bake(batter), bake(batter), bake(batter), bake(batter)); } } OnJava8-Examples-1.0/concurrent/Batter.java000066400000000000000000000020331374004044700206430ustar00rootroot00000000000000// concurrent/Batter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import onjava.Nap; public class Batter { static class Eggs {} static class Milk {} static class Sugar {} static class Flour {} static T prepare(T ingredient) { new Nap(0.1); return ingredient; } static CompletableFuture prep(T ingredient) { return CompletableFuture .completedFuture(ingredient) .thenApplyAsync(Batter::prepare); } public static CompletableFuture mix() { CompletableFuture eggs = prep(new Eggs()); CompletableFuture milk = prep(new Milk()); CompletableFuture sugar = prep(new Sugar()); CompletableFuture flour = prep(new Flour()); CompletableFuture .allOf(eggs, milk, sugar, flour) .join(); new Nap(0.1); // Mixing time return CompletableFuture.completedFuture(new Batter()); } } OnJava8-Examples-1.0/concurrent/Breakable.java000066400000000000000000000014031374004044700212720ustar00rootroot00000000000000// concurrent/Breakable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class Breakable { String id; private int failcount; public Breakable(String id, int failcount) { this.id = id; this.failcount = failcount; } @Override public String toString() { return "Breakable_" + id + " [" + failcount + "]"; } public static Breakable work(Breakable b) { if(--b.failcount == 0) { System.out.println( "Throwing Exception for " + b.id + ""); throw new RuntimeException( "Breakable_" + b.id + " failed"); } System.out.println(b); return b; } } OnJava8-Examples-1.0/concurrent/CachedThreadPool.java000066400000000000000000000014361374004044700225610ustar00rootroot00000000000000// concurrent/CachedThreadPool.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; public class CachedThreadPool { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); IntStream.range(0, 10) .mapToObj(NapTask::new) .forEach(exec::execute); exec.shutdown(); } } /* Output: NapTask[7] pool-1-thread-8 NapTask[4] pool-1-thread-5 NapTask[1] pool-1-thread-2 NapTask[3] pool-1-thread-4 NapTask[0] pool-1-thread-1 NapTask[8] pool-1-thread-9 NapTask[2] pool-1-thread-3 NapTask[9] pool-1-thread-10 NapTask[6] pool-1-thread-7 NapTask[5] pool-1-thread-6 */ OnJava8-Examples-1.0/concurrent/CachedThreadPool2.java000066400000000000000000000013671374004044700226460ustar00rootroot00000000000000// concurrent/CachedThreadPool2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; public class CachedThreadPool2 { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); IntStream.range(0, 10) .mapToObj(InterferingTask::new) .forEach(exec::execute); exec.shutdown(); } } /* Output: 0 pool-1-thread-1 200 1 pool-1-thread-2 200 4 pool-1-thread-5 300 5 pool-1-thread-6 400 8 pool-1-thread-9 500 9 pool-1-thread-10 600 2 pool-1-thread-3 700 7 pool-1-thread-8 800 3 pool-1-thread-4 900 6 pool-1-thread-7 1000 */ OnJava8-Examples-1.0/concurrent/CachedThreadPool3.java000066400000000000000000000023351374004044700226430ustar00rootroot00000000000000// concurrent/CachedThreadPool3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.concurrent.*; import java.util.stream.*; public class CachedThreadPool3 { public static Integer extractResult(Future f) { try { return f.get(); } catch(Exception e) { throw new RuntimeException(e); } } public static void main(String[] args) throws InterruptedException { ExecutorService exec = Executors.newCachedThreadPool(); List tasks = IntStream.range(0, 10) .mapToObj(CountingTask::new) .collect(Collectors.toList()); List> futures = exec.invokeAll(tasks); Integer sum = futures.stream() .map(CachedThreadPool3::extractResult) .reduce(0, Integer::sum); System.out.println("sum = " + sum); exec.shutdown(); } } /* Output: 1 pool-1-thread-2 100 0 pool-1-thread-1 100 4 pool-1-thread-5 100 5 pool-1-thread-6 100 8 pool-1-thread-9 100 9 pool-1-thread-10 100 2 pool-1-thread-3 100 3 pool-1-thread-4 100 6 pool-1-thread-7 100 7 pool-1-thread-8 100 sum = 1000 */ OnJava8-Examples-1.0/concurrent/CatchCompletableExceptions.java000066400000000000000000000046671374004044700246750ustar00rootroot00000000000000// concurrent/CatchCompletableExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class CatchCompletableExceptions { static void handleException(int failcount) { // Call the Function only if there's an // exception, must produce same type as came in: CompletableExceptions .test("exceptionally", failcount) .exceptionally((ex) -> { // Function if(ex == null) System.out.println("I don't get it yet"); return new Breakable(ex.getMessage(), 0); }) .thenAccept(str -> System.out.println("result: " + str)); // Create a new result (recover): CompletableExceptions .test("handle", failcount) .handle((result, fail) -> { // BiFunction if(fail != null) return "Failure recovery object"; else return result + " is good"; }) .thenAccept(str -> System.out.println("result: " + str)); // Do something but pass the same result through: CompletableExceptions .test("whenComplete", failcount) .whenComplete((result, fail) -> { // BiConsumer if(fail != null) System.out.println("It failed"); else System.out.println(result + " OK"); }) .thenAccept(r -> System.out.println("result: " + r)); } public static void main(String[] args) { System.out.println("**** Failure Mode ****"); handleException(2); System.out.println("**** Success Mode ****"); handleException(0); } } /* Output: **** Failure Mode **** Breakable_exceptionally [1] Throwing Exception for exceptionally result: Breakable_java.lang.RuntimeException: Breakable_exceptionally failed [0] Breakable_handle [1] Throwing Exception for handle result: Failure recovery object Breakable_whenComplete [1] Throwing Exception for whenComplete It failed **** Success Mode **** Breakable_exceptionally [-1] Breakable_exceptionally [-2] Breakable_exceptionally [-3] Breakable_exceptionally [-4] result: Breakable_exceptionally [-4] Breakable_handle [-1] Breakable_handle [-2] Breakable_handle [-3] Breakable_handle [-4] result: Breakable_handle [-4] is good Breakable_whenComplete [-1] Breakable_whenComplete [-2] Breakable_whenComplete [-3] Breakable_whenComplete [-4] Breakable_whenComplete [-4] OK result: Breakable_whenComplete [-4] */ OnJava8-Examples-1.0/concurrent/CollectionIntoStream.java000066400000000000000000000015231374004044700235260ustar00rootroot00000000000000// concurrent/CollectionIntoStream.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; import java.util.*; import java.util.stream.*; public class CollectionIntoStream { public static void main(String[] args) { List strings = Stream.generate(new Rand.String(5)) .limit(10) .collect(Collectors.toList()); strings.forEach(System.out::println); // Convert to a Stream for many more options: String result = strings.stream() .map(String::toUpperCase) .map(s -> s.substring(2)) .reduce(":", (s1, s2) -> s1 + s2); System.out.println(result); } } /* Output: btpen pccux szgvg meinn eeloz tdvew cippc ygpoa lkljl bynxt :PENCUXGVGINNLOZVEWPPCPOALJLNXT */ OnJava8-Examples-1.0/concurrent/CompletableApply.java000066400000000000000000000014151374004044700226620ustar00rootroot00000000000000// concurrent/CompletableApply.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class CompletableApply { public static void main(String[] args) { CompletableFuture cf = CompletableFuture.completedFuture( new Machina(0)); CompletableFuture cf2 = cf.thenApply(Machina::work); CompletableFuture cf3 = cf2.thenApply(Machina::work); CompletableFuture cf4 = cf3.thenApply(Machina::work); CompletableFuture cf5 = cf4.thenApply(Machina::work); } } /* Output: Machina0: ONE Machina0: TWO Machina0: THREE Machina0: complete */ OnJava8-Examples-1.0/concurrent/CompletableApplyAsync.java000066400000000000000000000015121374004044700236560ustar00rootroot00000000000000// concurrent/CompletableApplyAsync.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import onjava.*; public class CompletableApplyAsync { public static void main(String[] args) { Timer timer = new Timer(); CompletableFuture cf = CompletableFuture.completedFuture( new Machina(0)) .thenApplyAsync(Machina::work) .thenApplyAsync(Machina::work) .thenApplyAsync(Machina::work) .thenApplyAsync(Machina::work); System.out.println(timer.duration()); System.out.println(cf.join()); System.out.println(timer.duration()); } } /* Output: 116 Machina0: ONE Machina0: TWO Machina0: THREE Machina0: complete Machina0: complete 552 */ OnJava8-Examples-1.0/concurrent/CompletableApplyChained.java000066400000000000000000000013321374004044700241340ustar00rootroot00000000000000// concurrent/CompletableApplyChained.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import onjava.Timer; public class CompletableApplyChained { public static void main(String[] args) { Timer timer = new Timer(); CompletableFuture cf = CompletableFuture.completedFuture( new Machina(0)) .thenApply(Machina::work) .thenApply(Machina::work) .thenApply(Machina::work) .thenApply(Machina::work); System.out.println(timer.duration()); } } /* Output: Machina0: ONE Machina0: TWO Machina0: THREE Machina0: complete 514 */ OnJava8-Examples-1.0/concurrent/CompletableExceptions.java000066400000000000000000000036061374004044700237220ustar00rootroot00000000000000// concurrent/CompletableExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class CompletableExceptions { static CompletableFuture test(String id, int failcount) { return CompletableFuture.completedFuture( new Breakable(id, failcount)) .thenApply(Breakable::work) .thenApply(Breakable::work) .thenApply(Breakable::work) .thenApply(Breakable::work); } public static void main(String[] args) { // Exceptions don't appear ... test("A", 1); test("B", 2); test("C", 3); test("D", 4); test("E", 5); // ... until you try to fetch the value: try { test("F", 2).get(); // or join() } catch(Exception e) { System.out.println(e.getMessage()); } // Test for exceptions: System.out.println( test("G", 2).isCompletedExceptionally()); // Counts as "done": System.out.println(test("H", 2).isDone()); // Force an exception: CompletableFuture cfi = new CompletableFuture<>(); System.out.println("done? " + cfi.isDone()); cfi.completeExceptionally( new RuntimeException("forced")); try { cfi.get(); } catch(Exception e) { System.out.println(e.getMessage()); } } } /* Output: Throwing Exception for A Breakable_B [1] Throwing Exception for B Breakable_C [2] Breakable_C [1] Throwing Exception for C Breakable_D [3] Breakable_D [2] Breakable_D [1] Throwing Exception for D Breakable_E [4] Breakable_E [3] Breakable_E [2] Breakable_E [1] Breakable_F [1] Throwing Exception for F java.lang.RuntimeException: Breakable_F failed Breakable_G [1] Throwing Exception for G true Breakable_H [1] Throwing Exception for H true done? false java.lang.RuntimeException: forced */ OnJava8-Examples-1.0/concurrent/CompletableOperations.java000066400000000000000000000041011374004044700237130ustar00rootroot00000000000000// concurrent/CompletableOperations.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import static onjava.CompletableUtilities.*; public class CompletableOperations { static CompletableFuture cfi(int i) { return CompletableFuture.completedFuture( Integer.valueOf(i)); } public static void main(String[] args) { showr(cfi(1)); // Basic test voidr(cfi(2).runAsync(() -> System.out.println("runAsync"))); voidr(cfi(3).thenRunAsync(() -> System.out.println("thenRunAsync"))); voidr(CompletableFuture.runAsync(() -> System.out.println("runAsync is static"))); showr(CompletableFuture.supplyAsync(() -> 99)); voidr(cfi(4).thenAcceptAsync(i -> System.out.println("thenAcceptAsync: " + i))); showr(cfi(5).thenApplyAsync(i -> i + 42)); showr(cfi(6).thenComposeAsync(i -> cfi(i + 99))); CompletableFuture c = cfi(7); c.obtrudeValue(111); showr(c); showr(cfi(8).toCompletableFuture()); c = new CompletableFuture<>(); c.complete(9); showr(c); c = new CompletableFuture<>(); c.cancel(true); System.out.println("cancelled: " + c.isCancelled()); System.out.println("completed exceptionally: " + c.isCompletedExceptionally()); System.out.println("done: " + c.isDone()); System.out.println(c); c = new CompletableFuture<>(); System.out.println(c.getNow(777)); c = new CompletableFuture<>(); c.thenApplyAsync(i -> i + 42) .thenApplyAsync(i -> i * 12); System.out.println("dependents: " + c.getNumberOfDependents()); c.thenApplyAsync(i -> i / 2); System.out.println("dependents: " + c.getNumberOfDependents()); } } /* Output: 1 runAsync thenRunAsync runAsync is static 99 thenAcceptAsync: 4 47 105 111 8 9 cancelled: true completed exceptionally: true done: true java.util.concurrent.CompletableFuture@6d311334[Complet ed exceptionally] 777 dependents: 1 dependents: 2 */ OnJava8-Examples-1.0/concurrent/CompletablePizza.java000066400000000000000000000036671374004044700227050ustar00rootroot00000000000000// concurrent/CompletablePizza.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.concurrent.*; import java.util.stream.*; import onjava.Timer; public class CompletablePizza { static final int QUANTITY = 5; public static CompletableFuture makeCF(Pizza za) { return CompletableFuture .completedFuture(za) .thenApplyAsync(Pizza::roll) .thenApplyAsync(Pizza::sauce) .thenApplyAsync(Pizza::cheese) .thenApplyAsync(Pizza::toppings) .thenApplyAsync(Pizza::bake) .thenApplyAsync(Pizza::slice) .thenApplyAsync(Pizza::box); } public static void show(CompletableFuture cf) { try { System.out.println(cf.get()); } catch(Exception e) { throw new RuntimeException(e); } } public static void main(String[] args) { Timer timer = new Timer(); List> pizzas = IntStream.range(0, QUANTITY) .mapToObj(Pizza::new) .map(CompletablePizza::makeCF) .collect(Collectors.toList()); System.out.println(timer.duration()); pizzas.forEach(CompletablePizza::show); System.out.println(timer.duration()); } } /* Output: 169 Pizza 0: ROLLED Pizza 1: ROLLED Pizza 2: ROLLED Pizza 4: ROLLED Pizza 3: ROLLED Pizza 1: SAUCED Pizza 0: SAUCED Pizza 2: SAUCED Pizza 4: SAUCED Pizza 3: SAUCED Pizza 0: CHEESED Pizza 4: CHEESED Pizza 1: CHEESED Pizza 2: CHEESED Pizza 3: CHEESED Pizza 0: TOPPED Pizza 4: TOPPED Pizza 1: TOPPED Pizza 2: TOPPED Pizza 3: TOPPED Pizza 0: BAKED Pizza 4: BAKED Pizza 1: BAKED Pizza 3: BAKED Pizza 2: BAKED Pizza 0: SLICED Pizza 4: SLICED Pizza 1: SLICED Pizza 3: SLICED Pizza 2: SLICED Pizza 4: BOXED Pizza 0: BOXED Pizza0: complete Pizza 1: BOXED Pizza1: complete Pizza 3: BOXED Pizza 2: BOXED Pizza2: complete Pizza3: complete Pizza4: complete 1797 */ OnJava8-Examples-1.0/concurrent/CompletableUtilities.java000066400000000000000000000014421374004044700235500ustar00rootroot00000000000000// concurrent/CompletableUtilities.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.concurrent.*; public class CompletableUtilities { // Get and show value stored in a CF: public static void showr(CompletableFuture c) { try { System.out.println(c.get()); } catch(InterruptedException | ExecutionException e) { throw new RuntimeException(e); } } // For CF operations that have no value: public static void voidr(CompletableFuture c) { try { c.get(); // Returns void } catch(InterruptedException | ExecutionException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/concurrent/CompletedMachina.java000066400000000000000000000011071374004044700226200ustar00rootroot00000000000000// concurrent/CompletedMachina.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class CompletedMachina { public static void main(String[] args) { CompletableFuture cf = CompletableFuture.completedFuture( new Machina(0)); try { Machina m = cf.get(); // Doesn't block } catch(InterruptedException | ExecutionException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/concurrent/CountingStream.java000066400000000000000000000016511374004044700223710ustar00rootroot00000000000000// concurrent/CountingStream.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.util.*; import java.util.concurrent.*; import java.util.stream.*; public class CountingStream { public static void main(String[] args) { System.out.println( IntStream.range(0, 10) .parallel() .mapToObj(CountingTask::new) .map(ct -> ct.call()) .reduce(0, Integer::sum)); } } /* Output: 1 ForkJoinPool.commonPool-worker-3 100 8 ForkJoinPool.commonPool-worker-2 100 0 ForkJoinPool.commonPool-worker-6 100 2 ForkJoinPool.commonPool-worker-1 100 4 ForkJoinPool.commonPool-worker-5 100 9 ForkJoinPool.commonPool-worker-7 100 6 main 100 7 ForkJoinPool.commonPool-worker-4 100 5 ForkJoinPool.commonPool-worker-2 100 3 ForkJoinPool.commonPool-worker-3 100 1000 */ OnJava8-Examples-1.0/concurrent/CountingTask.java000066400000000000000000000010611374004044700220330ustar00rootroot00000000000000// concurrent/CountingTask.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class CountingTask implements Callable { final int id; public CountingTask(int id) { this.id = id; } @Override public Integer call() { Integer val = 0; for(int i = 0; i < 100; i++) val++; System.out.println(id + " " + Thread.currentThread().getName() + " " + val); return val; } } OnJava8-Examples-1.0/concurrent/DiningPhilosophers.java000066400000000000000000000021651374004044700232400ustar00rootroot00000000000000// concurrent/DiningPhilosophers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Hidden deadlock // {ExcludeFromGradle} Gradle has trouble import java.util.*; import java.util.concurrent.*; import onjava.Nap; public class DiningPhilosophers { private StickHolder[] sticks; private Philosopher[] philosophers; public DiningPhilosophers(int n) { sticks = new StickHolder[n]; Arrays.setAll(sticks, i -> new StickHolder()); philosophers = new Philosopher[n]; Arrays.setAll(philosophers, i -> new Philosopher(i, sticks[i], sticks[(i + 1) % n])); // [1] // Fix by reversing stick order for this one: // philosophers[1] = // [2] // new Philosopher(0, sticks[0], sticks[1]); Arrays.stream(philosophers) .forEach(CompletableFuture::runAsync); // [3] } public static void main(String[] args) { // Returns right away: new DiningPhilosophers(5); // [4] // Keeps main() from exiting: new Nap(3, "Shutdown"); } } OnJava8-Examples-1.0/concurrent/DualCompletableOperations.java000066400000000000000000000047531374004044700245360ustar00rootroot00000000000000// concurrent/DualCompletableOperations.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import static onjava.CompletableUtilities.*; public class DualCompletableOperations { static CompletableFuture cfA, cfB; static void init() { cfA = Workable.make("A", 0.15); cfB = Workable.make("B", 0.10); // Always wins } static void join() { cfA.join(); cfB.join(); System.out.println("*****************"); } public static void main(String[] args) { init(); voidr(cfA.runAfterEitherAsync(cfB, () -> System.out.println("runAfterEither"))); join(); init(); voidr(cfA.runAfterBothAsync(cfB, () -> System.out.println("runAfterBoth"))); join(); init(); showr(cfA.applyToEitherAsync(cfB, w -> { System.out.println("applyToEither: " + w); return w; })); join(); init(); voidr(cfA.acceptEitherAsync(cfB, w -> { System.out.println("acceptEither: " + w); })); join(); init(); voidr(cfA.thenAcceptBothAsync(cfB, (w1, w2) -> { System.out.println("thenAcceptBoth: " + w1 + ", " + w2); })); join(); init(); showr(cfA.thenCombineAsync(cfB, (w1, w2) -> { System.out.println("thenCombine: " + w1 + ", " + w2); return w1; })); join(); init(); CompletableFuture cfC = Workable.make("C", 0.08), cfD = Workable.make("D", 0.09); CompletableFuture.anyOf(cfA, cfB, cfC, cfD) .thenRunAsync(() -> System.out.println("anyOf")); join(); init(); cfC = Workable.make("C", 0.08); cfD = Workable.make("D", 0.09); CompletableFuture.allOf(cfA, cfB, cfC, cfD) .thenRunAsync(() -> System.out.println("allOf")); join(); } } /* Output: Workable[BW] runAfterEither Workable[AW] ***************** Workable[BW] Workable[AW] runAfterBoth ***************** Workable[BW] applyToEither: Workable[BW] Workable[BW] Workable[AW] ***************** Workable[BW] acceptEither: Workable[BW] Workable[AW] ***************** Workable[BW] Workable[AW] thenAcceptBoth: Workable[AW], Workable[BW] ***************** Workable[BW] Workable[AW] thenCombine: Workable[AW], Workable[BW] Workable[AW] ***************** Workable[CW] anyOf Workable[DW] Workable[BW] Workable[AW] ***************** Workable[CW] Workable[DW] Workable[BW] Workable[AW] ***************** allOf */ OnJava8-Examples-1.0/concurrent/FrostedCake.java000066400000000000000000000015711374004044700216220ustar00rootroot00000000000000// concurrent/FrostedCake.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; import onjava.Nap; final class Frosting { private Frosting() {} static CompletableFuture make() { new Nap(0.1); return CompletableFuture .completedFuture(new Frosting()); } } public class FrostedCake { public FrostedCake(Baked baked, Frosting frosting) { new Nap(0.1); } @Override public String toString() { return "FrostedCake"; } public static void main(String[] args) { Baked.batch().forEach(baked -> baked .thenCombineAsync(Frosting.make(), (cake, frosting) -> new FrostedCake(cake, frosting)) .thenAcceptAsync(System.out::println) .join()); } } OnJava8-Examples-1.0/concurrent/Futures.java000066400000000000000000000011651374004044700210640ustar00rootroot00000000000000// concurrent/Futures.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.concurrent.*; import java.util.stream.*; public class Futures { public static void main(String[] args) throws InterruptedException, ExecutionException { ExecutorService exec = Executors.newSingleThreadExecutor(); Future f = exec.submit(new CountingTask(99)); System.out.println(f.get()); // [1] exec.shutdown(); } } /* Output: 99 pool-1-thread-1 100 100 */ OnJava8-Examples-1.0/concurrent/GuardedIDField.java000066400000000000000000000010301374004044700221520ustar00rootroot00000000000000// concurrent/GuardedIDField.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.*; public class GuardedIDField implements HasID { private static AtomicInteger counter = new AtomicInteger(); private int id = counter.getAndIncrement(); public int getID() { return id; } public static void main(String[] args) { IDChecker.test(GuardedIDField::new); } } /* Output: 0 */ OnJava8-Examples-1.0/concurrent/HasID.java000066400000000000000000000003461374004044700203570ustar00rootroot00000000000000// concurrent/HasID.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public interface HasID { int getID(); } OnJava8-Examples-1.0/concurrent/IDChecker.java000066400000000000000000000022501374004044700212040ustar00rootroot00000000000000// concurrent/IDChecker.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; import java.util.concurrent.*; import com.google.common.collect.Sets; public class IDChecker { public static final int SIZE = 100_000; static class MakeObjects implements Supplier> { private Supplier gen; MakeObjects(Supplier gen) { this.gen = gen; } @Override public List get() { return Stream.generate(gen) .limit(SIZE) .map(HasID::getID) .collect(Collectors.toList()); } } public static void test(Supplier gen) { CompletableFuture> groupA = CompletableFuture .supplyAsync(new MakeObjects(gen)), groupB = CompletableFuture .supplyAsync(new MakeObjects(gen)); groupA.thenAcceptBoth(groupB, (a, b) -> { System.out.println( Sets.intersection( Sets.newHashSet(a), Sets.newHashSet(b)).size()); }).join(); } } OnJava8-Examples-1.0/concurrent/InterferingTask.java000066400000000000000000000010131374004044700225160ustar00rootroot00000000000000// concurrent/InterferingTask.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class InterferingTask implements Runnable { final int id; private static Integer val = 0; public InterferingTask(int id) { this.id = id; } @Override public void run() { for(int i = 0; i < 100; i++) val++; System.out.println(id + " " + Thread.currentThread().getName() + " " + val); } } OnJava8-Examples-1.0/concurrent/LambdasAndMethodReferences.java000066400000000000000000000016241374004044700245600ustar00rootroot00000000000000// concurrent/LambdasAndMethodReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; class NotRunnable { public void go() { System.out.println("NotRunnable"); } } class NotCallable { public Integer get() { System.out.println("NotCallable"); return 1; } } public class LambdasAndMethodReferences { public static void main(String[] args) throws InterruptedException { ExecutorService exec = Executors.newCachedThreadPool(); exec.submit(() -> System.out.println("Lambda1")); exec.submit(new NotRunnable()::go); exec.submit(() -> { System.out.println("Lambda2"); return 1; }); exec.submit(new NotCallable()::get); exec.shutdown(); } } /* Output: Lambda1 NotCallable NotRunnable Lambda2 */ OnJava8-Examples-1.0/concurrent/Machina.java000066400000000000000000000014501374004044700207640ustar00rootroot00000000000000// concurrent/Machina.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.Nap; public class Machina { public enum State { START, ONE, TWO, THREE, END; State step() { if(equals(END)) return END; return values()[ordinal() + 1]; } } private State state = State.START; private final int id; public Machina(int id) { this.id = id; } public static Machina work(Machina m) { if(!m.state.equals(State.END)){ new Nap(0.1); m.state = m.state.step(); } System.out.println(m); return m; } @Override public String toString() { return "Machina" + id + ": " + (state.equals(State.END)? "complete" : state); } } OnJava8-Examples-1.0/concurrent/MoreTasksAfterShutdown.java000066400000000000000000000015021374004044700240500ustar00rootroot00000000000000// concurrent/MoreTasksAfterShutdown.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class MoreTasksAfterShutdown { public static void main(String[] args) { ExecutorService exec = Executors.newSingleThreadExecutor(); exec.execute(new NapTask(1)); exec.shutdown(); try { exec.execute(new NapTask(99)); } catch(RejectedExecutionException e) { System.out.println(e); } } } /* Output: java.util.concurrent.RejectedExecutionException: Task NapTask[99] rejected from java.util.concurrent.ThreadPo olExecutor@4e25154f[Shutting down, pool size = 1, active threads = 1, queued tasks = 0, completed tasks = 0] NapTask[1] pool-1-thread-1 */ OnJava8-Examples-1.0/concurrent/NapTask.java000066400000000000000000000010301374004044700207570ustar00rootroot00000000000000// concurrent/NapTask.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.Nap; public class NapTask implements Runnable { final int id; public NapTask(int id) { this.id = id; } @Override public void run() { new Nap(0.1); // Seconds System.out.println(this + " " + Thread.currentThread().getName()); } @Override public String toString() { return "NapTask[" + id + "]"; } } OnJava8-Examples-1.0/concurrent/OnePizza.java000066400000000000000000000010571374004044700211660ustar00rootroot00000000000000// concurrent/OnePizza.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.Timer; public class OnePizza { public static void main(String[] args) { Pizza za = new Pizza(0); System.out.println( Timer.duration(() -> { while(!za.complete()) za.next(); })); } } /* Output: Pizza 0: ROLLED Pizza 0: SAUCED Pizza 0: CHEESED Pizza 0: TOPPED Pizza 0: BAKED Pizza 0: SLICED Pizza 0: BOXED 1622 */ OnJava8-Examples-1.0/concurrent/ParallelPrime.java000066400000000000000000000017741374004044700221660ustar00rootroot00000000000000// concurrent/ParallelPrime.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import static java.util.stream.LongStream.*; import java.io.*; import java.nio.file.*; import onjava.Timer; public class ParallelPrime { static final int COUNT = 100_000; public static boolean isPrime(long n) { return rangeClosed(2, (long)Math.sqrt(n)) .noneMatch(i -> n % i == 0); } public static void main(String[] args) throws IOException { Timer timer = new Timer(); List primes = iterate(2, i -> i + 1) .parallel() // [1] .filter(ParallelPrime::isPrime) .limit(COUNT) .mapToObj(Long::toString) .collect(Collectors.toList()); System.out.println(timer.duration()); Files.write(Paths.get("primes.txt"), primes, StandardOpenOption.CREATE); } } /* Output: 1224 */ OnJava8-Examples-1.0/concurrent/ParallelStreamPuzzle.java000066400000000000000000000013411374004044700235450ustar00rootroot00000000000000// concurrent/ParallelStreamPuzzle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; public class ParallelStreamPuzzle { static class IntGenerator implements Supplier { private int current = 0; public Integer get() { return current++; } } public static void main(String[] args) { List x = Stream.generate(new IntGenerator()) .limit(10) .parallel() // [1] .collect(Collectors.toList()); System.out.println(x); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] */ OnJava8-Examples-1.0/concurrent/ParallelStreamPuzzle2.java000066400000000000000000000021151374004044700236270ustar00rootroot00000000000000// concurrent/ParallelStreamPuzzle2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; import java.util.concurrent.*; import java.util.concurrent.atomic.*; import java.nio.file.*; public class ParallelStreamPuzzle2 { public static final Deque trace = new ConcurrentLinkedDeque<>(); static class IntGenerator implements Supplier { private AtomicInteger current = new AtomicInteger(); public Integer get() { trace.add(current.get() + ": " + Thread.currentThread().getName()); return current.getAndIncrement(); } } public static void main(String[] args) throws Exception { List x = Stream.generate(new IntGenerator()) .limit(10) .parallel() .collect(Collectors.toList()); System.out.println(x); Files.write(Paths.get("PSP2.txt"), trace); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] */ OnJava8-Examples-1.0/concurrent/ParallelStreamPuzzle3.java000066400000000000000000000017361374004044700236400ustar00rootroot00000000000000// concurrent/ParallelStreamPuzzle3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.util.*; import java.util.stream.*; public class ParallelStreamPuzzle3 { public static void main(String[] args) { List x = IntStream.range(0, 30) .peek(e -> System.out.println(e + ": " + Thread.currentThread().getName())) .limit(10) .parallel() .boxed() .collect(Collectors.toList()); System.out.println(x); } } /* Output: 8: main 6: ForkJoinPool.commonPool-worker-5 3: ForkJoinPool.commonPool-worker-7 5: ForkJoinPool.commonPool-worker-5 1: ForkJoinPool.commonPool-worker-3 2: ForkJoinPool.commonPool-worker-6 4: ForkJoinPool.commonPool-worker-1 0: ForkJoinPool.commonPool-worker-4 7: ForkJoinPool.commonPool-worker-1 9: ForkJoinPool.commonPool-worker-2 [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] */ OnJava8-Examples-1.0/concurrent/Philosopher.java000066400000000000000000000014001374004044700217130ustar00rootroot00000000000000// concurrent/Philosopher.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Philosopher implements Runnable { private final int seat; private final StickHolder left, right; public Philosopher(int seat, StickHolder left, StickHolder right) { this.seat = seat; this.left = left; this.right = right; } @Override public String toString() { return "P" + seat; } @Override public void run() { while(true) { // System.out.println("Thinking"); // [1] right.pickUp(); left.pickUp(); System.out.println(this + " eating"); right.putDown(); left.putDown(); } } } OnJava8-Examples-1.0/concurrent/Pizza.java000066400000000000000000000030761374004044700205270ustar00rootroot00000000000000// concurrent/Pizza.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; import onjava.Nap; public class Pizza { public enum Step { DOUGH(4), ROLLED(1), SAUCED(1), CHEESED(2), TOPPED(5), BAKED(2), SLICED(1), BOXED(0); int effort; // Needed to get to the next step Step(int effort) { this.effort = effort; } Step forward() { if(equals(BOXED)) return BOXED; new Nap(effort * 0.1); return values()[ordinal() + 1]; } } private Step step = Step.DOUGH; private final int id; public Pizza(int id) { this.id = id; } public Pizza next() { step = step.forward(); System.out.println("Pizza " + id + ": " + step); return this; } public Pizza next(Step previousStep) { if(!step.equals(previousStep)) throw new IllegalStateException("Expected " + previousStep + " but found " + step); return next(); } public Pizza roll() { return next(Step.DOUGH); } public Pizza sauce() { return next(Step.ROLLED); } public Pizza cheese() { return next(Step.SAUCED); } public Pizza toppings() { return next(Step.CHEESED); } public Pizza bake() { return next(Step.TOPPED); } public Pizza slice() { return next(Step.BAKED); } public Pizza box() { return next(Step.SLICED); } public boolean complete() { return step.equals(Step.BOXED); } @Override public String toString() { return "Pizza" + id + ": " + (step.equals(Step.BOXED)? "complete" : step); } } OnJava8-Examples-1.0/concurrent/PizzaParallelSteps.java000066400000000000000000000026111374004044700232150ustar00rootroot00000000000000// concurrent/PizzaParallelSteps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import onjava.Timer; public class PizzaParallelSteps { static final int QUANTITY = 5; public static void main(String[] args) { Timer timer = new Timer(); IntStream.range(0, QUANTITY) .mapToObj(Pizza::new) .parallel() .map(Pizza::roll) .map(Pizza::sauce) .map(Pizza::cheese) .map(Pizza::toppings) .map(Pizza::bake) .map(Pizza::slice) .map(Pizza::box) .forEach(za -> System.out.println(za)); System.out.println(timer.duration()); } } /* Output: Pizza 2: ROLLED Pizza 0: ROLLED Pizza 1: ROLLED Pizza 4: ROLLED Pizza 3: ROLLED Pizza 1: SAUCED Pizza 0: SAUCED Pizza 2: SAUCED Pizza 3: SAUCED Pizza 4: SAUCED Pizza 1: CHEESED Pizza 0: CHEESED Pizza 2: CHEESED Pizza 3: CHEESED Pizza 4: CHEESED Pizza 0: TOPPED Pizza 2: TOPPED Pizza 1: TOPPED Pizza 3: TOPPED Pizza 4: TOPPED Pizza 1: BAKED Pizza 2: BAKED Pizza 0: BAKED Pizza 4: BAKED Pizza 3: BAKED Pizza 0: SLICED Pizza 2: SLICED Pizza 1: SLICED Pizza 3: SLICED Pizza 4: SLICED Pizza 1: BOXED Pizza1: complete Pizza 2: BOXED Pizza 0: BOXED Pizza2: complete Pizza0: complete Pizza 3: BOXED Pizza 4: BOXED Pizza4: complete Pizza3: complete 1738 */ OnJava8-Examples-1.0/concurrent/PizzaStreams.java000066400000000000000000000022621374004044700220620ustar00rootroot00000000000000// concurrent/PizzaStreams.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import onjava.Timer; public class PizzaStreams { static final int QUANTITY = 5; public static void main(String[] args) { Timer timer = new Timer(); IntStream.range(0, QUANTITY) .mapToObj(Pizza::new) .parallel() // [1] .forEach(za -> { while(!za.complete()) za.next(); }); System.out.println(timer.duration()); } } /* Output: Pizza 2: ROLLED Pizza 0: ROLLED Pizza 1: ROLLED Pizza 4: ROLLED Pizza 3: ROLLED Pizza 2: SAUCED Pizza 1: SAUCED Pizza 0: SAUCED Pizza 4: SAUCED Pizza 3: SAUCED Pizza 2: CHEESED Pizza 1: CHEESED Pizza 0: CHEESED Pizza 4: CHEESED Pizza 3: CHEESED Pizza 2: TOPPED Pizza 1: TOPPED Pizza 0: TOPPED Pizza 4: TOPPED Pizza 3: TOPPED Pizza 2: BAKED Pizza 1: BAKED Pizza 0: BAKED Pizza 4: BAKED Pizza 3: BAKED Pizza 2: SLICED Pizza 1: SLICED Pizza 0: SLICED Pizza 4: SLICED Pizza 3: SLICED Pizza 2: BOXED Pizza 1: BOXED Pizza 0: BOXED Pizza 4: BOXED Pizza 3: BOXED 1739 */ OnJava8-Examples-1.0/concurrent/QuittableTask.java000066400000000000000000000011631374004044700222020ustar00rootroot00000000000000// concurrent/QuittableTask.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.AtomicBoolean; import onjava.Nap; public class QuittableTask implements Runnable { final int id; public QuittableTask(int id) { this.id = id; } private AtomicBoolean running = new AtomicBoolean(true); public void quit() { running.set(false); } @Override public void run() { while(running.get()) // [1] new Nap(0.1); System.out.print(id + " "); // [2] } } OnJava8-Examples-1.0/concurrent/QuittingCompletable.java000066400000000000000000000024121374004044700233770ustar00rootroot00000000000000// concurrent/QuittingCompletable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import onjava.Nap; public class QuittingCompletable { public static void main(String[] args) { List tasks = IntStream.range(1, QuittingTasks.COUNT) .mapToObj(QuittableTask::new) .collect(Collectors.toList()); List> cfutures = tasks.stream() .map(CompletableFuture::runAsync) .collect(Collectors.toList()); new Nap(1); tasks.forEach(QuittableTask::quit); cfutures.forEach(CompletableFuture::join); } } /* Output: 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 6 35 4 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 1 113 114 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 5 115 37 36 2 3 */ OnJava8-Examples-1.0/concurrent/QuittingTasks.java000066400000000000000000000023141374004044700222360ustar00rootroot00000000000000// concurrent/QuittingTasks.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import onjava.Nap; public class QuittingTasks { public static final int COUNT = 150; public static void main(String[] args) { ExecutorService es = Executors.newCachedThreadPool(); List tasks = IntStream.range(1, COUNT) .mapToObj(QuittableTask::new) .peek(qt -> es.execute(qt)) .collect(Collectors.toList()); new Nap(1); tasks.forEach(QuittableTask::quit); es.shutdown(); } } /* Output: 24 27 31 8 11 7 19 12 16 4 23 3 28 32 15 20 63 60 68 67 64 39 47 52 51 55 40 43 48 59 44 56 36 35 71 72 83 103 96 92 88 99 100 87 91 79 75 84 76 115 108 112 104 107 111 95 80 147 120 127 119 123 144 143 116 132 124 128 136 131 135 139 148 140 2 126 6 5 1 18 129 17 14 13 21 22 9 10 30 33 58 37 125 26 34 133 145 78 137 141 138 62 74 142 86 65 73 146 70 42 149 121 110 134 105 82 117 106 113 122 45 114 118 38 50 29 90 101 89 57 53 94 41 61 66 130 69 77 81 85 93 25 102 54 109 98 49 46 97 */ OnJava8-Examples-1.0/concurrent/SharedConstructorArgument.java000066400000000000000000000017241374004044700246070ustar00rootroot00000000000000// concurrent/SharedConstructorArgument.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.*; interface SharedArg { int get(); } class Unsafe implements SharedArg { private int i = 0; public int get() { return i++; } } class Safe implements SharedArg { private static AtomicInteger counter = new AtomicInteger(); public int get() { return counter.getAndIncrement(); } } class SharedUser implements HasID { private final int id; SharedUser(SharedArg sa) { id = sa.get(); } @Override public int getID() { return id; } } public class SharedConstructorArgument { public static void main(String[] args) { Unsafe unsafe = new Unsafe(); IDChecker.test(() -> new SharedUser(unsafe)); Safe safe = new Safe(); IDChecker.test(() -> new SharedUser(safe)); } } /* Output: 24838 0 */ OnJava8-Examples-1.0/concurrent/SingleThreadExecutor.java000066400000000000000000000024761374004044700235250ustar00rootroot00000000000000// concurrent/SingleThreadExecutor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; import onjava.*; public class SingleThreadExecutor { public static void main(String[] args) { ExecutorService exec = Executors.newSingleThreadExecutor(); IntStream.range(0, 10) .mapToObj(NapTask::new) .forEach(exec::execute); System.out.println("All tasks submitted"); exec.shutdown(); while(!exec.isTerminated()) { System.out.println( Thread.currentThread().getName() + " awaiting termination"); new Nap(0.1); } } } /* Output: All tasks submitted main awaiting termination main awaiting termination NapTask[0] pool-1-thread-1 main awaiting termination NapTask[1] pool-1-thread-1 main awaiting termination NapTask[2] pool-1-thread-1 main awaiting termination NapTask[3] pool-1-thread-1 main awaiting termination NapTask[4] pool-1-thread-1 main awaiting termination NapTask[5] pool-1-thread-1 main awaiting termination NapTask[6] pool-1-thread-1 main awaiting termination NapTask[7] pool-1-thread-1 main awaiting termination NapTask[8] pool-1-thread-1 main awaiting termination NapTask[9] pool-1-thread-1 */ OnJava8-Examples-1.0/concurrent/SingleThreadExecutor2.java000066400000000000000000000015131374004044700235760ustar00rootroot00000000000000// concurrent/SingleThreadExecutor2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; public class SingleThreadExecutor2 { public static void main(String[] args) throws InterruptedException { ExecutorService exec = Executors.newSingleThreadExecutor(); IntStream.range(0, 10) .mapToObj(NapTask::new) .forEach(exec::execute); exec.shutdown(); } } /* Output: NapTask[0] pool-1-thread-1 NapTask[1] pool-1-thread-1 NapTask[2] pool-1-thread-1 NapTask[3] pool-1-thread-1 NapTask[4] pool-1-thread-1 NapTask[5] pool-1-thread-1 NapTask[6] pool-1-thread-1 NapTask[7] pool-1-thread-1 NapTask[8] pool-1-thread-1 NapTask[9] pool-1-thread-1 */ OnJava8-Examples-1.0/concurrent/SingleThreadExecutor3.java000066400000000000000000000014421374004044700236000ustar00rootroot00000000000000// concurrent/SingleThreadExecutor3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; public class SingleThreadExecutor3 { public static void main(String[] args) throws InterruptedException { ExecutorService exec = Executors.newSingleThreadExecutor(); IntStream.range(0, 10) .mapToObj(InterferingTask::new) .forEach(exec::execute); exec.shutdown(); } } /* Output: 0 pool-1-thread-1 100 1 pool-1-thread-1 200 2 pool-1-thread-1 300 3 pool-1-thread-1 400 4 pool-1-thread-1 500 5 pool-1-thread-1 600 6 pool-1-thread-1 700 7 pool-1-thread-1 800 8 pool-1-thread-1 900 9 pool-1-thread-1 1000 */ OnJava8-Examples-1.0/concurrent/StaticIDField.java000066400000000000000000000005301374004044700220320ustar00rootroot00000000000000// concurrent/StaticIDField.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class StaticIDField implements HasID { private static int counter = 0; private int id = counter++; public int getID() { return id; } } OnJava8-Examples-1.0/concurrent/StickHolder.java000066400000000000000000000013721374004044700216420ustar00rootroot00000000000000// concurrent/StickHolder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class StickHolder { private static class Chopstick {} private Chopstick stick = new Chopstick(); private BlockingQueue holder = new ArrayBlockingQueue<>(1); public StickHolder() { putDown(); } public void pickUp() { try { holder.take(); // Blocks if unavailable } catch(InterruptedException e) { throw new RuntimeException(e); } } public void putDown() { try { holder.put(stick); } catch(InterruptedException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/concurrent/StreamExceptions.java000066400000000000000000000020421374004044700227170ustar00rootroot00000000000000// concurrent/StreamExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.stream.*; public class StreamExceptions { static Stream test(String id, int failcount) { return Stream.of(new Breakable(id, failcount)) .map(Breakable::work) .map(Breakable::work) .map(Breakable::work) .map(Breakable::work); } public static void main(String[] args) { // No operations are even applied ... test("A", 1); test("B", 2); Stream c = test("C", 3); test("D", 4); test("E", 5); // ... until there's a terminal operation: System.out.println("Entering try"); try { c.forEach(System.out::println); // [1] } catch(Exception e) { System.out.println(e.getMessage()); } } } /* Output: Entering try Breakable_C [2] Breakable_C [1] Throwing Exception for C Breakable_C failed */ OnJava8-Examples-1.0/concurrent/Summing.java000066400000000000000000000027761374004044700210570ustar00rootroot00000000000000// concurrent/Summing.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; import java.util.function.*; import onjava.Timer; public class Summing { static void timeTest(String id, long checkValue, LongSupplier operation) { System.out.print(id + ": "); Timer timer = new Timer(); long result = operation.getAsLong(); if(result == checkValue) System.out.println(timer.duration() + "ms"); else System.out.format("result: %d%ncheckValue: %d%n", result, checkValue); } public static final int SZ = 100_000_000; // This even works: // public static final int SZ = 1_000_000_000; public static final long CHECK = (long)SZ * ((long)SZ + 1)/2; // Gauss's formula public static void main(String[] args) { System.out.println(CHECK); timeTest("Sum Stream", CHECK, () -> LongStream.rangeClosed(0, SZ).sum()); timeTest("Sum Stream Parallel", CHECK, () -> LongStream.rangeClosed(0, SZ).parallel().sum()); timeTest("Sum Iterated", CHECK, () -> LongStream.iterate(0, i -> i + 1) .limit(SZ+1).sum()); // Slower & runs out of memory above 1_000_000: // timeTest("Sum Iterated Parallel", CHECK, () -> // LongStream.iterate(0, i -> i + 1) // .parallel() // .limit(SZ+1).sum()); } } /* Output: 5000000050000000 Sum Stream: 167ms Sum Stream Parallel: 46ms Sum Iterated: 284ms */ OnJava8-Examples-1.0/concurrent/Summing2.java000066400000000000000000000024011374004044700211220ustar00rootroot00000000000000// concurrent/Summing2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromTravisCI} import java.util.*; public class Summing2 { static long basicSum(long[] ia) { long sum = 0; int size = ia.length; for(int i = 0; i < size; i++) sum += ia[i]; return sum; } // Approximate largest value of SZ before // running out of memory on my machine: public static final int SZ = 20_000_000; public static final long CHECK = (long)SZ * ((long)SZ + 1)/2; public static void main(String[] args) { System.out.println(CHECK); long[] la = new long[SZ+1]; Arrays.parallelSetAll(la, i -> i); Summing.timeTest("Array Stream Sum", CHECK, () -> Arrays.stream(la).sum()); Summing.timeTest("Parallel", CHECK, () -> Arrays.stream(la).parallel().sum()); Summing.timeTest("Basic Sum", CHECK, () -> basicSum(la)); // Destructive summation: Summing.timeTest("parallelPrefix", CHECK, () -> { Arrays.parallelPrefix(la, Long::sum); return la[la.length - 1]; }); } } /* Output: 200000010000000 Array Stream Sum: 104ms Parallel: 81ms Basic Sum: 106ms parallelPrefix: 265ms */ OnJava8-Examples-1.0/concurrent/Summing3.java000066400000000000000000000023271374004044700211320ustar00rootroot00000000000000// concurrent/Summing3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromTravisCI} import java.util.*; public class Summing3 { static long basicSum(Long[] ia) { long sum = 0; int size = ia.length; for(int i = 0; i < size; i++) sum += ia[i]; return sum; } // Approximate largest value of SZ before // running out of memory on my machine: public static final int SZ = 10_000_000; public static final long CHECK = (long)SZ * ((long)SZ + 1)/2; public static void main(String[] args) { System.out.println(CHECK); Long[] aL = new Long[SZ+1]; Arrays.parallelSetAll(aL, i -> (long)i); Summing.timeTest("Long Array Stream Reduce", CHECK, () -> Arrays.stream(aL).reduce(0L, Long::sum)); Summing.timeTest("Long Basic Sum", CHECK, () -> basicSum(aL)); // Destructive summation: Summing.timeTest("Long parallelPrefix",CHECK, ()-> { Arrays.parallelPrefix(aL, Long::sum); return aL[aL.length - 1]; }); } } /* Output: 50000005000000 Long Array Stream Reduce: 1038ms Long Basic Sum: 21ms Long parallelPrefix: 3616ms */ OnJava8-Examples-1.0/concurrent/Summing4.java000066400000000000000000000011641374004044700211310ustar00rootroot00000000000000// concurrent/Summing4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromTravisCI} import java.util.*; public class Summing4 { public static void main(String[] args) { System.out.println(Summing3.CHECK); Long[] aL = new Long[Summing3.SZ+1]; Arrays.parallelSetAll(aL, i -> (long)i); Summing.timeTest("Long Parallel", Summing3.CHECK, () -> Arrays.stream(aL) .parallel() .reduce(0L,Long::sum)); } } /* Output: 50000005000000 Long Parallel: 1014ms */ OnJava8-Examples-1.0/concurrent/SynchronizedConstructor.java000066400000000000000000000013201374004044700243450ustar00rootroot00000000000000// concurrent/SynchronizedConstructor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.*; class SyncConstructor implements HasID { private final int id; private static Object constructorLock = new Object(); SyncConstructor(SharedArg sa) { synchronized(constructorLock) { id = sa.get(); } } @Override public int getID() { return id; } } public class SynchronizedConstructor { public static void main(String[] args) { Unsafe unsafe = new Unsafe(); IDChecker.test(() -> new SyncConstructor(unsafe)); } } /* Output: 0 */ OnJava8-Examples-1.0/concurrent/SynchronizedFactory.java000066400000000000000000000013151374004044700234330ustar00rootroot00000000000000// concurrent/SynchronizedFactory.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.*; final class SyncFactory implements HasID { private final int id; private SyncFactory(SharedArg sa) { id = sa.get(); } @Override public int getID() { return id; } public static synchronized SyncFactory factory(SharedArg sa) { return new SyncFactory(sa); } } public class SynchronizedFactory { public static void main(String[] args) { Unsafe unsafe = new Unsafe(); IDChecker.test(() -> SyncFactory.factory(unsafe)); } } /* Output: 0 */ OnJava8-Examples-1.0/concurrent/TestStaticIDField.java000066400000000000000000000005261374004044700226770ustar00rootroot00000000000000// concurrent/TestStaticIDField.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class TestStaticIDField { public static void main(String[] args) { IDChecker.test(StaticIDField::new); } } /* Output: 13287 */ OnJava8-Examples-1.0/concurrent/ThrowsChecked.java000066400000000000000000000022211374004044700221560ustar00rootroot00000000000000// concurrent/ThrowsChecked.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; import java.util.concurrent.*; public class ThrowsChecked { class Checked extends Exception {} static ThrowsChecked nochecked(ThrowsChecked tc) { return tc; } static ThrowsChecked withchecked(ThrowsChecked tc) throws Checked { return tc; } static void testStream() { Stream.of(new ThrowsChecked()) .map(ThrowsChecked::nochecked) // .map(ThrowsChecked::withchecked); // [1] .map(tc -> { try { return withchecked(tc); } catch(Checked e) { throw new RuntimeException(e); } }); } static void testCompletableFuture() { CompletableFuture .completedFuture(new ThrowsChecked()) .thenApply(ThrowsChecked::nochecked) // .thenApply(ThrowsChecked::withchecked); // [2] .thenApply(tc -> { try { return withchecked(tc); } catch(Checked e) { throw new RuntimeException(e); } }); } } OnJava8-Examples-1.0/concurrent/Workable.java000066400000000000000000000015231374004044700211730ustar00rootroot00000000000000// concurrent/Workable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import onjava.Nap; public class Workable { String id; final double duration; public Workable(String id, double duration) { this.id = id; this.duration = duration; } @Override public String toString() { return "Workable[" + id + "]"; } public static Workable work(Workable tt) { new Nap(tt.duration); // Seconds tt.id = tt.id + "W"; System.out.println(tt); return tt; } public static CompletableFuture make(String id, double duration) { return CompletableFuture.completedFuture( new Workable(id, duration)) .thenApplyAsync(Workable::work); } } OnJava8-Examples-1.0/control/000077500000000000000000000000001374004044700160575ustar00rootroot00000000000000OnJava8-Examples-1.0/control/BreakAndContinue.java000066400000000000000000000020421374004044700220740ustar00rootroot00000000000000// control/BreakAndContinue.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Break and continue keywords import static onjava.Range.*; public class BreakAndContinue { public static void main(String[] args) { for(int i = 0; i < 100; i++) { // [1] if(i == 74) break; // Out of for loop if(i % 9 != 0) continue; // Next iteration System.out.print(i + " "); } System.out.println(); // Using for-in: for(int i : range(100)) { // [2] if(i == 74) break; // Out of for loop if(i % 9 != 0) continue; // Next iteration System.out.print(i + " "); } System.out.println(); int i = 0; // An "infinite loop": while(true) { // [3] i++; int j = i * 27; if(j == 1269) break; // Out of loop if(i % 10 != 0) continue; // Top of loop System.out.print(i + " "); } } } /* Output: 0 9 18 27 36 45 54 63 72 0 9 18 27 36 45 54 63 72 10 20 30 40 */ OnJava8-Examples-1.0/control/CommaOperator.java000066400000000000000000000007001374004044700214670ustar00rootroot00000000000000// control/CommaOperator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class CommaOperator { public static void main(String[] args) { for(int i = 1, j = i + 10; i < 5; i++, j = i * 2) { System.out.println("i = " + i + " j = " + j); } } } /* Output: i = 1 j = 11 i = 2 j = 4 i = 3 j = 6 i = 4 j = 8 */ OnJava8-Examples-1.0/control/ForInFloat.java000066400000000000000000000011101374004044700207160ustar00rootroot00000000000000// control/ForInFloat.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ForInFloat { public static void main(String[] args) { Random rand = new Random(47); float[] f = new float[10]; for(int i = 0; i < 10; i++) f[i] = rand.nextFloat(); for(float x : f) System.out.println(x); } } /* Output: 0.72711575 0.39982635 0.5309454 0.0534122 0.16020656 0.57799757 0.18847865 0.4170137 0.51660204 0.73734957 */ OnJava8-Examples-1.0/control/ForInInt.java000066400000000000000000000014001374004044700204050ustar00rootroot00000000000000// control/ForInInt.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import static onjava.Range.*; public class ForInInt { public static void main(String[] args) { for(int i : range(10)) // 0..9 System.out.print(i + " "); System.out.println(); for(int i : range(5, 10)) // 5..9 System.out.print(i + " "); System.out.println(); for(int i : range(5, 20, 3)) // 5..20 step 3 System.out.print(i + " "); System.out.println(); for(int i : range(20, 5, -3)) // Count down System.out.print(i + " "); System.out.println(); } } /* Output: 0 1 2 3 4 5 6 7 8 9 5 6 7 8 9 5 8 11 14 17 20 17 14 11 8 */ OnJava8-Examples-1.0/control/ForInString.java000066400000000000000000000006231374004044700211270ustar00rootroot00000000000000// control/ForInString.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ForInString { public static void main(String[] args) { for(char c : "An African Swallow".toCharArray()) System.out.print(c + " "); } } /* Output: A n A f r i c a n S w a l l o w */ OnJava8-Examples-1.0/control/IfElse.java000066400000000000000000000011731374004044700200730ustar00rootroot00000000000000// control/IfElse.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class IfElse { static int result = 0; static void test(int testval, int target) { if(testval > target) result = +1; else if(testval < target) // [1] result = -1; else result = 0; // Match } public static void main(String[] args) { test(10, 5); System.out.println(result); test(5, 10); System.out.println(result); test(5, 5); System.out.println(result); } } /* Output: 1 -1 0 */ OnJava8-Examples-1.0/control/LabeledFor.java000066400000000000000000000026571374004044700207330ustar00rootroot00000000000000// control/LabeledFor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // For loops with "labeled break"/"labeled continue." public class LabeledFor { public static void main(String[] args) { int i = 0; outer: // Can't have statements here for(; true ;) { // infinite loop inner: // Can't have statements here for(; i < 10; i++) { System.out.println("i = " + i); if(i == 2) { System.out.println("continue"); continue; } if(i == 3) { System.out.println("break"); i++; // Otherwise i never // gets incremented. break; } if(i == 7) { System.out.println("continue outer"); i++; // Otherwise i never // gets incremented. continue outer; } if(i == 8) { System.out.println("break outer"); break outer; } for(int k = 0; k < 5; k++) { if(k == 3) { System.out.println("continue inner"); continue inner; } } } } // Can't break or continue to labels here } } /* Output: i = 0 continue inner i = 1 continue inner i = 2 continue i = 3 break i = 4 continue inner i = 5 continue inner i = 6 continue inner i = 7 continue outer i = 8 break outer */ OnJava8-Examples-1.0/control/LabeledWhile.java000066400000000000000000000020131374004044700212370ustar00rootroot00000000000000// control/LabeledWhile.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // "While" with "labeled break" and "labeled continue." public class LabeledWhile { public static void main(String[] args) { int i = 0; outer: while(true) { System.out.println("Outer while loop"); while(true) { i++; System.out.println("i = " + i); if(i == 1) { System.out.println("continue"); continue; } if(i == 3) { System.out.println("continue outer"); continue outer; } if(i == 5) { System.out.println("break"); break; } if(i == 7) { System.out.println("break outer"); break outer; } } } } } /* Output: Outer while loop i = 1 continue i = 2 i = 3 continue outer Outer while loop i = 4 i = 5 break Outer while loop i = 6 i = 7 break outer */ OnJava8-Examples-1.0/control/ListCharacters.java000066400000000000000000000013571374004044700216430ustar00rootroot00000000000000// control/ListCharacters.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // List all the lowercase ASCII letters public class ListCharacters { public static void main(String[] args) { for(char c = 0; c < 128; c++) if(Character.isLowerCase(c)) System.out.println("value: " + (int)c + " character: " + c); } } /* Output: (First 10 Lines) value: 97 character: a value: 98 character: b value: 99 character: c value: 100 character: d value: 101 character: e value: 102 character: f value: 103 character: g value: 104 character: h value: 105 character: i value: 106 character: j ... */ OnJava8-Examples-1.0/control/RandomBounds.java000066400000000000000000000016041374004044700213160ustar00rootroot00000000000000// control/RandomBounds.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Does Math.random() produce 0.0 and 1.0? // {java RandomBounds lower} import onjava.*; public class RandomBounds { public static void main(String[] args) { new TimedAbort(3); switch(args.length == 0 ? "" : args[0]) { case "lower": while(Math.random() != 0.0) ; // Keep trying System.out.println("Produced 0.0!"); break; case "upper": while(Math.random() != 1.0) ; // Keep trying System.out.println("Produced 1.0!"); break; default: System.out.println("Usage:"); System.out.println("\tRandomBounds lower"); System.out.println("\tRandomBounds upper"); System.exit(1); } } } OnJava8-Examples-1.0/control/StringSwitch.java000066400000000000000000000021151374004044700213510ustar00rootroot00000000000000// control/StringSwitch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class StringSwitch { public static void main(String[] args) { String color = "red"; // Old way: using if-then if("red".equals(color)) { System.out.println("RED"); } else if("green".equals(color)) { System.out.println("GREEN"); } else if("blue".equals(color)) { System.out.println("BLUE"); } else if("yellow".equals(color)) { System.out.println("YELLOW"); } else { System.out.println("Unknown"); } // New way: Strings in switch switch(color) { case "red": System.out.println("RED"); break; case "green": System.out.println("GREEN"); break; case "blue": System.out.println("BLUE"); break; case "yellow": System.out.println("YELLOW"); break; default: System.out.println("Unknown"); break; } } } /* Output: RED RED */ OnJava8-Examples-1.0/control/TestWithReturn.java000066400000000000000000000010601374004044700216720ustar00rootroot00000000000000// control/TestWithReturn.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class TestWithReturn { static int test(int testval, int target) { if(testval > target) return +1; if(testval < target) return -1; return 0; // Match } public static void main(String[] args) { System.out.println(test(10, 5)); System.out.println(test(5, 10)); System.out.println(test(5, 5)); } } /* Output: 1 -1 0 */ OnJava8-Examples-1.0/control/TrueFalse.java000066400000000000000000000005401374004044700206130ustar00rootroot00000000000000// control/TrueFalse.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class TrueFalse { public static void main(String[] args) { System.out.println(1 == 1); System.out.println(1 == 2); } } /* Output: true false */ OnJava8-Examples-1.0/control/VowelsAndConsonants.java000066400000000000000000000021441374004044700226730ustar00rootroot00000000000000// control/VowelsAndConsonants.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates the switch statement import java.util.*; public class VowelsAndConsonants { public static void main(String[] args) { Random rand = new Random(47); for(int i = 0; i < 100; i++) { int c = rand.nextInt(26) + 'a'; System.out.print((char)c + ", " + c + ": "); switch(c) { case 'a': case 'e': case 'i': case 'o': case 'u': System.out.println("vowel"); break; case 'y': case 'w': System.out.println("Sometimes vowel"); break; default: System.out.println("consonant"); } } } } /* Output: (First 13 Lines) y, 121: Sometimes vowel n, 110: consonant z, 122: consonant b, 98: consonant r, 114: consonant n, 110: consonant y, 121: Sometimes vowel g, 103: consonant c, 99: consonant f, 102: consonant o, 111: vowel w, 119: Sometimes vowel z, 122: consonant ... */ OnJava8-Examples-1.0/control/WhileTest.java000066400000000000000000000015031374004044700206310ustar00rootroot00000000000000// control/WhileTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates the while loop public class WhileTest { static boolean condition() { boolean result = Math.random() < 0.99; System.out.print(result + ", "); return result; } public static void main(String[] args) { while(condition()) System.out.println("Inside 'while'"); System.out.println("Exited 'while'"); } } /* Output: (First and Last 5 Lines) true, Inside 'while' true, Inside 'while' true, Inside 'while' true, Inside 'while' true, Inside 'while' ...________...________...________...________... true, Inside 'while' true, Inside 'while' true, Inside 'while' true, Inside 'while' false, Exited 'while' */ OnJava8-Examples-1.0/enums/000077500000000000000000000000001374004044700155265ustar00rootroot00000000000000OnJava8-Examples-1.0/enums/AlarmPoints.java000066400000000000000000000005011374004044700206160ustar00rootroot00000000000000// enums/AlarmPoints.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package enums; public enum AlarmPoints { STAIR1, STAIR2, LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY, KITCHEN } OnJava8-Examples-1.0/enums/BigEnumSet.java000066400000000000000000000022241374004044700203730ustar00rootroot00000000000000// enums/BigEnumSet.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class BigEnumSet { enum Big { A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, A66, A67, A68, A69, A70, A71, A72, A73, A74, A75 } public static void main(String[] args) { EnumSet bigEnumSet = EnumSet.allOf(Big.class); System.out.println(bigEnumSet); } } /* Output: [A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23, A24, A25, A26, A27, A28, A29, A30, A31, A32, A33, A34, A35, A36, A37, A38, A39, A40, A41, A42, A43, A44, A45, A46, A47, A48, A49, A50, A51, A52, A53, A54, A55, A56, A57, A58, A59, A60, A61, A62, A63, A64, A65, A66, A67, A68, A69, A70, A71, A72, A73, A74, A75] */ OnJava8-Examples-1.0/enums/Burrito2.java000066400000000000000000000013011374004044700200740ustar00rootroot00000000000000// enums/Burrito2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java enums.Burrito2} package enums; import static enums.SpicinessEnum.*; public class Burrito2 { SpicinessEnum degree; public Burrito2(SpicinessEnum degree) { this.degree = degree; } @Override public String toString() { return "Burrito is "+ degree; } public static void main(String[] args) { System.out.println(new Burrito2(NOT)); System.out.println(new Burrito2(MEDIUM)); System.out.println(new Burrito2(HOT)); } } /* Output: Burrito is NOT Burrito is MEDIUM Burrito is HOT */ OnJava8-Examples-1.0/enums/CarWash.java000066400000000000000000000034741374004044700177310ustar00rootroot00000000000000// enums/CarWash.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class CarWash { public enum Cycle { UNDERBODY { @Override void action() { System.out.println("Spraying the underbody"); } }, WHEELWASH { @Override void action() { System.out.println("Washing the wheels"); } }, PREWASH { @Override void action() { System.out.println("Loosening the dirt"); } }, BASIC { @Override void action() { System.out.println("The basic wash"); } }, HOTWAX { @Override void action() { System.out.println("Applying hot wax"); } }, RINSE { @Override void action() { System.out.println("Rinsing"); } }, BLOWDRY { @Override void action() { System.out.println("Blowing dry"); } }; abstract void action(); } EnumSet cycles = EnumSet.of(Cycle.BASIC, Cycle.RINSE); public void add(Cycle cycle) { cycles.add(cycle); } public void washCar() { for(Cycle c : cycles) c.action(); } @Override public String toString() { return cycles.toString(); } public static void main(String[] args) { CarWash wash = new CarWash(); System.out.println(wash); wash.washCar(); // Order of addition is unimportant: wash.add(Cycle.BLOWDRY); wash.add(Cycle.BLOWDRY); // Duplicates ignored wash.add(Cycle.RINSE); wash.add(Cycle.HOTWAX); System.out.println(wash); wash.washCar(); } } /* Output: [BASIC, RINSE] The basic wash Rinsing [BASIC, HOTWAX, RINSE, BLOWDRY] The basic wash Applying hot wax Rinsing Blowing dry */ OnJava8-Examples-1.0/enums/Competitor.java000066400000000000000000000005061374004044700205170ustar00rootroot00000000000000// enums/Competitor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Switching one enum on another package enums; public interface Competitor> { Outcome compete(T competitor); } OnJava8-Examples-1.0/enums/ConstantSpecificMethod.java000066400000000000000000000016411374004044700227730ustar00rootroot00000000000000// enums/ConstantSpecificMethod.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.text.*; public enum ConstantSpecificMethod { DATE_TIME { @Override String getInfo() { return DateFormat.getDateInstance() .format(new Date()); } }, CLASSPATH { @Override String getInfo() { return System.getenv("CLASSPATH"); } }, VERSION { @Override String getInfo() { return System.getProperty("java.version"); } }; abstract String getInfo(); public static void main(String[] args) { for(ConstantSpecificMethod csm : values()) System.out.println(csm.getInfo()); } } /* Output: May 9, 2017 C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\\gradle\wrapper\gradle- wrapper.jar 1.8.0_112 */ OnJava8-Examples-1.0/enums/EnumClass.java000066400000000000000000000023751374004044700202720ustar00rootroot00000000000000// enums/EnumClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Capabilities of the Enum class enum Shrubbery { GROUND, CRAWLING, HANGING } public class EnumClass { public static void main(String[] args) { for(Shrubbery s : Shrubbery.values()) { System.out.println( s + " ordinal: " + s.ordinal()); System.out.print( s.compareTo(Shrubbery.CRAWLING) + " "); System.out.print( s.equals(Shrubbery.CRAWLING) + " "); System.out.println(s == Shrubbery.CRAWLING); System.out.println(s.getDeclaringClass()); System.out.println(s.name()); System.out.println("********************"); } // Produce an enum value from a String name: for(String s : "HANGING CRAWLING GROUND".split(" ")) { Shrubbery shrub = Enum.valueOf(Shrubbery.class, s); System.out.println(shrub); } } } /* Output: GROUND ordinal: 0 -1 false false class Shrubbery GROUND ******************** CRAWLING ordinal: 1 0 true true class Shrubbery CRAWLING ******************** HANGING ordinal: 2 1 false false class Shrubbery HANGING ******************** HANGING CRAWLING GROUND */ OnJava8-Examples-1.0/enums/EnumMaps.java000066400000000000000000000020301374004044700201110ustar00rootroot00000000000000// enums/EnumMaps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Basics of EnumMaps // {java enums.EnumMaps} package enums; import java.util.*; import static enums.AlarmPoints.*; interface Command { void action(); } public class EnumMaps { public static void main(String[] args) { EnumMap em = new EnumMap<>(AlarmPoints.class); em.put(KITCHEN, () -> System.out.println("Kitchen fire!")); em.put(BATHROOM, () -> System.out.println("Bathroom alert!")); for(Map.Entry e: em.entrySet()) { System.out.print(e.getKey() + ": "); e.getValue().action(); } try { // If there's no value for a particular key: em.get(UTILITY).action(); } catch(Exception e) { System.out.println("Expected: " + e); } } } /* Output: BATHROOM: Bathroom alert! KITCHEN: Kitchen fire! Expected: java.lang.NullPointerException */ OnJava8-Examples-1.0/enums/EnumSets.java000066400000000000000000000021701374004044700201340ustar00rootroot00000000000000// enums/EnumSets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Operations on EnumSets // {java enums.EnumSets} package enums; import java.util.*; import static enums.AlarmPoints.*; public class EnumSets { public static void main(String[] args) { EnumSet points = EnumSet.noneOf(AlarmPoints.class); // Empty points.add(BATHROOM); System.out.println(points); points.addAll( EnumSet.of(STAIR1, STAIR2, KITCHEN)); System.out.println(points); points = EnumSet.allOf(AlarmPoints.class); points.removeAll( EnumSet.of(STAIR1, STAIR2, KITCHEN)); System.out.println(points); points.removeAll( EnumSet.range(OFFICE1, OFFICE4)); System.out.println(points); points = EnumSet.complementOf(points); System.out.println(points); } } /* Output: [BATHROOM] [STAIR1, STAIR2, BATHROOM, KITCHEN] [LOBBY, OFFICE1, OFFICE2, OFFICE3, OFFICE4, BATHROOM, UTILITY] [LOBBY, BATHROOM, UTILITY] [STAIR1, STAIR2, OFFICE1, OFFICE2, OFFICE3, OFFICE4, KITCHEN] */ OnJava8-Examples-1.0/enums/Input.java000066400000000000000000000016461374004044700174770ustar00rootroot00000000000000// enums/Input.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public enum Input { NICKEL(5), DIME(10), QUARTER(25), DOLLAR(100), TOOTHPASTE(200), CHIPS(75), SODA(100), SOAP(50), ABORT_TRANSACTION { @Override public int amount() { // Disallow throw new RuntimeException("ABORT.amount()"); } }, STOP { // This must be the last instance. @Override public int amount() { // Disallow throw new RuntimeException("SHUT_DOWN.amount()"); } }; int value; // In cents Input(int value) { this.value = value; } Input() {} int amount() { return value; }; // In cents static Random rand = new Random(47); public static Input randomSelection() { // Don't include STOP: return values()[rand.nextInt(values().length - 1)]; } } OnJava8-Examples-1.0/enums/NonEnum.java000066400000000000000000000010171374004044700177470ustar00rootroot00000000000000// enums/NonEnum.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class NonEnum { public static void main(String[] args) { Class intClass = Integer.class; try { for(Object en : intClass.getEnumConstants()) System.out.println(en); } catch(Exception e) { System.out.println("Expected: " + e); } } } /* Output: Expected: java.lang.NullPointerException */ OnJava8-Examples-1.0/enums/NotClasses.java000066400000000000000000000022041374004044700204450ustar00rootroot00000000000000// enums/NotClasses.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromGradle} // javap -c LikeClasses enum LikeClasses { WINKEN { @Override void behavior() { System.out.println("Behavior1"); } }, BLINKEN { @Override void behavior() { System.out.println("Behavior2"); } }, NOD { @Override void behavior() { System.out.println("Behavior3"); } }; abstract void behavior(); } public class NotClasses { // void f1(LikeClasses.WINKEN instance) {} // Nope } /* Output: (First 12 Lines) Compiled from "NotClasses.java" abstract class LikeClasses extends java.lang.Enum { public static final LikeClasses WINKEN; public static final LikeClasses BLINKEN; public static final LikeClasses NOD; public static LikeClasses[] values(); Code: 0: getstatic #2 // Field $VALUES:[LLikeClasses; 3: invokevirtual #3 // Method "[LLikeClasses;".clone:()Ljava/lang/Object; ... */ OnJava8-Examples-1.0/enums/Outcome.java000066400000000000000000000003571374004044700200110ustar00rootroot00000000000000// enums/Outcome.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package enums; public enum Outcome { WIN, LOSE, DRAW } OnJava8-Examples-1.0/enums/OverrideConstantSpecific.java000066400000000000000000000012171374004044700233310ustar00rootroot00000000000000// enums/OverrideConstantSpecific.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public enum OverrideConstantSpecific { NUT, BOLT, WASHER { @Override void f() { System.out.println("Overridden method"); } }; void f() { System.out.println("default behavior"); } public static void main(String[] args) { for(OverrideConstantSpecific ocs : values()) { System.out.print(ocs + ": "); ocs.f(); } } } /* Output: NUT: default behavior BOLT: default behavior WASHER: Overridden method */ OnJava8-Examples-1.0/enums/OzWitch.java000066400000000000000000000022111374004044700177540ustar00rootroot00000000000000// enums/OzWitch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The witches in the land of Oz public enum OzWitch { // Instances must be defined first, before methods: WEST("Miss Gulch, aka the Wicked Witch of the West"), NORTH("Glinda, the Good Witch of the North"), EAST("Wicked Witch of the East, wearer of the Ruby " + "Slippers, crushed by Dorothy's house"), SOUTH("Good by inference, but missing"); private String description; // Constructor must be package or private access: private OzWitch(String description) { this.description = description; } public String getDescription() { return description; } public static void main(String[] args) { for(OzWitch witch : OzWitch.values()) System.out.println( witch + ": " + witch.getDescription()); } } /* Output: WEST: Miss Gulch, aka the Wicked Witch of the West NORTH: Glinda, the Good Witch of the North EAST: Wicked Witch of the East, wearer of the Ruby Slippers, crushed by Dorothy's house SOUTH: Good by inference, but missing */ OnJava8-Examples-1.0/enums/PostOffice.java000066400000000000000000000130531374004044700204340ustar00rootroot00000000000000// enums/PostOffice.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Modeling a post office import java.util.*; import onjava.*; class Mail { // The NO's reduce probability of random selection: enum GeneralDelivery {YES,NO1,NO2,NO3,NO4,NO5} enum Scannability {UNSCANNABLE,YES1,YES2,YES3,YES4} enum Readability {ILLEGIBLE,YES1,YES2,YES3,YES4} enum Address {INCORRECT,OK1,OK2,OK3,OK4,OK5,OK6} enum ReturnAddress {MISSING,OK1,OK2,OK3,OK4,OK5} GeneralDelivery generalDelivery; Scannability scannability; Readability readability; Address address; ReturnAddress returnAddress; static long counter = 0; long id = counter++; @Override public String toString() { return "Mail " + id; } public String details() { return toString() + ", General Delivery: " + generalDelivery + ", Address Scanability: " + scannability + ", Address Readability: " + readability + ", Address Address: " + address + ", Return address: " + returnAddress; } // Generate test Mail: public static Mail randomMail() { Mail m = new Mail(); m.generalDelivery = Enums.random(GeneralDelivery.class); m.scannability = Enums.random(Scannability.class); m.readability = Enums.random(Readability.class); m.address = Enums.random(Address.class); m.returnAddress = Enums.random(ReturnAddress.class); return m; } public static Iterable generator(final int count) { return new Iterable() { int n = count; @Override public Iterator iterator() { return new Iterator() { @Override public boolean hasNext() { return n-- > 0; } @Override public Mail next() { return randomMail(); } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } }; } } public class PostOffice { enum MailHandler { GENERAL_DELIVERY { @Override boolean handle(Mail m) { switch(m.generalDelivery) { case YES: System.out.println( "Using general delivery for " + m); return true; default: return false; } } }, MACHINE_SCAN { @Override boolean handle(Mail m) { switch(m.scannability) { case UNSCANNABLE: return false; default: switch(m.address) { case INCORRECT: return false; default: System.out.println( "Delivering "+ m + " automatically"); return true; } } } }, VISUAL_INSPECTION { @Override boolean handle(Mail m) { switch(m.readability) { case ILLEGIBLE: return false; default: switch(m.address) { case INCORRECT: return false; default: System.out.println( "Delivering " + m + " normally"); return true; } } } }, RETURN_TO_SENDER { @Override boolean handle(Mail m) { switch(m.returnAddress) { case MISSING: return false; default: System.out.println( "Returning " + m + " to sender"); return true; } } }; abstract boolean handle(Mail m); } static void handle(Mail m) { for(MailHandler handler : MailHandler.values()) if(handler.handle(m)) return; System.out.println(m + " is a dead letter"); } public static void main(String[] args) { for(Mail mail : Mail.generator(10)) { System.out.println(mail.details()); handle(mail); System.out.println("*****"); } } } /* Output: Mail 0, General Delivery: NO2, Address Scanability: UNSCANNABLE, Address Readability: YES3, Address Address: OK1, Return address: OK1 Delivering Mail 0 normally ***** Mail 1, General Delivery: NO5, Address Scanability: YES3, Address Readability: ILLEGIBLE, Address Address: OK5, Return address: OK1 Delivering Mail 1 automatically ***** Mail 2, General Delivery: YES, Address Scanability: YES3, Address Readability: YES1, Address Address: OK1, Return address: OK5 Using general delivery for Mail 2 ***** Mail 3, General Delivery: NO4, Address Scanability: YES3, Address Readability: YES1, Address Address: INCORRECT, Return address: OK4 Returning Mail 3 to sender ***** Mail 4, General Delivery: NO4, Address Scanability: UNSCANNABLE, Address Readability: YES1, Address Address: INCORRECT, Return address: OK2 Returning Mail 4 to sender ***** Mail 5, General Delivery: NO3, Address Scanability: YES1, Address Readability: ILLEGIBLE, Address Address: OK4, Return address: OK2 Delivering Mail 5 automatically ***** Mail 6, General Delivery: YES, Address Scanability: YES4, Address Readability: ILLEGIBLE, Address Address: OK4, Return address: OK4 Using general delivery for Mail 6 ***** Mail 7, General Delivery: YES, Address Scanability: YES3, Address Readability: YES4, Address Address: OK2, Return address: MISSING Using general delivery for Mail 7 ***** Mail 8, General Delivery: NO3, Address Scanability: YES1, Address Readability: YES3, Address Address: INCORRECT, Return address: MISSING Mail 8 is a dead letter ***** Mail 9, General Delivery: NO1, Address Scanability: UNSCANNABLE, Address Readability: YES2, Address Address: OK1, Return address: OK4 Delivering Mail 9 normally ***** */ OnJava8-Examples-1.0/enums/RandomTest.java000066400000000000000000000012121374004044700204450ustar00rootroot00000000000000// enums/RandomTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; enum Activity { SITTING, LYING, STANDING, HOPPING, RUNNING, DODGING, JUMPING, FALLING, FLYING } public class RandomTest { public static void main(String[] args) { for(int i = 0; i < 20; i++) System.out.print( Enums.random(Activity.class) + " "); } } /* Output: STANDING FLYING RUNNING STANDING RUNNING STANDING LYING DODGING SITTING RUNNING HOPPING HOPPING HOPPING RUNNING STANDING LYING FALLING RUNNING FLYING LYING */ OnJava8-Examples-1.0/enums/Reflection.java000066400000000000000000000042521374004044700204660ustar00rootroot00000000000000// enums/Reflection.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Analyzing enums using reflection import java.lang.reflect.*; import java.util.*; import onjava.*; enum Explore { HERE, THERE } public class Reflection { public static Set analyze(Class enumClass) { System.out.println( "_____ Analyzing " + enumClass + " _____"); System.out.println("Interfaces:"); for(Type t : enumClass.getGenericInterfaces()) System.out.println(t); System.out.println( "Base: " + enumClass.getSuperclass()); System.out.println("Methods: "); Set methods = new TreeSet<>(); for(Method m : enumClass.getMethods()) methods.add(m.getName()); System.out.println(methods); return methods; } public static void main(String[] args) { Set exploreMethods = analyze(Explore.class); Set enumMethods = analyze(Enum.class); System.out.println( "Explore.containsAll(Enum)? " + exploreMethods.containsAll(enumMethods)); System.out.print("Explore.removeAll(Enum): "); exploreMethods.removeAll(enumMethods); System.out.println(exploreMethods); // Decompile the code for the enum: OSExecute.command( "javap -cp build/classes/java/main Explore"); } } /* Output: _____ Analyzing class Explore _____ Interfaces: Base: class java.lang.Enum Methods: [compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, values, wait] _____ Analyzing class java.lang.Enum _____ Interfaces: java.lang.Comparable interface java.io.Serializable Base: class java.lang.Object Methods: [compareTo, equals, getClass, getDeclaringClass, hashCode, name, notify, notifyAll, ordinal, toString, valueOf, wait] Explore.containsAll(Enum)? true Explore.removeAll(Enum): [values] Compiled from "Reflection.java" final class Explore extends java.lang.Enum { public static final Explore HERE; public static final Explore THERE; public static Explore[] values(); public static Explore valueOf(java.lang.String); static {}; } */ OnJava8-Examples-1.0/enums/RoShamBo.java000066400000000000000000000011621374004044700200430ustar00rootroot00000000000000// enums/RoShamBo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Common tools for RoShamBo examples package enums; import onjava.*; public class RoShamBo { public static > void match(T a, T b) { System.out.println( a + " vs. " + b + ": " + a.compete(b)); } public static & Competitor> void play(Class rsbClass, int size) { for(int i = 0; i < size; i++) match( Enums.random(rsbClass),Enums.random(rsbClass)); } } OnJava8-Examples-1.0/enums/RoShamBo1.java000066400000000000000000000047121374004044700201300ustar00rootroot00000000000000// enums/RoShamBo1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of multiple dispatching // {java enums.RoShamBo1} package enums; import java.util.*; import static enums.Outcome.*; interface Item { Outcome compete(Item it); Outcome eval(Paper p); Outcome eval(Scissors s); Outcome eval(Rock r); } class Paper implements Item { @Override public Outcome compete(Item it) { return it.eval(this); } @Override public Outcome eval(Paper p) { return DRAW; } @Override public Outcome eval(Scissors s) { return WIN; } @Override public Outcome eval(Rock r) { return LOSE; } @Override public String toString() { return "Paper"; } } class Scissors implements Item { @Override public Outcome compete(Item it) { return it.eval(this); } @Override public Outcome eval(Paper p) { return LOSE; } @Override public Outcome eval(Scissors s) { return DRAW; } @Override public Outcome eval(Rock r) { return WIN; } @Override public String toString() { return "Scissors"; } } class Rock implements Item { @Override public Outcome compete(Item it) { return it.eval(this); } @Override public Outcome eval(Paper p) { return WIN; } @Override public Outcome eval(Scissors s) { return LOSE; } @Override public Outcome eval(Rock r) { return DRAW; } @Override public String toString() { return "Rock"; } } public class RoShamBo1 { static final int SIZE = 20; private static Random rand = new Random(47); public static Item newItem() { switch(rand.nextInt(3)) { default: case 0: return new Scissors(); case 1: return new Paper(); case 2: return new Rock(); } } public static void match(Item a, Item b) { System.out.println( a + " vs. " + b + ": " + a.compete(b)); } public static void main(String[] args) { for(int i = 0; i < SIZE; i++) match(newItem(), newItem()); } } /* Output: Rock vs. Rock: DRAW Paper vs. Rock: WIN Paper vs. Rock: WIN Paper vs. Rock: WIN Scissors vs. Paper: WIN Scissors vs. Scissors: DRAW Scissors vs. Paper: WIN Rock vs. Paper: LOSE Paper vs. Paper: DRAW Rock vs. Paper: LOSE Paper vs. Scissors: LOSE Paper vs. Scissors: LOSE Rock vs. Scissors: WIN Rock vs. Paper: LOSE Paper vs. Rock: WIN Scissors vs. Paper: WIN Paper vs. Scissors: LOSE Paper vs. Scissors: LOSE Paper vs. Scissors: LOSE Paper vs. Scissors: LOSE */ OnJava8-Examples-1.0/enums/RoShamBo2.java000066400000000000000000000025651374004044700201350ustar00rootroot00000000000000// enums/RoShamBo2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Switching one enum on another // {java enums.RoShamBo2} package enums; import static enums.Outcome.*; public enum RoShamBo2 implements Competitor { PAPER(DRAW, LOSE, WIN), SCISSORS(WIN, DRAW, LOSE), ROCK(LOSE, WIN, DRAW); private Outcome vPAPER, vSCISSORS, vROCK; RoShamBo2(Outcome paper, Outcome scissors, Outcome rock) { this.vPAPER = paper; this.vSCISSORS = scissors; this.vROCK = rock; } @Override public Outcome compete(RoShamBo2 it) { switch(it) { default: case PAPER: return vPAPER; case SCISSORS: return vSCISSORS; case ROCK: return vROCK; } } public static void main(String[] args) { RoShamBo.play(RoShamBo2.class, 20); } } /* Output: ROCK vs. ROCK: DRAW SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE PAPER vs. PAPER: DRAW PAPER vs. SCISSORS: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. SCISSORS: DRAW ROCK vs. SCISSORS: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN ROCK vs. PAPER: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN */ OnJava8-Examples-1.0/enums/RoShamBo3.java000066400000000000000000000032251374004044700201300ustar00rootroot00000000000000// enums/RoShamBo3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using constant-specific methods // {java enums.RoShamBo3} package enums; import static enums.Outcome.*; public enum RoShamBo3 implements Competitor { PAPER { @Override public Outcome compete(RoShamBo3 it) { switch(it) { default: // To placate the compiler case PAPER: return DRAW; case SCISSORS: return LOSE; case ROCK: return WIN; } } }, SCISSORS { @Override public Outcome compete(RoShamBo3 it) { switch(it) { default: case PAPER: return WIN; case SCISSORS: return DRAW; case ROCK: return LOSE; } } }, ROCK { @Override public Outcome compete(RoShamBo3 it) { switch(it) { default: case PAPER: return LOSE; case SCISSORS: return WIN; case ROCK: return DRAW; } } }; @Override public abstract Outcome compete(RoShamBo3 it); public static void main(String[] args) { RoShamBo.play(RoShamBo3.class, 20); } } /* Output: ROCK vs. ROCK: DRAW SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE PAPER vs. PAPER: DRAW PAPER vs. SCISSORS: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. SCISSORS: DRAW ROCK vs. SCISSORS: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN ROCK vs. PAPER: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN */ OnJava8-Examples-1.0/enums/RoShamBo4.java000066400000000000000000000026341374004044700201340ustar00rootroot00000000000000// enums/RoShamBo4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java enums.RoShamBo4} package enums; public enum RoShamBo4 implements Competitor { ROCK { @Override public Outcome compete(RoShamBo4 opponent) { return compete(SCISSORS, opponent); } }, SCISSORS { @Override public Outcome compete(RoShamBo4 opponent) { return compete(PAPER, opponent); } }, PAPER { @Override public Outcome compete(RoShamBo4 opponent) { return compete(ROCK, opponent); } }; Outcome compete(RoShamBo4 loser, RoShamBo4 opponent) { return ((opponent == this) ? Outcome.DRAW : ((opponent == loser) ? Outcome.WIN : Outcome.LOSE)); } public static void main(String[] args) { RoShamBo.play(RoShamBo4.class, 20); } } /* Output: PAPER vs. PAPER: DRAW SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN ROCK vs. SCISSORS: WIN ROCK vs. ROCK: DRAW ROCK vs. SCISSORS: WIN PAPER vs. SCISSORS: LOSE SCISSORS vs. SCISSORS: DRAW PAPER vs. SCISSORS: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE PAPER vs. ROCK: WIN PAPER vs. SCISSORS: LOSE SCISSORS vs. PAPER: WIN ROCK vs. SCISSORS: WIN SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE */ OnJava8-Examples-1.0/enums/RoShamBo5.java000066400000000000000000000032231374004044700201300ustar00rootroot00000000000000// enums/RoShamBo5.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Multiple dispatching using an EnumMap of EnumMaps // {java enums.RoShamBo5} package enums; import java.util.*; import static enums.Outcome.*; enum RoShamBo5 implements Competitor { PAPER, SCISSORS, ROCK; static EnumMap> table = new EnumMap<>(RoShamBo5.class); static { for(RoShamBo5 it : RoShamBo5.values()) table.put(it, new EnumMap<>(RoShamBo5.class)); initRow(PAPER, DRAW, LOSE, WIN); initRow(SCISSORS, WIN, DRAW, LOSE); initRow(ROCK, LOSE, WIN, DRAW); } static void initRow(RoShamBo5 it, Outcome vPAPER, Outcome vSCISSORS, Outcome vROCK) { EnumMap row = RoShamBo5.table.get(it); row.put(RoShamBo5.PAPER, vPAPER); row.put(RoShamBo5.SCISSORS, vSCISSORS); row.put(RoShamBo5.ROCK, vROCK); } @Override public Outcome compete(RoShamBo5 it) { return table.get(this).get(it); } public static void main(String[] args) { RoShamBo.play(RoShamBo5.class, 20); } } /* Output: ROCK vs. ROCK: DRAW SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE PAPER vs. PAPER: DRAW PAPER vs. SCISSORS: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. SCISSORS: DRAW ROCK vs. SCISSORS: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN ROCK vs. PAPER: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN */ OnJava8-Examples-1.0/enums/RoShamBo6.java000066400000000000000000000023101374004044700201250ustar00rootroot00000000000000// enums/RoShamBo6.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Enums using "tables" instead of multiple dispatch // {java enums.RoShamBo6} package enums; import static enums.Outcome.*; enum RoShamBo6 implements Competitor { PAPER, SCISSORS, ROCK; private static Outcome[][] table = { { DRAW, LOSE, WIN }, // PAPER { WIN, DRAW, LOSE }, // SCISSORS { LOSE, WIN, DRAW }, // ROCK }; @Override public Outcome compete(RoShamBo6 other) { return table[this.ordinal()][other.ordinal()]; } public static void main(String[] args) { RoShamBo.play(RoShamBo6.class, 20); } } /* Output: ROCK vs. ROCK: DRAW SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE PAPER vs. PAPER: DRAW PAPER vs. SCISSORS: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. SCISSORS: DRAW ROCK vs. SCISSORS: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN ROCK vs. PAPER: LOSE ROCK vs. SCISSORS: WIN SCISSORS vs. ROCK: LOSE PAPER vs. SCISSORS: LOSE SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN SCISSORS vs. PAPER: WIN */ OnJava8-Examples-1.0/enums/SecurityCategory.java000066400000000000000000000021001374004044700216670ustar00rootroot00000000000000// enums/SecurityCategory.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // More succinct subcategorization of enums import onjava.*; enum SecurityCategory { STOCK(Security.Stock.class), BOND(Security.Bond.class); Security[] values; SecurityCategory(Class kind) { values = kind.getEnumConstants(); } interface Security { enum Stock implements Security { SHORT, LONG, MARGIN } enum Bond implements Security { MUNICIPAL, JUNK } } public Security randomSelection() { return Enums.random(values); } public static void main(String[] args) { for(int i = 0; i < 10; i++) { SecurityCategory category = Enums.random(SecurityCategory.class); System.out.println(category + ": " + category.randomSelection()); } } } /* Output: BOND: MUNICIPAL BOND: MUNICIPAL STOCK: MARGIN STOCK: MARGIN BOND: JUNK STOCK: SHORT STOCK: LONG STOCK: LONG BOND: MUNICIPAL BOND: JUNK */ OnJava8-Examples-1.0/enums/SpaceShip.java000066400000000000000000000011641374004044700202520ustar00rootroot00000000000000// enums/SpaceShip.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public enum SpaceShip { SCOUT, CARGO, TRANSPORT, CRUISER, BATTLESHIP, MOTHERSHIP; @Override public String toString() { String id = name(); String lower = id.substring(1).toLowerCase(); return id.charAt(0) + lower; } public static void main(String[] args) { Stream.of(values()) .forEach(System.out::println); } } /* Output: Scout Cargo Transport Cruiser Battleship Mothership */ OnJava8-Examples-1.0/enums/SpicinessEnum.java000066400000000000000000000004161374004044700211570ustar00rootroot00000000000000// enums/SpicinessEnum.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package enums; public enum SpicinessEnum { NOT, MILD, MEDIUM, HOT, FLAMING } OnJava8-Examples-1.0/enums/TrafficLight.java000066400000000000000000000021601374004044700207360ustar00rootroot00000000000000// enums/TrafficLight.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Enums in switch statements // Define an enum type: enum Signal { GREEN, YELLOW, RED, } public class TrafficLight { Signal color = Signal.RED; public void change() { switch(color) { // Note you don't have to say Signal.RED // in the case statement: case RED: color = Signal.GREEN; break; case GREEN: color = Signal.YELLOW; break; case YELLOW: color = Signal.RED; break; } } @Override public String toString() { return "The traffic light is " + color; } public static void main(String[] args) { TrafficLight t = new TrafficLight(); for(int i = 0; i < 7; i++) { System.out.println(t); t.change(); } } } /* Output: The traffic light is RED The traffic light is GREEN The traffic light is YELLOW The traffic light is RED The traffic light is GREEN The traffic light is YELLOW The traffic light is RED */ OnJava8-Examples-1.0/enums/UpcastEnum.java000066400000000000000000000010571374004044700204600ustar00rootroot00000000000000// enums/UpcastEnum.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // No values() method if you upcast an enum enum Search { HITHER, YON } public class UpcastEnum { public static void main(String[] args) { Search[] vals = Search.values(); Enum e = Search.HITHER; // Upcast // e.values(); // No values() in Enum for(Enum en : e.getClass().getEnumConstants()) System.out.println(en); } } /* Output: HITHER YON */ OnJava8-Examples-1.0/enums/VendingMachine.java000066400000000000000000000106571374004044700212610ustar00rootroot00000000000000// enums/VendingMachine.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java VendingMachine VendingMachineInput.txt} import java.util.*; import java.io.IOException; import java.util.function.*; import java.nio.file.*; import java.util.stream.*; enum Category { MONEY(Input.NICKEL, Input.DIME, Input.QUARTER, Input.DOLLAR), ITEM_SELECTION(Input.TOOTHPASTE, Input.CHIPS, Input.SODA, Input.SOAP), QUIT_TRANSACTION(Input.ABORT_TRANSACTION), SHUT_DOWN(Input.STOP); private Input[] values; Category(Input... types) { values = types; } private static EnumMap categories = new EnumMap<>(Input.class); static { for(Category c : Category.class.getEnumConstants()) for(Input type : c.values) categories.put(type, c); } public static Category categorize(Input input) { return categories.get(input); } } public class VendingMachine { private static State state = State.RESTING; private static int amount = 0; private static Input selection = null; enum StateDuration { TRANSIENT } // Tagging enum enum State { RESTING { @Override void next(Input input) { switch(Category.categorize(input)) { case MONEY: amount += input.amount(); state = ADDING_MONEY; break; case SHUT_DOWN: state = TERMINAL; default: } } }, ADDING_MONEY { @Override void next(Input input) { switch(Category.categorize(input)) { case MONEY: amount += input.amount(); break; case ITEM_SELECTION: selection = input; if(amount < selection.amount()) System.out.println( "Insufficient money for " + selection); else state = DISPENSING; break; case QUIT_TRANSACTION: state = GIVING_CHANGE; break; case SHUT_DOWN: state = TERMINAL; default: } } }, DISPENSING(StateDuration.TRANSIENT) { @Override void next() { System.out.println("here is your " + selection); amount -= selection.amount(); state = GIVING_CHANGE; } }, GIVING_CHANGE(StateDuration.TRANSIENT) { @Override void next() { if(amount > 0) { System.out.println("Your change: " + amount); amount = 0; } state = RESTING; } }, TERMINAL {@Override void output() { System.out.println("Halted"); } }; private boolean isTransient = false; State() {} State(StateDuration trans) { isTransient = true; } void next(Input input) { throw new RuntimeException("Only call " + "next(Input input) for non-transient states"); } void next() { throw new RuntimeException( "Only call next() for " + "StateDuration.TRANSIENT states"); } void output() { System.out.println(amount); } } static void run(Supplier gen) { while(state != State.TERMINAL) { state.next(gen.get()); while(state.isTransient) state.next(); state.output(); } } public static void main(String[] args) { Supplier gen = new RandomInputSupplier(); if(args.length == 1) gen = new FileInputSupplier(args[0]); run(gen); } } // For a basic sanity check: class RandomInputSupplier implements Supplier { @Override public Input get() { return Input.randomSelection(); } } // Create Inputs from a file of ';'-separated strings: class FileInputSupplier implements Supplier { private Iterator input; FileInputSupplier(String fileName) { try { input = Files.lines(Paths.get(fileName)) .skip(1) // Skip the comment line .flatMap(s -> Arrays.stream(s.split(";"))) .map(String::trim) .collect(Collectors.toList()) .iterator(); } catch(IOException e) { throw new RuntimeException(e); } } @Override public Input get() { if(!input.hasNext()) return null; return Enum.valueOf( Input.class, input.next().trim()); } } /* Output: 25 50 75 here is your CHIPS 0 100 200 here is your TOOTHPASTE 0 25 35 Your change: 35 0 25 35 Insufficient money for SODA 35 60 70 75 Insufficient money for SODA 75 Your change: 75 0 Halted */ OnJava8-Examples-1.0/enums/VendingMachineInput.txt000066400000000000000000000003141374004044700221640ustar00rootroot00000000000000// enums/VendingMachineInput.txt QUARTER; QUARTER; QUARTER; CHIPS; DOLLAR; DOLLAR; TOOTHPASTE; QUARTER; DIME; ABORT_TRANSACTION; QUARTER; DIME; SODA; QUARTER; DIME; NICKEL; SODA; ABORT_TRANSACTION; STOP; OnJava8-Examples-1.0/enums/cartoons/000077500000000000000000000000001374004044700173565ustar00rootroot00000000000000OnJava8-Examples-1.0/enums/cartoons/EnumImplementation.java000066400000000000000000000017731374004044700240430ustar00rootroot00000000000000// enums/cartoons/EnumImplementation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An enum can implement an interface // {java enums.cartoons.EnumImplementation} package enums.cartoons; import java.util.*; import java.util.function.*; enum CartoonCharacter implements Supplier { SLAPPY, SPANKY, PUNCHY, SILLY, BOUNCY, NUTTY, BOB; private Random rand = new Random(47); @Override public CartoonCharacter get() { return values()[rand.nextInt(values().length)]; } } public class EnumImplementation { public static void printNext(Supplier rg) { System.out.print(rg.get() + ", "); } public static void main(String[] args) { // Choose any instance: CartoonCharacter cc = CartoonCharacter.BOB; for(int i = 0; i < 10; i++) printNext(cc); } } /* Output: BOB, PUNCHY, BOB, SPANKY, NUTTY, PUNCHY, SLAPPY, NUTTY, NUTTY, SLAPPY, */ OnJava8-Examples-1.0/enums/menu/000077500000000000000000000000001374004044700164725ustar00rootroot00000000000000OnJava8-Examples-1.0/enums/menu/Course.java000066400000000000000000000010661374004044700206000ustar00rootroot00000000000000// enums/menu/Course.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package enums.menu; import onjava.*; public enum Course { APPETIZER(Food.Appetizer.class), MAINCOURSE(Food.MainCourse.class), DESSERT(Food.Dessert.class), COFFEE(Food.Coffee.class); private Food[] values; private Course(Class kind) { values = kind.getEnumConstants(); } public Food randomSelection() { return Enums.random(values); } } OnJava8-Examples-1.0/enums/menu/Food.java000066400000000000000000000012431374004044700202240ustar00rootroot00000000000000// enums/menu/Food.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Subcategorization of enums within interfaces package enums.menu; public interface Food { enum Appetizer implements Food { SALAD, SOUP, SPRING_ROLLS; } enum MainCourse implements Food { LASAGNE, BURRITO, PAD_THAI, LENTILS, HUMMOUS, VINDALOO; } enum Dessert implements Food { TIRAMISU, GELATO, BLACK_FOREST_CAKE, FRUIT, CREME_CARAMEL; } enum Coffee implements Food { BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, LATTE, CAPPUCCINO, TEA, HERB_TEA; } } OnJava8-Examples-1.0/enums/menu/Meal.java000066400000000000000000000012671374004044700202210ustar00rootroot00000000000000// enums/menu/Meal.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java enums.menu.Meal} package enums.menu; public class Meal { public static void main(String[] args) { for(int i = 0; i < 5; i++) { for(Course course : Course.values()) { Food food = course.randomSelection(); System.out.println(food); } System.out.println("***"); } } } /* Output: SPRING_ROLLS VINDALOO FRUIT DECAF_COFFEE *** SOUP VINDALOO FRUIT TEA *** SALAD BURRITO FRUIT TEA *** SALAD BURRITO CREME_CARAMEL LATTE *** SOUP BURRITO TIRAMISU ESPRESSO *** */ OnJava8-Examples-1.0/enums/menu/Meal2.java000066400000000000000000000027061374004044700203020ustar00rootroot00000000000000// enums/menu/Meal2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java enums.menu.Meal2} package enums.menu; import onjava.*; public enum Meal2 { APPETIZER(Food.Appetizer.class), MAINCOURSE(Food.MainCourse.class), DESSERT(Food.Dessert.class), COFFEE(Food.Coffee.class); private Food[] values; private Meal2(Class kind) { values = kind.getEnumConstants(); } public interface Food { enum Appetizer implements Food { SALAD, SOUP, SPRING_ROLLS; } enum MainCourse implements Food { LASAGNE, BURRITO, PAD_THAI, LENTILS, HUMMOUS, VINDALOO; } enum Dessert implements Food { TIRAMISU, GELATO, BLACK_FOREST_CAKE, FRUIT, CREME_CARAMEL; } enum Coffee implements Food { BLACK_COFFEE, DECAF_COFFEE, ESPRESSO, LATTE, CAPPUCCINO, TEA, HERB_TEA; } } public Food randomSelection() { return Enums.random(values); } public static void main(String[] args) { for(int i = 0; i < 5; i++) { for(Meal2 meal : Meal2.values()) { Food food = meal.randomSelection(); System.out.println(food); } System.out.println("***"); } } } /* Output: SPRING_ROLLS VINDALOO FRUIT DECAF_COFFEE *** SOUP VINDALOO FRUIT TEA *** SALAD BURRITO FRUIT TEA *** SALAD BURRITO CREME_CARAMEL LATTE *** SOUP BURRITO TIRAMISU ESPRESSO *** */ OnJava8-Examples-1.0/enums/menu/TypeOfFood.java000066400000000000000000000007321374004044700213550ustar00rootroot00000000000000// enums/menu/TypeOfFood.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java enums.menu.TypeOfFood} package enums.menu; import static enums.menu.Food.*; public class TypeOfFood { public static void main(String[] args) { Food food = Appetizer.SALAD; food = MainCourse.LASAGNE; food = Dessert.GELATO; food = Coffee.CAPPUCCINO; } } OnJava8-Examples-1.0/equalshashcode/000077500000000000000000000000001374004044700173705ustar00rootroot00000000000000OnJava8-Examples-1.0/equalshashcode/ComposedEquality.java000066400000000000000000000032641374004044700235270ustar00rootroot00000000000000// equalshashcode/ComposedEquality.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class Part { String ss; double dd; Part(String ss, double dd) { this.ss = ss; this.dd = dd; } @Override public boolean equals(Object rval) { return rval instanceof Part && Objects.equals(ss, ((Part)rval).ss) && Objects.equals(dd, ((Part)rval).dd); } } public class ComposedEquality extends SuccinctEquality { Part part; public ComposedEquality(int i, String s, double d) { super(i, s, d); part = new Part(s, d); System.out.println("made 'ComposedEquality'"); } @Override public boolean equals(Object rval) { return rval instanceof ComposedEquality && super.equals(rval) && Objects.equals(part, ((ComposedEquality)rval).part); } public static void main(String[] args) { Equality.testAll( (i, s, d) -> new ComposedEquality(i, s, d)); } } /* Output: made 'Equality' made 'SuccinctEquality' made 'ComposedEquality' made 'Equality' made 'SuccinctEquality' made 'ComposedEquality' made 'Equality' made 'SuccinctEquality' made 'ComposedEquality' -- Testing null -- null instanceof Equality: false Expected false, got false -- Testing same object -- same object instanceof Equality: true Expected true, got true -- Testing different type -- different type instanceof Equality: false Expected false, got false -- Testing same values -- same values instanceof Equality: true Expected true, got true -- Testing different values -- different values instanceof Equality: true Expected false, got false */ OnJava8-Examples-1.0/equalshashcode/CountedString.java000066400000000000000000000040551374004044700230270ustar00rootroot00000000000000// equalshashcode/CountedString.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating a good hashCode() import java.util.*; public class CountedString { private static List created = new ArrayList<>(); private String s; private int id = 0; public CountedString(String str) { s = str; created.add(s); // id is the total number of instances // of this String used by CountedString: for(String s2 : created) if(s2.equals(s)) id++; } @Override public String toString() { return "String: " + s + " id: " + id + " hashCode(): " + hashCode(); } @Override public int hashCode() { // The very simple approach: // return s.hashCode() * id; // Using Joshua Bloch's recipe: int result = 17; result = 37 * result + s.hashCode(); result = 37 * result + id; return result; } @Override public boolean equals(Object o) { return o instanceof CountedString && Objects.equals(s, ((CountedString)o).s) && Objects.equals(id, ((CountedString)o).id); } public static void main(String[] args) { Map map = new HashMap<>(); CountedString[] cs = new CountedString[5]; for(int i = 0; i < cs.length; i++) { cs[i] = new CountedString("hi"); map.put(cs[i], i); // Autobox int to Integer } System.out.println(map); for(CountedString cstring : cs) { System.out.println("Looking up " + cstring); System.out.println(map.get(cstring)); } } } /* Output: {String: hi id: 4 hashCode(): 146450=3, String: hi id: 5 hashCode(): 146451=4, String: hi id: 2 hashCode(): 146448=1, String: hi id: 3 hashCode(): 146449=2, String: hi id: 1 hashCode(): 146447=0} Looking up String: hi id: 1 hashCode(): 146447 0 Looking up String: hi id: 2 hashCode(): 146448 1 Looking up String: hi id: 3 hashCode(): 146449 2 Looking up String: hi id: 4 hashCode(): 146450 3 Looking up String: hi id: 5 hashCode(): 146451 4 */ OnJava8-Examples-1.0/equalshashcode/DefaultComparison.java000066400000000000000000000011201374004044700236440ustar00rootroot00000000000000// equalshashcode/DefaultComparison.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class DefaultComparison { private int i, j, k; DefaultComparison(int i, int j, int k) { this.i = i; this.j = j; this.k = k; } public static void main(String[] args) { DefaultComparison a = new DefaultComparison(1, 2, 3), b = new DefaultComparison(1, 2, 3); System.out.println(a == a); System.out.println(a == b); } } /* Output: true false */ OnJava8-Examples-1.0/equalshashcode/Equality.java000066400000000000000000000041431374004044700220320ustar00rootroot00000000000000// equalshashcode/Equality.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class Equality { protected int i; protected String s; protected double d; public Equality(int i, String s, double d) { this.i = i; this.s = s; this.d = d; System.out.println("made 'Equality'"); } @Override public boolean equals(Object rval) { if(rval == null) return false; if(rval == this) return true; if(!(rval instanceof Equality)) return false; Equality other = (Equality)rval; if(!Objects.equals(i, other.i)) return false; if(!Objects.equals(s, other.s)) return false; if(!Objects.equals(d, other.d)) return false; return true; } public void test(String descr, String expected, Object rval) { System.out.format("-- Testing %s --%n" + "%s instanceof Equality: %s%n" + "Expected %s, got %s%n", descr, descr, rval instanceof Equality, expected, equals(rval)); } public static void testAll(EqualityFactory eqf) { Equality e = eqf.make(1, "Monty", 3.14), eq = eqf.make(1, "Monty", 3.14), neq = eqf.make(99, "Bob", 1.618); e.test("null", "false", null); e.test("same object", "true", e); e.test("different type", "false", Integer.valueOf(99)); e.test("same values", "true", eq); e.test("different values", "false", neq); } public static void main(String[] args) { testAll( (i, s, d) -> new Equality(i, s, d)); } } /* Output: made 'Equality' made 'Equality' made 'Equality' -- Testing null -- null instanceof Equality: false Expected false, got false -- Testing same object -- same object instanceof Equality: true Expected true, got true -- Testing different type -- different type instanceof Equality: false Expected false, got false -- Testing same values -- same values instanceof Equality: true Expected true, got true -- Testing different values -- different values instanceof Equality: true Expected false, got false */ OnJava8-Examples-1.0/equalshashcode/EqualityFactory.java000066400000000000000000000004501374004044700233570ustar00rootroot00000000000000// equalshashcode/EqualityFactory.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface EqualityFactory { Equality make(int i, String s, double d); } OnJava8-Examples-1.0/equalshashcode/Groundhog.java000066400000000000000000000006471374004044700221760ustar00rootroot00000000000000// equalshashcode/Groundhog.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Looks plausible, but doesn't work as a HashMap key public class Groundhog { protected int number; public Groundhog(int n) { number = n; } @Override public String toString() { return "Groundhog #" + number; } } OnJava8-Examples-1.0/equalshashcode/Groundhog2.java000066400000000000000000000011261374004044700222510ustar00rootroot00000000000000// equalshashcode/Groundhog2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A class that's used as a key in a HashMap // must override hashCode() and equals() import java.util.*; public class Groundhog2 extends Groundhog { public Groundhog2(int n) { super(n); } @Override public int hashCode() { return number; } @Override public boolean equals(Object o) { return o instanceof Groundhog2 && Objects.equals( number, ((Groundhog2)o).number); } } OnJava8-Examples-1.0/equalshashcode/IndividualTest.java000066400000000000000000000013271374004044700231660ustar00rootroot00000000000000// equalshashcode/IndividualTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import collections.MapOfList; import typeinfo.pets.*; import java.util.*; public class IndividualTest { public static void main(String[] args) { Set pets = new TreeSet<>(); for(List lp : MapOfList.petPeople.values()) for(Pet p : lp) pets.add(p); pets.forEach(System.out::println); } } /* Output: Cat Elsie May Cat Pinkola Cat Shackleton Cat Stanford Cymric Molly Dog Margrett Mutt Spot Pug Louie aka Louis Snorkelstein Dupree Rat Fizzy Rat Freckly Rat Fuzzy */ OnJava8-Examples-1.0/equalshashcode/MapEntry.java000066400000000000000000000020551374004044700217740ustar00rootroot00000000000000// equalshashcode/MapEntry.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A simple Map.Entry for sample Map implementations import java.util.*; public class MapEntry implements Map.Entry { private K key; private V value; public MapEntry(K key, V value) { this.key = key; this.value = value; } @Override public K getKey() { return key; } @Override public V getValue() { return value; } @Override public V setValue(V v) { V result = value; value = v; return result; } @Override public int hashCode() { return Objects.hash(key, value); } @SuppressWarnings("unchecked") @Override public boolean equals(Object rval) { return rval instanceof MapEntry && Objects.equals(key, ((MapEntry)rval).getKey()) && Objects.equals(value, ((MapEntry)rval).getValue()); } @Override public String toString() { return key + "=" + value; } } OnJava8-Examples-1.0/equalshashcode/Prediction.java000066400000000000000000000007001374004044700223300ustar00rootroot00000000000000// equalshashcode/Prediction.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Predicting the weather import java.util.*; public class Prediction { private static Random rand = new Random(47); @Override public String toString() { return rand.nextBoolean() ? "Six more weeks of Winter!" : "Early Spring!"; } } OnJava8-Examples-1.0/equalshashcode/SimpleHashMap.java000066400000000000000000000047121374004044700227320ustar00rootroot00000000000000// equalshashcode/SimpleHashMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A demonstration hashed Map import java.util.*; import onjava.*; public class SimpleHashMap extends AbstractMap { // Choose a prime number for the hash table // size, to achieve a uniform distribution: static final int SIZE = 997; // You can't have a physical array of generics, // but you can upcast to one: @SuppressWarnings("unchecked") LinkedList>[] buckets = new LinkedList[SIZE]; @Override public V put(K key, V value) { V oldValue = null; int index = Math.abs(key.hashCode()) % SIZE; if(buckets[index] == null) buckets[index] = new LinkedList<>(); LinkedList> bucket = buckets[index]; MapEntry pair = new MapEntry<>(key, value); boolean found = false; ListIterator> it = bucket.listIterator(); while(it.hasNext()) { MapEntry iPair = it.next(); if(iPair.getKey().equals(key)) { oldValue = iPair.getValue(); it.set(pair); // Replace old with new found = true; break; } } if(!found) buckets[index].add(pair); return oldValue; } @Override public V get(Object key) { int index = Math.abs(key.hashCode()) % SIZE; if(buckets[index] == null) return null; for(MapEntry iPair : buckets[index]) if(iPair.getKey().equals(key)) return iPair.getValue(); return null; } @Override public Set> entrySet() { Set> set= new HashSet<>(); for(LinkedList> bucket : buckets) { if(bucket == null) continue; for(MapEntry mpair : bucket) set.add(mpair); } return set; } public static void main(String[] args) { SimpleHashMap m = new SimpleHashMap<>(); m.putAll(Countries.capitals(8)); m.forEach((k, v) -> System.out.println(k + "=" + v)); System.out.println(m.get("BENIN")); m.entrySet().forEach(System.out::println); } } /* Output: CAMEROON=Yaounde ANGOLA=Luanda BURKINA FASO=Ouagadougou BURUNDI=Bujumbura ALGERIA=Algiers BENIN=Porto-Novo CAPE VERDE=Praia BOTSWANA=Gaberone Porto-Novo CAMEROON=Yaounde ANGOLA=Luanda BURKINA FASO=Ouagadougou BURUNDI=Bujumbura ALGERIA=Algiers BENIN=Porto-Novo CAPE VERDE=Praia BOTSWANA=Gaberone */ OnJava8-Examples-1.0/equalshashcode/SlowMap.java000066400000000000000000000032411374004044700216150ustar00rootroot00000000000000// equalshashcode/SlowMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A Map implemented with ArrayLists import java.util.*; import onjava.*; public class SlowMap extends AbstractMap { private List keys = new ArrayList<>(); private List values = new ArrayList<>(); @Override public V put(K key, V value) { V oldValue = get(key); // The old value or null if(!keys.contains(key)) { keys.add(key); values.add(value); } else values.set(keys.indexOf(key), value); return oldValue; } @Override public V get(Object key) { // key: type Object, not K if(!keys.contains(key)) return null; return values.get(keys.indexOf(key)); } @Override public Set> entrySet() { Set> set= new HashSet<>(); Iterator ki = keys.iterator(); Iterator vi = values.iterator(); while(ki.hasNext()) set.add(new MapEntry<>(ki.next(), vi.next())); return set; } public static void main(String[] args) { SlowMap m= new SlowMap<>(); m.putAll(Countries.capitals(8)); m.forEach((k, v) -> System.out.println(k + "=" + v)); System.out.println(m.get("BENIN")); m.entrySet().forEach(System.out::println); } } /* Output: CAMEROON=Yaounde ANGOLA=Luanda BURKINA FASO=Ouagadougou BURUNDI=Bujumbura ALGERIA=Algiers BENIN=Porto-Novo CAPE VERDE=Praia BOTSWANA=Gaberone Porto-Novo CAMEROON=Yaounde ANGOLA=Luanda BURKINA FASO=Ouagadougou BURUNDI=Bujumbura ALGERIA=Algiers BENIN=Porto-Novo CAPE VERDE=Praia BOTSWANA=Gaberone */ OnJava8-Examples-1.0/equalshashcode/SpringDetector.java000066400000000000000000000035431374004044700231740ustar00rootroot00000000000000// equalshashcode/SpringDetector.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // What will the weather be? import java.util.*; import java.util.stream.*; import java.util.function.*; import java.lang.reflect.*; public class SpringDetector { public static void detectSpring(Class type) { try { Constructor ghog = type.getConstructor(int.class); Map map = IntStream.range(0, 10) .mapToObj(i -> { try { return ghog.newInstance(i); } catch(Exception e) { throw new RuntimeException(e); } }) .collect(Collectors.toMap( Function.identity(), gh -> new Prediction())); map.forEach((k, v) -> System.out.println(k + ": " + v)); Groundhog gh = ghog.newInstance(3); System.out.println( "Looking up prediction for " + gh); if(map.containsKey(gh)) System.out.println(map.get(gh)); else System.out.println("Key not found: " + gh); } catch(NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) { throw new RuntimeException(e); } } public static void main(String[] args) { detectSpring(Groundhog.class); } } /* Output: Groundhog #3: Six more weeks of Winter! Groundhog #0: Early Spring! Groundhog #8: Six more weeks of Winter! Groundhog #6: Early Spring! Groundhog #4: Early Spring! Groundhog #2: Six more weeks of Winter! Groundhog #1: Early Spring! Groundhog #9: Early Spring! Groundhog #5: Six more weeks of Winter! Groundhog #7: Six more weeks of Winter! Looking up prediction for Groundhog #3 Key not found: Groundhog #3 */ OnJava8-Examples-1.0/equalshashcode/SpringDetector2.java000066400000000000000000000013651374004044700232560ustar00rootroot00000000000000// equalshashcode/SpringDetector2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A working key public class SpringDetector2 { public static void main(String[] args) { SpringDetector.detectSpring(Groundhog2.class); } } /* Output: Groundhog #0: Six more weeks of Winter! Groundhog #1: Early Spring! Groundhog #2: Six more weeks of Winter! Groundhog #3: Early Spring! Groundhog #4: Early Spring! Groundhog #5: Six more weeks of Winter! Groundhog #6: Early Spring! Groundhog #7: Early Spring! Groundhog #8: Six more weeks of Winter! Groundhog #9: Six more weeks of Winter! Looking up prediction for Groundhog #3 Early Spring! */ OnJava8-Examples-1.0/equalshashcode/StringHashCode.java000066400000000000000000000007041374004044700231010ustar00rootroot00000000000000// equalshashcode/StringHashCode.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class StringHashCode { public static void main(String[] args) { String[] hellos = "Hello Hello".split(" "); System.out.println(hellos[0].hashCode()); System.out.println(hellos[1].hashCode()); } } /* Output: 69609650 69609650 */ OnJava8-Examples-1.0/equalshashcode/SubtypeEquality.java000066400000000000000000000027271374004044700234140ustar00rootroot00000000000000// equalshashcode/SubtypeEquality.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; enum Size { SMALL, MEDIUM, LARGE } class Animal { private static int counter = 0; private final int id = counter++; private final String name; private final Size size; Animal(String name, Size size) { this.name = name; this.size = size; } @Override public boolean equals(Object rval) { return rval instanceof Animal && // Objects.equals(id, ((Animal)rval).id) && // [1] Objects.equals(name, ((Animal)rval).name) && Objects.equals(size, ((Animal)rval).size); } @Override public int hashCode() { return Objects.hash(name, size); // return Objects.hash(name, size, id); // [2] } @Override public String toString() { return String.format("%s[%d]: %s %s %x", getClass().getSimpleName(), id, name, size, hashCode()); } } class Dog extends Animal { Dog(String name, Size size) { super(name, size); } } class Pig extends Animal { Pig(String name, Size size) { super(name, size); } } public class SubtypeEquality { public static void main(String[] args) { Set pets = new HashSet<>(); pets.add(new Dog("Ralph", Size.MEDIUM)); pets.add(new Pig("Ralph", Size.MEDIUM)); pets.forEach(System.out::println); } } /* Output: Dog[0]: Ralph MEDIUM a752aeee */ OnJava8-Examples-1.0/equalshashcode/SubtypeEquality2.java000066400000000000000000000017051374004044700234710ustar00rootroot00000000000000// equalshashcode/SubtypeEquality2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class Dog2 extends Animal { Dog2(String name, Size size) { super(name, size); } @Override public boolean equals(Object rval) { return rval instanceof Dog2 && super.equals(rval); } } class Pig2 extends Animal { Pig2(String name, Size size) { super(name, size); } @Override public boolean equals(Object rval) { return rval instanceof Pig2 && super.equals(rval); } } public class SubtypeEquality2 { public static void main(String[] args) { Set pets = new HashSet<>(); pets.add(new Dog2("Ralph", Size.MEDIUM)); pets.add(new Pig2("Ralph", Size.MEDIUM)); pets.forEach(System.out::println); } } /* Output: Dog2[0]: Ralph MEDIUM a752aeee Pig2[1]: Ralph MEDIUM a752aeee */ OnJava8-Examples-1.0/equalshashcode/SuccinctEquality.java000066400000000000000000000025351374004044700235310ustar00rootroot00000000000000// equalshashcode/SuccinctEquality.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SuccinctEquality extends Equality { public SuccinctEquality(int i, String s, double d) { super(i, s, d); System.out.println("made 'SuccinctEquality'"); } @Override public boolean equals(Object rval) { return rval instanceof SuccinctEquality && Objects.equals(i, ((SuccinctEquality)rval).i) && Objects.equals(s, ((SuccinctEquality)rval).s) && Objects.equals(d, ((SuccinctEquality)rval).d); } public static void main(String[] args) { Equality.testAll( (i, s, d) -> new SuccinctEquality(i, s, d)); } } /* Output: made 'Equality' made 'SuccinctEquality' made 'Equality' made 'SuccinctEquality' made 'Equality' made 'SuccinctEquality' -- Testing null -- null instanceof Equality: false Expected false, got false -- Testing same object -- same object instanceof Equality: true Expected true, got true -- Testing different type -- different type instanceof Equality: false Expected false, got false -- Testing same values -- same values instanceof Equality: true Expected true, got true -- Testing different values -- different values instanceof Equality: true Expected false, got false */ OnJava8-Examples-1.0/exceptions/000077500000000000000000000000001374004044700165605ustar00rootroot00000000000000OnJava8-Examples-1.0/exceptions/AlwaysFinally.java000066400000000000000000000016401374004044700222030ustar00rootroot00000000000000// exceptions/AlwaysFinally.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Finally is always executed class FourException extends Exception {} public class AlwaysFinally { public static void main(String[] args) { System.out.println("Entering first try block"); try { System.out.println("Entering second try block"); try { throw new FourException(); } finally { System.out.println("finally in 2nd try block"); } } catch(FourException e) { System.out.println( "Caught FourException in 1st try block"); } finally { System.out.println("finally in 1st try block"); } } } /* Output: Entering first try block Entering second try block finally in 2nd try block Caught FourException in 1st try block finally in 1st try block */ OnJava8-Examples-1.0/exceptions/AutoCloseableDetails.java000066400000000000000000000013351374004044700234550ustar00rootroot00000000000000// exceptions/AutoCloseableDetails.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Reporter implements AutoCloseable { String name = getClass().getSimpleName(); Reporter() { System.out.println("Creating " + name); } public void close() { System.out.println("Closing " + name); } } class First extends Reporter {} class Second extends Reporter {} public class AutoCloseableDetails { public static void main(String[] args) { try( First f = new First(); Second s = new Second() ) { } } } /* Output: Creating First Creating Second Closing Second Closing First */ OnJava8-Examples-1.0/exceptions/BodyException.java000066400000000000000000000013131374004044700221750ustar00rootroot00000000000000// exceptions/BodyException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Third extends Reporter {} public class BodyException { public static void main(String[] args) { try( First f = new First(); Second s2 = new Second() ) { System.out.println("In body"); Third t = new Third(); new SecondExcept(); System.out.println("End of body"); } catch(CE e) { System.out.println("Caught: " + e); } } } /* Output: Creating First Creating Second In body Creating Third Creating SecondExcept Closing Second Closing First Caught: CE */ OnJava8-Examples-1.0/exceptions/Cleanup.java000066400000000000000000000014671374004044700210220ustar00rootroot00000000000000// exceptions/Cleanup.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Guaranteeing proper cleanup of a resource public class Cleanup { public static void main(String[] args) { try { InputFile in = new InputFile("Cleanup.java"); try { String s; int i = 1; while((s = in.getLine()) != null) ; // Perform line-by-line processing here... } catch(Exception e) { System.out.println("Caught Exception in main"); e.printStackTrace(System.out); } finally { in.dispose(); } } catch(Exception e) { System.out.println( "InputFile construction failed"); } } } /* Output: dispose() successful */ OnJava8-Examples-1.0/exceptions/CleanupIdiom.java000066400000000000000000000033371374004044700220020ustar00rootroot00000000000000// exceptions/CleanupIdiom.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Disposable objects must be followed by a try-finally class NeedsCleanup { // Construction can't fail private static long counter = 1; private final long id = counter++; public void dispose() { System.out.println( "NeedsCleanup " + id + " disposed"); } } class ConstructionException extends Exception {} class NeedsCleanup2 extends NeedsCleanup { // Construction can fail: NeedsCleanup2() throws ConstructionException {} } public class CleanupIdiom { public static void main(String[] args) { // [1]: NeedsCleanup nc1 = new NeedsCleanup(); try { // ... } finally { nc1.dispose(); } // [2]: // If construction cannot fail, // you can group objects: NeedsCleanup nc2 = new NeedsCleanup(); NeedsCleanup nc3 = new NeedsCleanup(); try { // ... } finally { nc3.dispose(); // Reverse order of construction nc2.dispose(); } // [3]: // If construction can fail you must guard each one: try { NeedsCleanup2 nc4 = new NeedsCleanup2(); try { NeedsCleanup2 nc5 = new NeedsCleanup2(); try { // ... } finally { nc5.dispose(); } } catch(ConstructionException e) { // nc5 const. System.out.println(e); } finally { nc4.dispose(); } } catch(ConstructionException e) { // nc4 const. System.out.println(e); } } } /* Output: NeedsCleanup 1 disposed NeedsCleanup 3 disposed NeedsCleanup 2 disposed NeedsCleanup 5 disposed NeedsCleanup 4 disposed */ OnJava8-Examples-1.0/exceptions/CloseExceptions.java000066400000000000000000000020651374004044700225350ustar00rootroot00000000000000// exceptions/CloseExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class CloseException extends Exception {} class Reporter2 implements AutoCloseable { String name = getClass().getSimpleName(); Reporter2() { System.out.println("Creating " + name); } public void close() throws CloseException { System.out.println("Closing " + name); } } class Closer extends Reporter2 { @Override public void close() throws CloseException { super.close(); throw new CloseException(); } } public class CloseExceptions { public static void main(String[] args) { try( First f = new First(); Closer c = new Closer(); Second s = new Second() ) { System.out.println("In body"); } catch(CloseException e) { System.out.println("Caught: " + e); } } } /* Output: Creating First Creating Closer Creating Second In body Closing Second Closing Closer Closing First Caught: CloseException */ OnJava8-Examples-1.0/exceptions/ConstructorException.java000066400000000000000000000013271374004044700236320ustar00rootroot00000000000000// exceptions/ConstructorException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class CE extends Exception {} class SecondExcept extends Reporter { SecondExcept() throws CE { super(); throw new CE(); } } public class ConstructorException { public static void main(String[] args) { try( First f = new First(); SecondExcept s = new SecondExcept(); Second s2 = new Second() ) { System.out.println("In body"); } catch(CE e) { System.out.println("Caught: " + e); } } } /* Output: Creating First Creating SecondExcept Closing First Caught: CE */ OnJava8-Examples-1.0/exceptions/DynamicFields.java000066400000000000000000000071401374004044700221400ustar00rootroot00000000000000// exceptions/DynamicFields.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A Class that dynamically adds fields to itself to // demonstrate exception chaining class DynamicFieldsException extends Exception {} public class DynamicFields { private Object[][] fields; public DynamicFields(int initialSize) { fields = new Object[initialSize][2]; for(int i = 0; i < initialSize; i++) fields[i] = new Object[] { null, null }; } @Override public String toString() { StringBuilder result = new StringBuilder(); for(Object[] obj : fields) { result.append(obj[0]); result.append(": "); result.append(obj[1]); result.append("\n"); } return result.toString(); } private int hasField(String id) { for(int i = 0; i < fields.length; i++) if(id.equals(fields[i][0])) return i; return -1; } private int getFieldNumber(String id) throws NoSuchFieldException { int fieldNum = hasField(id); if(fieldNum == -1) throw new NoSuchFieldException(); return fieldNum; } private int makeField(String id) { for(int i = 0; i < fields.length; i++) if(fields[i][0] == null) { fields[i][0] = id; return i; } // No empty fields. Add one: Object[][] tmp = new Object[fields.length + 1][2]; for(int i = 0; i < fields.length; i++) tmp[i] = fields[i]; for(int i = fields.length; i < tmp.length; i++) tmp[i] = new Object[] { null, null }; fields = tmp; // Recursive call with expanded fields: return makeField(id); } public Object getField(String id) throws NoSuchFieldException { return fields[getFieldNumber(id)][1]; } public Object setField(String id, Object value) throws DynamicFieldsException { if(value == null) { // Most exceptions don't have a "cause" // constructor. In these cases you must use // initCause(), available in all // Throwable subclasses. DynamicFieldsException dfe = new DynamicFieldsException(); dfe.initCause(new NullPointerException()); throw dfe; } int fieldNumber = hasField(id); if(fieldNumber == -1) fieldNumber = makeField(id); Object result = null; try { result = getField(id); // Get old value } catch(NoSuchFieldException e) { // Use constructor that takes "cause": throw new RuntimeException(e); } fields[fieldNumber][1] = value; return result; } public static void main(String[] args) { DynamicFields df = new DynamicFields(3); System.out.println(df); try { df.setField("d", "A value for d"); df.setField("number", 47); df.setField("number2", 48); System.out.println(df); df.setField("d", "A new value for d"); df.setField("number3", 11); System.out.println("df: " + df); System.out.println("df.getField(\"d\") : " + df.getField("d")); Object field = df.setField("d", null); // Exception } catch(NoSuchFieldException | DynamicFieldsException e) { e.printStackTrace(System.out); } } } /* Output: null: null null: null null: null d: A value for d number: 47 number2: 48 df: d: A new value for d number: 47 number2: 48 number3: 11 df.getField("d") : A new value for d DynamicFieldsException at DynamicFields.setField(DynamicFields.java:65) at DynamicFields.main(DynamicFields.java:97) Caused by: java.lang.NullPointerException at DynamicFields.setField(DynamicFields.java:67) ... 1 more */ OnJava8-Examples-1.0/exceptions/ExceptionMethods.java000066400000000000000000000017301374004044700227060ustar00rootroot00000000000000// exceptions/ExceptionMethods.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrating the Exception Methods public class ExceptionMethods { public static void main(String[] args) { try { throw new Exception("My Exception"); } catch(Exception e) { System.out.println("Caught Exception"); System.out.println( "getMessage():" + e.getMessage()); System.out.println("getLocalizedMessage():" + e.getLocalizedMessage()); System.out.println("toString():" + e); System.out.println("printStackTrace():"); e.printStackTrace(System.out); } } } /* Output: Caught Exception getMessage():My Exception getLocalizedMessage():My Exception toString():java.lang.Exception: My Exception printStackTrace(): java.lang.Exception: My Exception at ExceptionMethods.main(ExceptionMethods.java:7) */ OnJava8-Examples-1.0/exceptions/ExceptionSilencer.java000066400000000000000000000007111374004044700230450ustar00rootroot00000000000000// exceptions/ExceptionSilencer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ExceptionSilencer { public static void main(String[] args) { try { throw new RuntimeException(); } finally { // Using 'return' inside the finally block // will silence any thrown exception. return; } } } OnJava8-Examples-1.0/exceptions/ExtraFeatures.java000066400000000000000000000037671374004044700222220ustar00rootroot00000000000000// exceptions/ExtraFeatures.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Further embellishment of exception classes class MyException2 extends Exception { private int x; MyException2() {} MyException2(String msg) { super(msg); } MyException2(String msg, int x) { super(msg); this.x = x; } public int val() { return x; } @Override public String getMessage() { return "Detail Message: "+ x + " "+ super.getMessage(); } } public class ExtraFeatures { public static void f() throws MyException2 { System.out.println( "Throwing MyException2 from f()"); throw new MyException2(); } public static void g() throws MyException2 { System.out.println( "Throwing MyException2 from g()"); throw new MyException2("Originated in g()"); } public static void h() throws MyException2 { System.out.println( "Throwing MyException2 from h()"); throw new MyException2("Originated in h()", 47); } public static void main(String[] args) { try { f(); } catch(MyException2 e) { e.printStackTrace(System.out); } try { g(); } catch(MyException2 e) { e.printStackTrace(System.out); } try { h(); } catch(MyException2 e) { e.printStackTrace(System.out); System.out.println("e.val() = " + e.val()); } } } /* Output: Throwing MyException2 from f() MyException2: Detail Message: 0 null at ExtraFeatures.f(ExtraFeatures.java:24) at ExtraFeatures.main(ExtraFeatures.java:38) Throwing MyException2 from g() MyException2: Detail Message: 0 Originated in g() at ExtraFeatures.g(ExtraFeatures.java:29) at ExtraFeatures.main(ExtraFeatures.java:43) Throwing MyException2 from h() MyException2: Detail Message: 47 Originated in h() at ExtraFeatures.h(ExtraFeatures.java:34) at ExtraFeatures.main(ExtraFeatures.java:48) e.val() = 47 */ OnJava8-Examples-1.0/exceptions/FinallyWorks.java000066400000000000000000000015221374004044700220470ustar00rootroot00000000000000// exceptions/FinallyWorks.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The finally clause is always executed class ThreeException extends Exception {} public class FinallyWorks { static int count = 0; public static void main(String[] args) { while(true) { try { // Post-increment is zero first time: if(count++ == 0) throw new ThreeException(); System.out.println("No exception"); } catch(ThreeException e) { System.out.println("ThreeException"); } finally { System.out.println("In finally clause"); if(count == 2) break; // out of "while" } } } } /* Output: ThreeException In finally clause No exception In finally clause */ OnJava8-Examples-1.0/exceptions/FullConstructors.java000066400000000000000000000022661374004044700227640ustar00rootroot00000000000000// exceptions/FullConstructors.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class MyException extends Exception { MyException() {} MyException(String msg) { super(msg); } } public class FullConstructors { public static void f() throws MyException { System.out.println("Throwing MyException from f()"); throw new MyException(); } public static void g() throws MyException { System.out.println("Throwing MyException from g()"); throw new MyException("Originated in g()"); } public static void main(String[] args) { try { f(); } catch(MyException e) { e.printStackTrace(System.out); } try { g(); } catch(MyException e) { e.printStackTrace(System.out); } } } /* Output: Throwing MyException from f() MyException at FullConstructors.f(FullConstructors.java:11) at FullConstructors.main(FullConstructors.java:19) Throwing MyException from g() MyException: Originated in g() at FullConstructors.g(FullConstructors.java:15) at FullConstructors.main(FullConstructors.java:24) */ OnJava8-Examples-1.0/exceptions/Human.java000066400000000000000000000013731374004044700204770ustar00rootroot00000000000000// exceptions/Human.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Catching exception hierarchies class Annoyance extends Exception {} class Sneeze extends Annoyance {} public class Human { public static void main(String[] args) { // Catch the exact type: try { throw new Sneeze(); } catch(Sneeze s) { System.out.println("Caught Sneeze"); } catch(Annoyance a) { System.out.println("Caught Annoyance"); } // Catch the base type: try { throw new Sneeze(); } catch(Annoyance a) { System.out.println("Caught Annoyance"); } } } /* Output: Caught Sneeze Caught Annoyance */ OnJava8-Examples-1.0/exceptions/InheritingExceptions.java000066400000000000000000000013361374004044700235700ustar00rootroot00000000000000// exceptions/InheritingExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating your own exceptions class SimpleException extends Exception {} public class InheritingExceptions { public void f() throws SimpleException { System.out.println( "Throw SimpleException from f()"); throw new SimpleException(); } public static void main(String[] args) { InheritingExceptions sed = new InheritingExceptions(); try { sed.f(); } catch(SimpleException e) { System.out.println("Caught it!"); } } } /* Output: Throw SimpleException from f() Caught it! */ OnJava8-Examples-1.0/exceptions/InputFile.java000066400000000000000000000024151374004044700213240ustar00rootroot00000000000000// exceptions/InputFile.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Paying attention to exceptions in constructors import java.io.*; public class InputFile { private BufferedReader in; public InputFile(String fname) throws Exception { try { in = new BufferedReader(new FileReader(fname)); // Other code that might throw exceptions } catch(FileNotFoundException e) { System.out.println("Could not open " + fname); // Wasn't open, so don't close it throw e; } catch(Exception e) { // All other exceptions must close it try { in.close(); } catch(IOException e2) { System.out.println("in.close() unsuccessful"); } throw e; // Rethrow } finally { // Don't close it here!!! } } public String getLine() { String s; try { s = in.readLine(); } catch(IOException e) { throw new RuntimeException("readLine() failed"); } return s; } public void dispose() { try { in.close(); System.out.println("dispose() successful"); } catch(IOException e2) { throw new RuntimeException("in.close() failed"); } } } OnJava8-Examples-1.0/exceptions/InputFile2.java000066400000000000000000000013251374004044700214050ustar00rootroot00000000000000// exceptions/InputFile2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.nio.file.*; import java.util.stream.*; public class InputFile2 { private String fname; public InputFile2(String fname) { this.fname = fname; } public Stream getLines() throws IOException { return Files.lines(Paths.get(fname)); } public static void main(String[] args) throws IOException { new InputFile2("InputFile2.java").getLines() .skip(15) .limit(1) .forEach(System.out::println); } } /* Output: main(String[] args) throws IOException { */ OnJava8-Examples-1.0/exceptions/LoggingExceptions.java000066400000000000000000000024031374004044700230520ustar00rootroot00000000000000// exceptions/LoggingExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An exception that reports through a Logger // {ErrorOutputExpected} import java.util.logging.*; import java.io.*; class LoggingException extends Exception { private static Logger logger = Logger.getLogger("LoggingException"); LoggingException() { StringWriter trace = new StringWriter(); printStackTrace(new PrintWriter(trace)); logger.severe(trace.toString()); } } public class LoggingExceptions { public static void main(String[] args) { try { throw new LoggingException(); } catch(LoggingException e) { System.err.println("Caught " + e); } try { throw new LoggingException(); } catch(LoggingException e) { System.err.println("Caught " + e); } } } /* Output: ___[ Error Output ]___ May 09, 2017 6:07:17 AM LoggingException SEVERE: LoggingException at LoggingExceptions.main(LoggingExceptions.java:20) Caught LoggingException May 09, 2017 6:07:17 AM LoggingException SEVERE: LoggingException at LoggingExceptions.main(LoggingExceptions.java:25) Caught LoggingException */ OnJava8-Examples-1.0/exceptions/LoggingExceptions2.java000066400000000000000000000016641374004044700231440ustar00rootroot00000000000000// exceptions/LoggingExceptions2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Logging caught exceptions // {ErrorOutputExpected} import java.util.logging.*; import java.io.*; public class LoggingExceptions2 { private static Logger logger = Logger.getLogger("LoggingExceptions2"); static void logException(Exception e) { StringWriter trace = new StringWriter(); e.printStackTrace(new PrintWriter(trace)); logger.severe(trace.toString()); } public static void main(String[] args) { try { throw new NullPointerException(); } catch(NullPointerException e) { logException(e); } } } /* Output: ___[ Error Output ]___ May 09, 2017 6:07:17 AM LoggingExceptions2 logException SEVERE: java.lang.NullPointerException at LoggingExceptions2.main(LoggingExceptions2.java:17) */ OnJava8-Examples-1.0/exceptions/LostMessage.java000066400000000000000000000017421374004044700216550ustar00rootroot00000000000000// exceptions/LostMessage.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // How an exception can be lost class VeryImportantException extends Exception { @Override public String toString() { return "A very important exception!"; } } class HoHumException extends Exception { @Override public String toString() { return "A trivial exception"; } } public class LostMessage { void f() throws VeryImportantException { throw new VeryImportantException(); } void dispose() throws HoHumException { throw new HoHumException(); } public static void main(String[] args) { try { LostMessage lm = new LostMessage(); try { lm.f(); } finally { lm.dispose(); } } catch(VeryImportantException | HoHumException e) { System.out.println(e); } } } /* Output: A trivial exception */ OnJava8-Examples-1.0/exceptions/MainException.java000066400000000000000000000007711374004044700221730ustar00rootroot00000000000000// exceptions/MainException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.nio.file.*; public class MainException { // Pass exceptions to the console: public static void main(String[] args) throws Exception { // Open the file: List lines = Files.readAllLines( Paths.get("MainException.java")); // Use the file ... } } OnJava8-Examples-1.0/exceptions/MessyExceptions.java000066400000000000000000000012631374004044700225670ustar00rootroot00000000000000// exceptions/MessyExceptions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; public class MessyExceptions { public static void main(String[] args) { InputStream in = null; try { in = new FileInputStream( new File("MessyExceptions.java")); int contents = in.read(); // Process contents } catch(IOException e) { // Handle the error } finally { if(in != null) { try { in.close(); } catch(IOException e) { // Handle the close() error } } } } } OnJava8-Examples-1.0/exceptions/MultiCatch.java000066400000000000000000000006351374004044700214640ustar00rootroot00000000000000// exceptions/MultiCatch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class MultiCatch { void x() throws Except1, Except2, Except3, Except4 {} void process() {} void f() { try { x(); } catch(Except1 | Except2 | Except3 | Except4 e) { process(); } } } OnJava8-Examples-1.0/exceptions/MultiCatch2.java000066400000000000000000000007271374004044700215500ustar00rootroot00000000000000// exceptions/MultiCatch2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class MultiCatch2 { void x() throws Except1, Except2, Except3, Except4 {} void process1() {} void process2() {} void f() { try { x(); } catch(Except1 | Except2 e) { process1(); } catch(Except3 | Except4 e) { process2(); } } } OnJava8-Examples-1.0/exceptions/MultipleReturns.java000066400000000000000000000020401374004044700225750ustar00rootroot00000000000000// exceptions/MultipleReturns.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class MultipleReturns { public static void f(int i) { System.out.println( "Initialization that requires cleanup"); try { System.out.println("Point 1"); if(i == 1) return; System.out.println("Point 2"); if(i == 2) return; System.out.println("Point 3"); if(i == 3) return; System.out.println("End"); return; } finally { System.out.println("Performing cleanup"); } } public static void main(String[] args) { for(int i = 1; i <= 4; i++) f(i); } } /* Output: Initialization that requires cleanup Point 1 Performing cleanup Initialization that requires cleanup Point 1 Point 2 Performing cleanup Initialization that requires cleanup Point 1 Point 2 Point 3 Performing cleanup Initialization that requires cleanup Point 1 Point 2 Point 3 End Performing cleanup */ OnJava8-Examples-1.0/exceptions/NeverCaught.java000066400000000000000000000012401374004044700216330ustar00rootroot00000000000000// exceptions/NeverCaught.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Ignoring RuntimeExceptions // {ThrowsException} public class NeverCaught { static void f() { throw new RuntimeException("From f()"); } static void g() { f(); } public static void main(String[] args) { g(); } } /* Output: ___[ Error Output ]___ Exception in thread "main" java.lang.RuntimeException: From f() at NeverCaught.f(NeverCaught.java:7) at NeverCaught.g(NeverCaught.java:10) at NeverCaught.main(NeverCaught.java:13) */ OnJava8-Examples-1.0/exceptions/OnOffException1.java000066400000000000000000000003671374004044700224000ustar00rootroot00000000000000// exceptions/OnOffException1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class OnOffException1 extends Exception {} OnJava8-Examples-1.0/exceptions/OnOffException2.java000066400000000000000000000003671374004044700224010ustar00rootroot00000000000000// exceptions/OnOffException2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class OnOffException2 extends Exception {} OnJava8-Examples-1.0/exceptions/OnOffSwitch.java000066400000000000000000000013111374004044700216100ustar00rootroot00000000000000// exceptions/OnOffSwitch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Why use finally? public class OnOffSwitch { private static Switch sw = new Switch(); public static void f() throws OnOffException1, OnOffException2 {} public static void main(String[] args) { try { sw.on(); // Code that can throw exceptions... f(); sw.off(); } catch(OnOffException1 e) { System.out.println("OnOffException1"); sw.off(); } catch(OnOffException2 e) { System.out.println("OnOffException2"); sw.off(); } } } /* Output: on off */ OnJava8-Examples-1.0/exceptions/PreciseRethrow.java000066400000000000000000000007201374004044700223670ustar00rootroot00000000000000// exceptions/PreciseRethrow.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class BaseException extends Exception {} class DerivedException extends BaseException {} public class PreciseRethrow { void catcher() throws DerivedException { try { throw new DerivedException(); } catch(BaseException e) { throw e; } } } OnJava8-Examples-1.0/exceptions/RethrowNew.java000066400000000000000000000025361374004044700215350ustar00rootroot00000000000000// exceptions/RethrowNew.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Rethrow a different object from the one you caught class OneException extends Exception { OneException(String s) { super(s); } } class TwoException extends Exception { TwoException(String s) { super(s); } } public class RethrowNew { public static void f() throws OneException { System.out.println( "originating the exception in f()"); throw new OneException("thrown from f()"); } public static void main(String[] args) { try { try { f(); } catch(OneException e) { System.out.println( "Caught in inner try, e.printStackTrace()"); e.printStackTrace(System.out); throw new TwoException("from inner try"); } } catch(TwoException e) { System.out.println( "Caught in outer try, e.printStackTrace()"); e.printStackTrace(System.out); } } } /* Output: originating the exception in f() Caught in inner try, e.printStackTrace() OneException: thrown from f() at RethrowNew.f(RethrowNew.java:16) at RethrowNew.main(RethrowNew.java:21) Caught in outer try, e.printStackTrace() TwoException: from inner try at RethrowNew.main(RethrowNew.java:26) */ OnJava8-Examples-1.0/exceptions/Rethrowing.java000066400000000000000000000040161374004044700215540ustar00rootroot00000000000000// exceptions/Rethrowing.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrating fillInStackTrace() public class Rethrowing { public static void f() throws Exception { System.out.println( "originating the exception in f()"); throw new Exception("thrown from f()"); } public static void g() throws Exception { try { f(); } catch(Exception e) { System.out.println( "Inside g(), e.printStackTrace()"); e.printStackTrace(System.out); throw e; } } public static void h() throws Exception { try { f(); } catch(Exception e) { System.out.println( "Inside h(), e.printStackTrace()"); e.printStackTrace(System.out); throw (Exception)e.fillInStackTrace(); } } public static void main(String[] args) { try { g(); } catch(Exception e) { System.out.println("main: printStackTrace()"); e.printStackTrace(System.out); } try { h(); } catch(Exception e) { System.out.println("main: printStackTrace()"); e.printStackTrace(System.out); } } } /* Output: originating the exception in f() Inside g(), e.printStackTrace() java.lang.Exception: thrown from f() at Rethrowing.f(Rethrowing.java:8) at Rethrowing.g(Rethrowing.java:12) at Rethrowing.main(Rethrowing.java:32) main: printStackTrace() java.lang.Exception: thrown from f() at Rethrowing.f(Rethrowing.java:8) at Rethrowing.g(Rethrowing.java:12) at Rethrowing.main(Rethrowing.java:32) originating the exception in f() Inside h(), e.printStackTrace() java.lang.Exception: thrown from f() at Rethrowing.f(Rethrowing.java:8) at Rethrowing.h(Rethrowing.java:22) at Rethrowing.main(Rethrowing.java:38) main: printStackTrace() java.lang.Exception: thrown from f() at Rethrowing.h(Rethrowing.java:27) at Rethrowing.main(Rethrowing.java:38) */ OnJava8-Examples-1.0/exceptions/SameHandler.java000066400000000000000000000014101374004044700216020ustar00rootroot00000000000000// exceptions/SameHandler.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class EBase1 extends Exception {} class Except1 extends EBase1 {} class EBase2 extends Exception {} class Except2 extends EBase2 {} class EBase3 extends Exception {} class Except3 extends EBase3 {} class EBase4 extends Exception {} class Except4 extends EBase4 {} public class SameHandler { void x() throws Except1, Except2, Except3, Except4 {} void process() {} void f() { try { x(); } catch(Except1 e) { process(); } catch(Except2 e) { process(); } catch(Except3 e) { process(); } catch(Except4 e) { process(); } } } OnJava8-Examples-1.0/exceptions/StormyInning.java000066400000000000000000000052411374004044700220650ustar00rootroot00000000000000// exceptions/StormyInning.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Overridden methods can throw only the exceptions // specified in their base-class versions, or exceptions // derived from the base-class exceptions class BaseballException extends Exception {} class Foul extends BaseballException {} class Strike extends BaseballException {} abstract class Inning { Inning() throws BaseballException {} public void event() throws BaseballException { // Doesn't actually have to throw anything } public abstract void atBat() throws Strike, Foul; public void walk() {} // Throws no checked exceptions } class StormException extends Exception {} class RainedOut extends StormException {} class PopFoul extends Foul {} interface Storm { void event() throws RainedOut; void rainHard() throws RainedOut; } public class StormyInning extends Inning implements Storm { // OK to add new exceptions for constructors, but you // must deal with the base constructor exceptions: public StormyInning() throws RainedOut, BaseballException {} public StormyInning(String s) throws BaseballException {} // Regular methods must conform to base class: //- void walk() throws PopFoul {} //Compile error // Interface CANNOT add exceptions to existing // methods from the base class: //- public void event() throws RainedOut {} // If the method doesn't already exist in the // base class, the exception is OK: @Override public void rainHard() throws RainedOut {} // You can choose to not throw any exceptions, // even if the base version does: @Override public void event() {} // Overridden methods can throw inherited exceptions: @Override public void atBat() throws PopFoul {} public static void main(String[] args) { try { StormyInning si = new StormyInning(); si.atBat(); } catch(PopFoul e) { System.out.println("Pop foul"); } catch(RainedOut e) { System.out.println("Rained out"); } catch(BaseballException e) { System.out.println("Generic baseball exception"); } // Strike not thrown in derived version. try { // What happens if you upcast? Inning i = new StormyInning(); i.atBat(); // You must catch the exceptions from the // base-class version of the method: } catch(Strike e) { System.out.println("Strike"); } catch(Foul e) { System.out.println("Foul"); } catch(RainedOut e) { System.out.println("Rained out"); } catch(BaseballException e) { System.out.println("Generic baseball exception"); } } } OnJava8-Examples-1.0/exceptions/StreamsAreAutoCloseable.java000066400000000000000000000012641374004044700241370ustar00rootroot00000000000000// exceptions/StreamsAreAutoCloseable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.nio.file.*; import java.util.stream.*; public class StreamsAreAutoCloseable { public static void main(String[] args) throws IOException{ try( Stream in = Files.lines( Paths.get("StreamsAreAutoCloseable.java")); PrintWriter outfile = new PrintWriter( "Results.txt"); // [1] ) { in.skip(5) .limit(1) .map(String::toLowerCase) .forEachOrdered(outfile::println); } // [2] } } OnJava8-Examples-1.0/exceptions/Switch.java000066400000000000000000000010021374004044700206550ustar00rootroot00000000000000// exceptions/Switch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Switch { private boolean state = false; public boolean read() { return state; } public void on() { state = true; System.out.println(this); } public void off() { state = false; System.out.println(this); } @Override public String toString() { return state ? "on" : "off"; } } OnJava8-Examples-1.0/exceptions/TryAnything.java000066400000000000000000000005561374004044700217110ustar00rootroot00000000000000// exceptions/TryAnything.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} class Anything {} public class TryAnything { public static void main(String[] args) { try( Anything a = new Anything() ) { } } } OnJava8-Examples-1.0/exceptions/TryWithResources.java000066400000000000000000000010111374004044700227210ustar00rootroot00000000000000// exceptions/TryWithResources.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; public class TryWithResources { public static void main(String[] args) { try( InputStream in = new FileInputStream( new File("TryWithResources.java")) ) { int contents = in.read(); // Process contents } catch(IOException e) { // Handle the error } } } OnJava8-Examples-1.0/exceptions/TurnOffChecking.java000066400000000000000000000035611374004044700224470ustar00rootroot00000000000000// exceptions/TurnOffChecking.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // "Turning off" Checked exceptions import java.io.*; class WrapCheckedException { void throwRuntimeException(int type) { try { switch(type) { case 0: throw new FileNotFoundException(); case 1: throw new IOException(); case 2: throw new RuntimeException("Where am I?"); default: return; } } catch(IOException | RuntimeException e) { // Adapt to unchecked: throw new RuntimeException(e); } } } class SomeOtherException extends Exception {} public class TurnOffChecking { public static void main(String[] args) { WrapCheckedException wce = new WrapCheckedException(); // You can call throwRuntimeException() without // a try block, and let RuntimeExceptions // leave the method: wce.throwRuntimeException(3); // Or you can choose to catch exceptions: for(int i = 0; i < 4; i++) try { if(i < 3) wce.throwRuntimeException(i); else throw new SomeOtherException(); } catch(SomeOtherException e) { System.out.println( "SomeOtherException: " + e); } catch(RuntimeException re) { try { throw re.getCause(); } catch(FileNotFoundException e) { System.out.println( "FileNotFoundException: " + e); } catch(IOException e) { System.out.println("IOException: " + e); } catch(Throwable e) { System.out.println("Throwable: " + e); } } } } /* Output: FileNotFoundException: java.io.FileNotFoundException IOException: java.io.IOException Throwable: java.lang.RuntimeException: Where am I? SomeOtherException: SomeOtherException */ OnJava8-Examples-1.0/exceptions/WhoCalled.java000066400000000000000000000014121374004044700212630ustar00rootroot00000000000000// exceptions/WhoCalled.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Programmatic access to stack trace information public class WhoCalled { static void f() { // Generate an exception to fill in the stack trace try { throw new Exception(); } catch(Exception e) { for(StackTraceElement ste : e.getStackTrace()) System.out.println(ste.getMethodName()); } } static void g() { f(); } static void h() { g(); } public static void main(String[] args) { f(); System.out.println("*******"); g(); System.out.println("*******"); h(); } } /* Output: f main ******* f g main ******* f g h main */ OnJava8-Examples-1.0/exceptions/WithFinally.java000066400000000000000000000012011374004044700216470ustar00rootroot00000000000000// exceptions/WithFinally.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Finally Guarantees cleanup public class WithFinally { static Switch sw = new Switch(); public static void main(String[] args) { try { sw.on(); // Code that can throw exceptions... OnOffSwitch.f(); } catch(OnOffException1 e) { System.out.println("OnOffException1"); } catch(OnOffException2 e) { System.out.println("OnOffException2"); } finally { sw.off(); } } } /* Output: on off */ OnJava8-Examples-1.0/files/000077500000000000000000000000001374004044700155015ustar00rootroot00000000000000OnJava8-Examples-1.0/files/AddAndSubtractPaths.java000066400000000000000000000052361374004044700221750ustar00rootroot00000000000000// files/AddAndSubtractPaths.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; import java.io.IOException; public class AddAndSubtractPaths { static Path base = Paths.get("..", "..", "..") .toAbsolutePath() .normalize(); static void show(int id, Path result) { if(result.isAbsolute()) System.out.println("(" + id + ")r " + base.relativize(result)); else System.out.println("(" + id + ") " + result); try { System.out.println("RealPath: " + result.toRealPath()); } catch(IOException e) { System.out.println(e); } } public static void main(String[] args) { System.out.println(System.getProperty("os.name")); System.out.println(base); Path p = Paths.get("AddAndSubtractPaths.java") .toAbsolutePath(); show(1, p); Path convoluted = p.getParent().getParent() .resolve("strings") .resolve("..") .resolve(p.getParent().getFileName()); show(2, convoluted); show(3, convoluted.normalize()); Path p2 = Paths.get("..", ".."); show(4, p2); show(5, p2.normalize()); show(6, p2.toAbsolutePath().normalize()); Path p3 = Paths.get(".").toAbsolutePath(); Path p4 = p3.resolve(p2); show(7, p4); show(8, p4.normalize()); Path p5 = Paths.get("").toAbsolutePath(); show(9, p5); show(10, p5.resolveSibling("strings")); show(11, Paths.get("nonexistent")); } } /* Output: Windows 10 C:\Users\Bruce\Documents\GitHub (1)r on- java\ExtractedExamples\files\AddAndSubtractPaths.java RealPath: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files\AddAndSubtractPaths.java (2)r on-java\ExtractedExamples\strings\..\files RealPath: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files (3)r on-java\ExtractedExamples\files RealPath: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files (4) ..\.. RealPath: C:\Users\Bruce\Documents\GitHub\on-java (5) ..\.. RealPath: C:\Users\Bruce\Documents\GitHub\on-java (6)r on-java RealPath: C:\Users\Bruce\Documents\GitHub\on-java (7)r on-java\ExtractedExamples\files\.\..\.. RealPath: C:\Users\Bruce\Documents\GitHub\on-java (8)r on-java RealPath: C:\Users\Bruce\Documents\GitHub\on-java (9)r on-java\ExtractedExamples\files RealPath: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files (10)r on-java\ExtractedExamples\strings RealPath: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\strings (11) nonexistent java.nio.file.NoSuchFileException: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files\nonexistent */ OnJava8-Examples-1.0/files/Directories.java000066400000000000000000000047641374004044700206330ustar00rootroot00000000000000// files/Directories.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.nio.file.*; import onjava.RmDir; public class Directories { static Path test = Paths.get("test"); static String sep = FileSystems.getDefault().getSeparator(); static List parts = Arrays.asList("foo", "bar", "baz", "bag"); static Path makeVariant() { Collections.rotate(parts, 1); return Paths.get("test", String.join(sep, parts)); } static void refreshTestDir() throws Exception { if(Files.exists(test)) RmDir.rmdir(test); if(!Files.exists(test)) Files.createDirectory(test); } public static void main(String[] args) throws Exception { refreshTestDir(); Files.createFile(test.resolve("Hello.txt")); Path variant = makeVariant(); // Throws exception (too many levels): try { Files.createDirectory(variant); } catch(Exception e) { System.out.println("Nope, that doesn't work."); } populateTestDir(); Path tempdir = Files.createTempDirectory(test, "DIR_"); Files.createTempFile(tempdir, "pre", ".non"); Files.newDirectoryStream(test) .forEach(System.out::println); System.out.println("*********"); Files.walk(test).forEach(System.out::println); } static void populateTestDir() throws Exception { for(int i = 0; i < parts.size(); i++) { Path variant = makeVariant(); if(!Files.exists(variant)) { Files.createDirectories(variant); Files.copy(Paths.get("Directories.java"), variant.resolve("File.txt")); Files.createTempFile(variant, null, null); } } } } /* Output: Nope, that doesn't work. test\bag test\bar test\baz test\DIR_5142667942049986036 test\foo test\Hello.txt ********* test test\bag test\bag\foo test\bag\foo\bar test\bag\foo\bar\baz test\bag\foo\bar\baz\8279660869874696036.tmp test\bag\foo\bar\baz\File.txt test\bar test\bar\baz test\bar\baz\bag test\bar\baz\bag\foo test\bar\baz\bag\foo\1274043134240426261.tmp test\bar\baz\bag\foo\File.txt test\baz test\baz\bag test\baz\bag\foo test\baz\bag\foo\bar test\baz\bag\foo\bar\6130572530014544105.tmp test\baz\bag\foo\bar\File.txt test\DIR_5142667942049986036 test\DIR_5142667942049986036\pre7704286843227113253.non test\foo test\foo\bar test\foo\bar\baz test\foo\bar\baz\bag test\foo\bar\baz\bag\5412864507741775436.tmp test\foo\bar\baz\bag\File.txt test\Hello.txt */ OnJava8-Examples-1.0/files/FileSystemDemo.java000066400000000000000000000024231374004044700212360ustar00rootroot00000000000000// files/FileSystemDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; public class FileSystemDemo { static void show(String id, Object o) { System.out.println(id + ": " + o); } public static void main(String[] args) { System.out.println(System.getProperty("os.name")); FileSystem fsys = FileSystems.getDefault(); for(FileStore fs : fsys.getFileStores()) show("File Store", fs); for(Path rd : fsys.getRootDirectories()) show("Root Directory", rd); show("Separator", fsys.getSeparator()); show("UserPrincipalLookupService", fsys.getUserPrincipalLookupService()); show("isOpen", fsys.isOpen()); show("isReadOnly", fsys.isReadOnly()); show("FileSystemProvider", fsys.provider()); show("File Attribute Views", fsys.supportedFileAttributeViews()); } } /* Output: Windows 10 File Store: SSD (C:) Root Directory: C:\ Root Directory: D:\ Separator: \ UserPrincipalLookupService: sun.nio.fs.WindowsFileSystem$LookupService$1@15db9742 isOpen: true isReadOnly: false FileSystemProvider: sun.nio.fs.WindowsFileSystemProvider@6d06d69c File Attribute Views: [owner, dos, acl, basic, user] */ OnJava8-Examples-1.0/files/Find.java000066400000000000000000000033151374004044700172260ustar00rootroot00000000000000// files/Find.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromGradle} import java.nio.file.*; public class Find { public static void main(String[] args) throws Exception { Path test = Paths.get("test"); Directories.refreshTestDir(); Directories.populateTestDir(); // Creating a *directory*, not a file: Files.createDirectory(test.resolve("dir.tmp")); PathMatcher matcher = FileSystems.getDefault() .getPathMatcher("glob:**/*.{tmp,txt}"); Files.walk(test) .filter(matcher::matches) .forEach(System.out::println); System.out.println("***************"); PathMatcher matcher2 = FileSystems.getDefault() .getPathMatcher("glob:*.tmp"); Files.walk(test) .map(Path::getFileName) .filter(matcher2::matches) .forEach(System.out::println); System.out.println("***************"); Files.walk(test) // Only look for files .filter(Files::isRegularFile) .map(Path::getFileName) .filter(matcher2::matches) .forEach(System.out::println); } } /* Output: test\bag\foo\bar\baz\5208762845883213974.tmp test\bag\foo\bar\baz\File.txt test\bar\baz\bag\foo\7918367201207778677.tmp test\bar\baz\bag\foo\File.txt test\baz\bag\foo\bar\8016595521026696632.tmp test\baz\bag\foo\bar\File.txt test\dir.tmp test\foo\bar\baz\bag\5832319279813617280.tmp test\foo\bar\baz\bag\File.txt *************** 5208762845883213974.tmp 7918367201207778677.tmp 8016595521026696632.tmp dir.tmp 5832319279813617280.tmp *************** 5208762845883213974.tmp 7918367201207778677.tmp 8016595521026696632.tmp 5832319279813617280.tmp */ OnJava8-Examples-1.0/files/ListOfLines.java000066400000000000000000000012201374004044700205320ustar00rootroot00000000000000// files/ListOfLines.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.nio.file.*; public class ListOfLines { public static void main(String[] args) throws Exception { Files.readAllLines( Paths.get("../streams/Cheese.dat")) .stream() .filter(line -> !line.startsWith("//")) .map(line -> line.substring(0, line.length()/2)) .forEach(System.out::println); } } /* Output: Not much of a cheese Finest in the And what leads you Well, it's It's certainly uncon */ OnJava8-Examples-1.0/files/PartsOfPaths.java000066400000000000000000000022251374004044700207230ustar00rootroot00000000000000// files/PartsOfPaths.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; public class PartsOfPaths { public static void main(String[] args) { System.out.println(System.getProperty("os.name")); Path p = Paths.get("PartsOfPaths.java").toAbsolutePath(); for(int i = 0; i < p.getNameCount(); i++) System.out.println(p.getName(i)); System.out.println("ends with '.java': " + p.endsWith(".java")); for(Path pp : p) { System.out.print(pp + ": "); System.out.print(p.startsWith(pp) + " : "); System.out.println(p.endsWith(pp)); } System.out.println("Starts with " + p.getRoot() + " " + p.startsWith(p.getRoot())); } } /* Output: Windows 10 Users Bruce Documents GitHub on-java ExtractedExamples files PartsOfPaths.java ends with '.java': false Users: false : false Bruce: false : false Documents: false : false GitHub: false : false on-java: false : false ExtractedExamples: false : false files: false : false PartsOfPaths.java: false : true Starts with C:\ true */ OnJava8-Examples-1.0/files/PathAnalysis.java000066400000000000000000000033141374004044700207450ustar00rootroot00000000000000// files/PathAnalysis.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; import java.io.IOException; public class PathAnalysis { static void say(String id, Object result) { System.out.print(id + ": "); System.out.println(result); } public static void main(String[] args) throws IOException { System.out.println(System.getProperty("os.name")); Path p = Paths.get("PathAnalysis.java").toAbsolutePath(); say("Exists", Files.exists(p)); say("Directory", Files.isDirectory(p)); say("Executable", Files.isExecutable(p)); say("Readable", Files.isReadable(p)); say("RegularFile", Files.isRegularFile(p)); say("Writable", Files.isWritable(p)); say("notExists", Files.notExists(p)); say("Hidden", Files.isHidden(p)); say("size", Files.size(p)); say("FileStore", Files.getFileStore(p)); say("LastModified: ", Files.getLastModifiedTime(p)); say("Owner", Files.getOwner(p)); say("ContentType", Files.probeContentType(p)); say("SymbolicLink", Files.isSymbolicLink(p)); if(Files.isSymbolicLink(p)) say("SymbolicLink", Files.readSymbolicLink(p)); if(FileSystems.getDefault() .supportedFileAttributeViews().contains("posix")) say("PosixFilePermissions", Files.getPosixFilePermissions(p)); } } /* Output: Windows 10 Exists: true Directory: false Executable: true Readable: true RegularFile: true Writable: true notExists: false Hidden: false size: 1631 FileStore: SSD (C:) LastModified: : 2017-05-09T12:07:00.428366Z Owner: MINDVIEWTOSHIBA\Bruce (User) ContentType: null SymbolicLink: false */ OnJava8-Examples-1.0/files/PathInfo.java000066400000000000000000000050721374004044700200600ustar00rootroot00000000000000// files/PathInfo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; import java.net.URI; import java.io.File; import java.io.IOException; public class PathInfo { static void show(String id, Object p) { System.out.println(id + ": " + p); } static void info(Path p) { show("toString", p); show("Exists", Files.exists(p)); show("RegularFile", Files.isRegularFile(p)); show("Directory", Files.isDirectory(p)); show("Absolute", p.isAbsolute()); show("FileName", p.getFileName()); show("Parent", p.getParent()); show("Root", p.getRoot()); System.out.println("******************"); } public static void main(String[] args) { System.out.println(System.getProperty("os.name")); info(Paths.get( "C:", "path", "to", "nowhere", "NoFile.txt")); Path p = Paths.get("PathInfo.java"); info(p); Path ap = p.toAbsolutePath(); info(ap); info(ap.getParent()); try { info(p.toRealPath()); } catch(IOException e) { System.out.println(e); } URI u = p.toUri(); System.out.println("URI: " + u); Path puri = Paths.get(u); System.out.println(Files.exists(puri)); File f = ap.toFile(); // Don't be fooled } } /* Output: Windows 10 toString: C:\path\to\nowhere\NoFile.txt Exists: false RegularFile: false Directory: false Absolute: true FileName: NoFile.txt Parent: C:\path\to\nowhere Root: C:\ ****************** toString: PathInfo.java Exists: true RegularFile: true Directory: false Absolute: false FileName: PathInfo.java Parent: null Root: null ****************** toString: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files\PathInfo.java Exists: true RegularFile: true Directory: false Absolute: true FileName: PathInfo.java Parent: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files Root: C:\ ****************** toString: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files Exists: true RegularFile: false Directory: true Absolute: true FileName: files Parent: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples Root: C:\ ****************** toString: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files\PathInfo.java Exists: true RegularFile: true Directory: false Absolute: true FileName: PathInfo.java Parent: C:\Users\Bruce\Documents\GitHub\on- java\ExtractedExamples\files Root: C:\ ****************** URI: file:///C:/Users/Bruce/Documents/GitHub/on- java/ExtractedExamples/files/PathInfo.java true */ OnJava8-Examples-1.0/files/PathWatcher.java000066400000000000000000000034071374004044700205620ustar00rootroot00000000000000// files/PathWatcher.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromGradle} import java.io.IOException; import java.nio.file.*; import static java.nio.file.StandardWatchEventKinds.*; import java.util.concurrent.*; public class PathWatcher { static Path test = Paths.get("test"); static void delTxtFiles() { try { Files.walk(test) .filter(f -> f.toString().endsWith(".txt")) .forEach(f -> { try { System.out.println("deleting " + f); Files.delete(f); } catch(IOException e) { throw new RuntimeException(e); } }); } catch(IOException e) { throw new RuntimeException(e); } } public static void main(String[] args) throws Exception { Directories.refreshTestDir(); Directories.populateTestDir(); Files.createFile(test.resolve("Hello.txt")); WatchService watcher = FileSystems.getDefault().newWatchService(); test.register(watcher, ENTRY_DELETE); Executors.newSingleThreadScheduledExecutor() .schedule( PathWatcher::delTxtFiles, 250, TimeUnit.MILLISECONDS); WatchKey key = watcher.take(); for(WatchEvent evt : key.pollEvents()) { System.out.println( "evt.context(): " + evt.context() + "\nevt.count(): " + evt.count() + "\nevt.kind(): " + evt.kind()); System.exit(0); } } } /* Output: deleting test\bag\foo\bar\baz\File.txt deleting test\bar\baz\bag\foo\File.txt deleting test\baz\bag\foo\bar\File.txt deleting test\foo\bar\baz\bag\File.txt deleting test\Hello.txt evt.context(): Hello.txt evt.count(): 1 evt.kind(): ENTRY_DELETE */ OnJava8-Examples-1.0/files/ReadLineStream.java000066400000000000000000000007571374004044700212140ustar00rootroot00000000000000// files/ReadLineStream.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; public class ReadLineStream { public static void main(String[] args) throws Exception { Files.lines(Paths.get("PathInfo.java")) .skip(13) .findFirst() .ifPresent(System.out::println); } } /* Output: show("RegularFile", Files.isRegularFile(p)); */ OnJava8-Examples-1.0/files/StreamInAndOut.java000066400000000000000000000012401374004044700211760ustar00rootroot00000000000000// files/StreamInAndOut.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.nio.file.*; import java.util.stream.*; public class StreamInAndOut { public static void main(String[] args) { try( Stream input = Files.lines(Paths.get("StreamInAndOut.java")); PrintWriter output = new PrintWriter("StreamInAndOut.txt") ) { input .map(String::toUpperCase) .forEachOrdered(output::println); } catch(Exception e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/files/TreeWatcher.java000066400000000000000000000027501374004044700205650ustar00rootroot00000000000000// files/TreeWatcher.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromGradle} import java.io.IOException; import java.nio.file.*; import static java.nio.file.StandardWatchEventKinds.*; import java.util.concurrent.*; public class TreeWatcher { static void watchDir(Path dir) { try { WatchService watcher = FileSystems.getDefault().newWatchService(); dir.register(watcher, ENTRY_DELETE); Executors.newSingleThreadExecutor().submit(() -> { try { WatchKey key = watcher.take(); for(WatchEvent evt : key.pollEvents()) { System.out.println( "evt.context(): " + evt.context() + "\nevt.count(): " + evt.count() + "\nevt.kind(): " + evt.kind()); System.exit(0); } } catch(InterruptedException e) { return; } }); } catch(IOException e) { throw new RuntimeException(e); } } public static void main(String[] args) throws Exception { Directories.refreshTestDir(); Directories.populateTestDir(); Files.walk(Paths.get("test")) .filter(Files::isDirectory) .forEach(TreeWatcher::watchDir); PathWatcher.delTxtFiles(); } } /* Output: deleting test\bag\foo\bar\baz\File.txt deleting test\bar\baz\bag\foo\File.txt evt.context(): File.txt evt.count(): 1 evt.kind(): ENTRY_DELETE */ OnJava8-Examples-1.0/files/Writing.java000066400000000000000000000016251374004044700177730ustar00rootroot00000000000000// files/Writing.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.nio.file.*; public class Writing { static Random rand = new Random(47); static final int SIZE = 1000; public static void main(String[] args) throws Exception { // Write bytes to a file: byte[] bytes = new byte[SIZE]; rand.nextBytes(bytes); Files.write(Paths.get("bytes.dat"), bytes); System.out.println("bytes.dat: " + Files.size(Paths.get("bytes.dat"))); // Write an iterable to a file: List lines = Files.readAllLines( Paths.get("../streams/Cheese.dat")); Files.write(Paths.get("Cheese.txt"), lines); System.out.println("Cheese.txt: " + Files.size(Paths.get("Cheese.txt"))); } } /* Output: bytes.dat: 1000 Cheese.txt: 199 */ OnJava8-Examples-1.0/functional/000077500000000000000000000000001374004044700165415ustar00rootroot00000000000000OnJava8-Examples-1.0/functional/AnonymousClosure.java000066400000000000000000000007411374004044700227330ustar00rootroot00000000000000// functional/AnonymousClosure.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class AnonymousClosure { IntSupplier makeFun(int x) { int i = 0; // Same rules apply: // i++; // Not "effectively final" // x++; // Ditto return new IntSupplier() { public int getAsInt() { return x + i; } }; } } OnJava8-Examples-1.0/functional/BiConsumerPermutations.java000066400000000000000000000013431374004044700240660ustar00rootroot00000000000000// functional/BiConsumerPermutations.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class BiConsumerPermutations { static BiConsumer bicid = (i, d) -> System.out.format("%d, %f%n", i, d); static BiConsumer bicdi = (d, i) -> System.out.format("%d, %f%n", i, d); static BiConsumer bicil = (i, l) -> System.out.format("%d, %d%n", i, l); public static void main(String[] args) { bicid.accept(47, 11.34); bicdi.accept(22.45, 92); bicil.accept(1, 11L); } } /* Output: 47, 11.340000 92, 22.450000 1, 11 */ OnJava8-Examples-1.0/functional/ClassFunctionals.java000066400000000000000000000031161374004044700226600ustar00rootroot00000000000000// functional/ClassFunctionals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; class AA {} class BB {} class CC {} public class ClassFunctionals { static AA f1() { return new AA(); } static int f2(AA aa1, AA aa2) { return 1; } static void f3(AA aa) {} static void f4(AA aa, BB bb) {} static CC f5(AA aa) { return new CC(); } static CC f6(AA aa, BB bb) { return new CC(); } static boolean f7(AA aa) { return true; } static boolean f8(AA aa, BB bb) { return true; } static AA f9(AA aa) { return new AA(); } static AA f10(AA aa1, AA aa2) { return new AA(); } public static void main(String[] args) { Supplier s = ClassFunctionals::f1; s.get(); Comparator c = ClassFunctionals::f2; c.compare(new AA(), new AA()); Consumer cons = ClassFunctionals::f3; cons.accept(new AA()); BiConsumer bicons = ClassFunctionals::f4; bicons.accept(new AA(), new BB()); Function f = ClassFunctionals::f5; CC cc = f.apply(new AA()); BiFunction bif = ClassFunctionals::f6; cc = bif.apply(new AA(), new BB()); Predicate p = ClassFunctionals::f7; boolean result = p.test(new AA()); BiPredicate bip = ClassFunctionals::f8; result = bip.test(new AA(), new BB()); UnaryOperator uo = ClassFunctionals::f9; AA aa = uo.apply(new AA()); BinaryOperator bo = ClassFunctionals::f10; aa = bo.apply(new AA(), new AA()); } } OnJava8-Examples-1.0/functional/Closure1.java000066400000000000000000000004741374004044700211060ustar00rootroot00000000000000// functional/Closure1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Closure1 { int i; IntSupplier makeFun(int x) { return () -> x + i++; } } OnJava8-Examples-1.0/functional/Closure2.java000066400000000000000000000005001374004044700210750ustar00rootroot00000000000000// functional/Closure2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Closure2 { IntSupplier makeFun(int x) { int i = 0; return () -> x + i; } } OnJava8-Examples-1.0/functional/Closure3.java000066400000000000000000000005761374004044700211130ustar00rootroot00000000000000// functional/Closure3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import java.util.function.*; public class Closure3 { IntSupplier makeFun(int x) { int i = 0; // Neither x++ nor i++ will work: return () -> x++ + i++; } } OnJava8-Examples-1.0/functional/Closure4.java000066400000000000000000000005141374004044700211040ustar00rootroot00000000000000// functional/Closure4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Closure4 { IntSupplier makeFun(final int x) { final int i = 0; return () -> x + i; } } OnJava8-Examples-1.0/functional/Closure5.java000066400000000000000000000005461374004044700211120ustar00rootroot00000000000000// functional/Closure5.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import java.util.function.*; public class Closure5 { IntSupplier makeFun(int x) { int i = 0; i++; x++; return () -> x + i; } } OnJava8-Examples-1.0/functional/Closure6.java000066400000000000000000000006201374004044700211040ustar00rootroot00000000000000// functional/Closure6.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Closure6 { IntSupplier makeFun(int x) { int i = 0; i++; x++; final int iFinal = i; final int xFinal = x; return () -> xFinal + iFinal; } } OnJava8-Examples-1.0/functional/Closure7.java000066400000000000000000000005471374004044700211150ustar00rootroot00000000000000// functional/Closure7.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import java.util.function.*; public class Closure7 { IntSupplier makeFun(int x) { Integer i = 0; i = i + 1; return () -> x + i; } } OnJava8-Examples-1.0/functional/Closure8.java000066400000000000000000000013371374004044700211140ustar00rootroot00000000000000// functional/Closure8.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; public class Closure8 { Supplier> makeFun() { final List ai = new ArrayList<>(); ai.add(1); return () -> ai; } public static void main(String[] args) { Closure8 c7 = new Closure8(); List l1 = c7.makeFun().get(), l2 = c7.makeFun().get(); System.out.println(l1); System.out.println(l2); l1.add(42); l2.add(96); System.out.println(l1); System.out.println(l2); } } /* Output: [1] [1] [1, 42] [1, 96] */ OnJava8-Examples-1.0/functional/Closure9.java000066400000000000000000000006631374004044700211160ustar00rootroot00000000000000// functional/Closure9.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import java.util.*; import java.util.function.*; public class Closure9 { Supplier> makeFun() { List ai = new ArrayList<>(); ai = new ArrayList<>(); // Reassignment return () -> ai; } } OnJava8-Examples-1.0/functional/ConsumeFunction.java000066400000000000000000000007201374004044700225220ustar00rootroot00000000000000// functional/ConsumeFunction.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; class One {} class Two {} public class ConsumeFunction { static Two consume(Function onetwo) { return onetwo.apply(new One()); } public static void main(String[] args) { Two two = consume(one -> new Two()); } } OnJava8-Examples-1.0/functional/CtorReference.java000066400000000000000000000014401374004044700221310ustar00rootroot00000000000000// functional/CtorReference.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Dog { String name; int age = -1; // For "unknown" Dog() { name = "stray"; } Dog(String nm) { name = nm; } Dog(String nm, int yrs) { name = nm; age = yrs; } } interface MakeNoArgs { Dog make(); } interface Make1Arg { Dog make(String nm); } interface Make2Args { Dog make(String nm, int age); } public class CtorReference { public static void main(String[] args) { MakeNoArgs mna = Dog::new; // [1] Make1Arg m1a = Dog::new; // [2] Make2Args m2a = Dog::new; // [3] Dog dn = mna.make(); Dog d1 = m1a.make("Comet"); Dog d2 = m2a.make("Ralph", 4); } } OnJava8-Examples-1.0/functional/CurriedIntAdd.java000066400000000000000000000007501374004044700220670ustar00rootroot00000000000000// functional/CurriedIntAdd.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class CurriedIntAdd { public static void main(String[] args) { IntFunction curriedIntAdd = a -> b -> a + b; IntUnaryOperator add4 = curriedIntAdd.apply(4); System.out.println(add4.applyAsInt(5)); } } /* Output: 9 */ OnJava8-Examples-1.0/functional/Curry3Args.java000066400000000000000000000012061374004044700214070ustar00rootroot00000000000000// functional/Curry3Args.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Curry3Args { public static void main(String[] args) { Function>> sum = a -> b -> c -> a + b + c; Function> hi = sum.apply("Hi "); Function ho = hi.apply("Ho "); System.out.println(ho.apply("Hup")); } } /* Output: Hi Ho Hup */ OnJava8-Examples-1.0/functional/CurryingAndPartials.java000066400000000000000000000016231374004044700233330ustar00rootroot00000000000000// functional/CurryingAndPartials.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class CurryingAndPartials { // Uncurried: static String uncurried(String a, String b) { return a + b; } public static void main(String[] args) { // Curried function: Function> sum = a -> b -> a + b; // [1] System.out.println(uncurried("Hi ", "Ho")); Function hi = sum.apply("Hi "); // [2] System.out.println(hi.apply("Ho")); // Partial application: Function sumHi = sum.apply("Hup "); System.out.println(sumHi.apply("Ho")); System.out.println(sumHi.apply("Hey")); } } /* Output: Hi Ho Hi Ho Hup Ho Hup Hey */ OnJava8-Examples-1.0/functional/FunctionComposition.java000066400000000000000000000012211374004044700234110ustar00rootroot00000000000000// functional/FunctionComposition.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class FunctionComposition { static Function f1 = s -> { System.out.println(s); return s.replace('A', '_'); }, f2 = s -> s.substring(3), f3 = s -> s.toLowerCase(), f4 = f1.compose(f2).andThen(f3); public static void main(String[] args) { System.out.println( f4.apply("GO AFTER ALL AMBULANCES")); } } /* Output: AFTER ALL AMBULANCES _fter _ll _mbul_nces */ OnJava8-Examples-1.0/functional/FunctionVariants.java000066400000000000000000000030531374004044700227020ustar00rootroot00000000000000// functional/FunctionVariants.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; class Foo {} class Bar { Foo f; Bar(Foo f) { this.f = f; } } class IBaz { int i; IBaz(int i) { this.i = i; } } class LBaz { long l; LBaz(long l) { this.l = l; } } class DBaz { double d; DBaz(double d) { this.d = d; } } public class FunctionVariants { static Function f1 = f -> new Bar(f); static IntFunction f2 = i -> new IBaz(i); static LongFunction f3 = l -> new LBaz(l); static DoubleFunction f4 = d -> new DBaz(d); static ToIntFunction f5 = ib -> ib.i; static ToLongFunction f6 = lb -> lb.l; static ToDoubleFunction f7 = db -> db.d; static IntToLongFunction f8 = i -> i; static IntToDoubleFunction f9 = i -> i; static LongToIntFunction f10 = l -> (int)l; static LongToDoubleFunction f11 = l -> l; static DoubleToIntFunction f12 = d -> (int)d; static DoubleToLongFunction f13 = d -> (long)d; public static void main(String[] args) { Bar b = f1.apply(new Foo()); IBaz ib = f2.apply(11); LBaz lb = f3.apply(11); DBaz db = f4.apply(11); int i = f5.applyAsInt(ib); long l = f6.applyAsLong(lb); double d = f7.applyAsDouble(db); l = f8.applyAsLong(12); d = f9.applyAsDouble(12); i = f10.applyAsInt(12); d = f11.applyAsDouble(12); i = f12.applyAsInt(13.0); l = f13.applyAsLong(13.0); } } OnJava8-Examples-1.0/functional/FunctionWithWrapped.java000066400000000000000000000006261374004044700233540ustar00rootroot00000000000000// functional/FunctionWithWrapped.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class FunctionWithWrapped { public static void main(String[] args) { Function fid = i -> (double)i; IntToDoubleFunction fid2 = i -> i; } } OnJava8-Examples-1.0/functional/FunctionalAnnotation.java000066400000000000000000000020001374004044700235310ustar00rootroot00000000000000// functional/FunctionalAnnotation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. @FunctionalInterface interface Functional { String goodbye(String arg); } interface FunctionalNoAnn { String goodbye(String arg); } /* @FunctionalInterface interface NotFunctional { String goodbye(String arg); String hello(String arg); } Produces error message: NotFunctional is not a functional interface multiple non-overriding abstract methods found in interface NotFunctional */ public class FunctionalAnnotation { public String goodbye(String arg) { return "Goodbye, " + arg; } public static void main(String[] args) { FunctionalAnnotation fa = new FunctionalAnnotation(); Functional f = fa::goodbye; FunctionalNoAnn fna = fa::goodbye; // Functional fac = fa; // Incompatible Functional fl = a -> "Goodbye, " + a; FunctionalNoAnn fnal = a -> "Goodbye, " + a; } } OnJava8-Examples-1.0/functional/IntCall.java000066400000000000000000000003511374004044700207310ustar00rootroot00000000000000// functional/IntCall.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface IntCall { int call(int arg); } OnJava8-Examples-1.0/functional/LambdaExpressions.java000066400000000000000000000021151374004044700230260ustar00rootroot00000000000000// functional/LambdaExpressions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface Description { String brief(); } interface Body { String detailed(String head); } interface Multi { String twoArg(String head, Double d); } public class LambdaExpressions { static Body bod = h -> h + " No Parens!"; // [1] static Body bod2 = (h) -> h + " More details"; // [2] static Description desc = () -> "Short info"; // [3] static Multi mult = (h, n) -> h + n; // [4] static Description moreLines = () -> { // [5] System.out.println("moreLines()"); return "from moreLines()"; }; public static void main(String[] args) { System.out.println(bod.detailed("Oh!")); System.out.println(bod2.detailed("Hi!")); System.out.println(desc.brief()); System.out.println(mult.twoArg("Pi! ", 3.14159)); System.out.println(moreLines.brief()); } } /* Output: Oh! No Parens! Hi! More details Short info Pi! 3.14159 moreLines() from moreLines() */ OnJava8-Examples-1.0/functional/MethodConversion.java000066400000000000000000000014251374004044700226740ustar00rootroot00000000000000// functional/MethodConversion.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; class In1 {} class In2 {} public class MethodConversion { static void accept(In1 i1, In2 i2) { System.out.println("accept()"); } static void someOtherName(In1 i1, In2 i2) { System.out.println("someOtherName()"); } public static void main(String[] args) { BiConsumer bic; bic = MethodConversion::accept; bic.accept(new In1(), new In2()); bic = MethodConversion::someOtherName; // bic.someOtherName(new In1(), new In2()); // Nope bic.accept(new In1(), new In2()); } } /* Output: accept() someOtherName() */ OnJava8-Examples-1.0/functional/MethodReferences.java000066400000000000000000000022171374004044700226300ustar00rootroot00000000000000// functional/MethodReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface Callable { // [1] void call(String s); } class Describe { void show(String msg) { // [2] System.out.println(msg); } } public class MethodReferences { static void hello(String name) { // [3] System.out.println("Hello, " + name); } static class Description { String about; Description(String desc) { about = desc; } void help(String msg) { // [4] System.out.println(about + " " + msg); } } static class Helper { static void assist(String msg) { // [5] System.out.println(msg); } } public static void main(String[] args) { Describe d = new Describe(); Callable c = d::show; // [6] c.call("call()"); // [7] c = MethodReferences::hello; // [8] c.call("Bob"); c = new Description("valuable")::help; // [9] c.call("information"); c = Helper::assist; // [10] c.call("Help!"); } } /* Output: call() Hello, Bob valuable information Help! */ OnJava8-Examples-1.0/functional/MultiUnbound.java000066400000000000000000000016771374004044700220440ustar00rootroot00000000000000// functional/MultiUnbound.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Unbound methods with multiple arguments class This { void two(int i, double d) {} void three(int i, double d, String s) {} void four(int i, double d, String s, char c) {} } interface TwoArgs { void call2(This athis, int i, double d); } interface ThreeArgs { void call3(This athis, int i, double d, String s); } interface FourArgs { void call4( This athis, int i, double d, String s, char c); } public class MultiUnbound { public static void main(String[] args) { TwoArgs twoargs = This::two; ThreeArgs threeargs = This::three; FourArgs fourargs = This::four; This athis = new This(); twoargs.call2(athis, 11, 3.14); threeargs.call3(athis, 11, 3.14, "Three"); fourargs.call4(athis, 11, 3.14, "Four", 'Z'); } } OnJava8-Examples-1.0/functional/PredicateComposition.java000066400000000000000000000012031374004044700235240ustar00rootroot00000000000000// functional/PredicateComposition.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; import java.util.stream.*; public class PredicateComposition { static Predicate p1 = s -> s.contains("bar"), p2 = s -> s.length() < 5, p3 = s -> s.contains("foo"), p4 = p1.negate().and(p2).or(p3); public static void main(String[] args) { Stream.of("bar", "foobar", "foobaz", "fongopuckey") .filter(p4) .forEach(System.out::println); } } /* Output: foobar foobaz */ OnJava8-Examples-1.0/functional/ProduceFunction.java000066400000000000000000000010241374004044700225100ustar00rootroot00000000000000// functional/ProduceFunction.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; interface FuncSS extends Function {} // [1] public class ProduceFunction { static FuncSS produce() { return s -> s.toLowerCase(); // [2] } public static void main(String[] args) { FuncSS f = produce(); System.out.println(f.apply("YELLING")); } } /* Output: yelling */ OnJava8-Examples-1.0/functional/RecursiveFactorial.java000066400000000000000000000007521374004044700232040ustar00rootroot00000000000000// functional/RecursiveFactorial.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class RecursiveFactorial { static IntCall fact; public static void main(String[] args) { fact = n -> n == 0 ? 1 : n * fact.call(n - 1); for(int i = 0; i <= 10; i++) System.out.println(fact.call(i)); } } /* Output: 1 1 2 6 24 120 720 5040 40320 362880 3628800 */ OnJava8-Examples-1.0/functional/RecursiveFibonacci.java000066400000000000000000000012131374004044700231460ustar00rootroot00000000000000// functional/RecursiveFibonacci.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class RecursiveFibonacci { IntCall fib; RecursiveFibonacci() { fib = n -> n == 0 ? 0 : n == 1 ? 1 : fib.call(n - 1) + fib.call(n - 2); } int fibonacci(int n) { return fib.call(n); } public static void main(String[] args) { RecursiveFibonacci rf = new RecursiveFibonacci(); for(int i = 0; i <= 10; i++) System.out.println(rf.fibonacci(i)); } } /* Output: 0 1 1 2 3 5 8 13 21 34 55 */ OnJava8-Examples-1.0/functional/RunnableMethodReference.java000066400000000000000000000012541374004044700241340ustar00rootroot00000000000000// functional/RunnableMethodReference.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Method references with interface Runnable class Go { static void go() { System.out.println("Go::go()"); } } public class RunnableMethodReference { public static void main(String[] args) { new Thread(new Runnable() { public void run() { System.out.println("Anonymous"); } }).start(); new Thread( () -> System.out.println("lambda") ).start(); new Thread(Go::go).start(); } } /* Output: Anonymous lambda Go::go() */ OnJava8-Examples-1.0/functional/SharedStorage.java000066400000000000000000000011061374004044700221350ustar00rootroot00000000000000// functional/SharedStorage.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class SharedStorage { public static void main(String[] args) { Closure1 c1 = new Closure1(); IntSupplier f1 = c1.makeFun(0); IntSupplier f2 = c1.makeFun(0); IntSupplier f3 = c1.makeFun(0); System.out.println(f1.getAsInt()); System.out.println(f2.getAsInt()); System.out.println(f3.getAsInt()); } } /* Output: 0 1 2 */ OnJava8-Examples-1.0/functional/Strategize.java000066400000000000000000000024351374004044700215310ustar00rootroot00000000000000// functional/Strategize.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface Strategy { String approach(String msg); } class Soft implements Strategy { public String approach(String msg) { return msg.toLowerCase() + "?"; } } class Unrelated { static String twice(String msg) { return msg + " " + msg; } } public class Strategize { Strategy strategy; String msg; Strategize(String msg) { strategy = new Soft(); // [1] this.msg = msg; } void communicate() { System.out.println(strategy.approach(msg)); } void changeStrategy(Strategy strategy) { this.strategy = strategy; } public static void main(String[] args) { Strategy[] strategies = { new Strategy() { // [2] public String approach(String msg) { return msg.toUpperCase() + "!"; } }, msg -> msg.substring(0, 5), // [3] Unrelated::twice // [4] }; Strategize s = new Strategize("Hello there"); s.communicate(); for(Strategy newStrategy : strategies) { s.changeStrategy(newStrategy); // [5] s.communicate(); // [6] } } } /* Output: hello there? HELLO THERE! Hello Hello there Hello there */ OnJava8-Examples-1.0/functional/TransformFunction.java000066400000000000000000000013341374004044700230660ustar00rootroot00000000000000// functional/TransformFunction.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; class I { @Override public String toString() { return "I"; } } class O { @Override public String toString() { return "O"; } } public class TransformFunction { static Function transform(Function in) { return in.andThen(o -> { System.out.println(o); return o; }); } public static void main(String[] args) { Function f2 = transform(i -> { System.out.println(i); return new O(); }); O o = f2.apply(new I()); } } /* Output: I O */ OnJava8-Examples-1.0/functional/TriFunction.java000066400000000000000000000004401374004044700216460ustar00rootroot00000000000000// functional/TriFunction.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. @FunctionalInterface public interface TriFunction { R apply(T t, U u, V v); } OnJava8-Examples-1.0/functional/TriFunctionTest.java000066400000000000000000000006661374004044700225200ustar00rootroot00000000000000// functional/TriFunctionTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class TriFunctionTest { static int f(int i, long l, double d) { return 99; } public static void main(String[] args) { TriFunction tf = TriFunctionTest::f; tf = (i, l, d) -> 12; } } OnJava8-Examples-1.0/functional/UnboundMethodReference.java000066400000000000000000000012421374004044700237750ustar00rootroot00000000000000// functional/UnboundMethodReference.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Method reference without an object class X { String f() { return "X::f()"; } } interface MakeString { String make(); } interface TransformX { String transform(X x); } public class UnboundMethodReference { public static void main(String[] args) { // MakeString ms = X::f; // [1] TransformX sp = X::f; X x = new X(); System.out.println(sp.transform(x)); // [2] System.out.println(x.f()); // Same effect } } /* Output: X::f() X::f() */ OnJava8-Examples-1.0/generics/000077500000000000000000000000001374004044700161765ustar00rootroot00000000000000OnJava8-Examples-1.0/generics/Amphibian.java000066400000000000000000000003271374004044700207330ustar00rootroot00000000000000// generics/Amphibian.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Amphibian {} OnJava8-Examples-1.0/generics/Apply.java000066400000000000000000000011431374004044700201250ustar00rootroot00000000000000// generics/Apply.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.reflect.*; import java.util.*; public class Apply { public static > void apply(S seq, Method f, Object... args) { try { for(T t: seq) f.invoke(t, args); } catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { // Failures are programmer errors throw new RuntimeException(e); } } } OnJava8-Examples-1.0/generics/ApplyFunctional.java000066400000000000000000000022731374004044700221550ustar00rootroot00000000000000// generics/ApplyFunctional.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; import onjava.*; public class ApplyFunctional { public static void main(String[] args) { Stream.of( Stream.generate(Shape::new).limit(2), Stream.generate(Square::new).limit(2)) .flatMap(c -> c) // flatten into one stream .peek(Shape::rotate) .forEach(s -> s.resize(7)); new FilledList<>(Shape::new, 2) .forEach(Shape::rotate); new FilledList<>(Square::new, 2) .forEach(Shape::rotate); SimpleQueue shapeQ = Suppliers.fill( new SimpleQueue<>(), SimpleQueue::add, Shape::new, 2); Suppliers.fill(shapeQ, SimpleQueue::add, Square::new, 2); shapeQ.forEach(Shape::rotate); } } /* Output: Shape 0 rotate Shape 0 resize 7 Shape 1 rotate Shape 1 resize 7 Square 2 rotate Square 2 resize 7 Square 3 rotate Square 3 resize 7 Shape 4 rotate Shape 5 rotate Square 6 rotate Square 7 rotate Shape 8 rotate Shape 9 rotate Square 10 rotate Square 11 rotate */ OnJava8-Examples-1.0/generics/ApplyTest.java000066400000000000000000000031411374004044700207650ustar00rootroot00000000000000// generics/ApplyTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import onjava.*; public class ApplyTest { public static void main(String[] args) throws Exception { List shapes = Suppliers.create(ArrayList::new, Shape::new, 3); Apply.apply(shapes, Shape.class.getMethod("rotate")); Apply.apply(shapes, Shape.class.getMethod("resize", int.class), 7); List squares = Suppliers.create(ArrayList::new, Square::new, 3); Apply.apply(squares, Shape.class.getMethod("rotate")); Apply.apply(squares, Shape.class.getMethod("resize", int.class), 7); Apply.apply(new FilledList<>(Shape::new, 3), Shape.class.getMethod("rotate")); Apply.apply(new FilledList<>(Square::new, 3), Shape.class.getMethod("rotate")); SimpleQueue shapeQ = Suppliers.fill( new SimpleQueue<>(), SimpleQueue::add, Shape::new, 3); Suppliers.fill(shapeQ, SimpleQueue::add, Square::new, 3); Apply.apply(shapeQ, Shape.class.getMethod("rotate")); } } /* Output: Shape 0 rotate Shape 1 rotate Shape 2 rotate Shape 0 resize 7 Shape 1 resize 7 Shape 2 resize 7 Square 3 rotate Square 4 rotate Square 5 rotate Square 3 resize 7 Square 4 resize 7 Square 5 resize 7 Shape 6 rotate Shape 7 rotate Shape 8 rotate Square 9 rotate Square 10 rotate Square 11 rotate Shape 12 rotate Shape 13 rotate Shape 14 rotate Square 15 rotate Square 16 rotate Square 17 rotate */ OnJava8-Examples-1.0/generics/ArrayMaker.java000066400000000000000000000013641374004044700211030ustar00rootroot00000000000000// generics/ArrayMaker.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.reflect.*; import java.util.*; public class ArrayMaker { private Class kind; public ArrayMaker(Class kind) { this.kind = kind; } @SuppressWarnings("unchecked") T[] create(int size) { return (T[])Array.newInstance(kind, size); } public static void main(String[] args) { ArrayMaker stringMaker = new ArrayMaker<>(String.class); String[] stringArray = stringMaker.create(9); System.out.println(Arrays.toString(stringArray)); } } /* Output: [null, null, null, null, null, null, null, null, null] */ OnJava8-Examples-1.0/generics/ArrayOfGeneric.java000066400000000000000000000016161374004044700217050ustar00rootroot00000000000000// generics/ArrayOfGeneric.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ArrayOfGeneric { static final int SIZE = 100; static Generic[] gia; @SuppressWarnings("unchecked") public static void main(String[] args) { try { gia = (Generic[])new Object[SIZE]; } catch(ClassCastException e) { System.out.println(e.getMessage()); } // Runtime type is the raw (erased) type: gia = (Generic[])new Generic[SIZE]; System.out.println(gia.getClass().getSimpleName()); gia[0] = new Generic<>(); //- gia[1] = new Object(); // Compile-time error // Discovers type mismatch at compile time: //- gia[2] = new Generic(); } } /* Output: [Ljava.lang.Object; cannot be cast to [LGeneric; Generic[] */ OnJava8-Examples-1.0/generics/ArrayOfGenericReference.java000066400000000000000000000004531374004044700235220ustar00rootroot00000000000000// generics/ArrayOfGenericReference.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Generic {} public class ArrayOfGenericReference { static Generic[] gia; } OnJava8-Examples-1.0/generics/BankTeller.java000066400000000000000000000034551374004044700210730ustar00rootroot00000000000000// generics/BankTeller.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A very simple bank teller simulation import java.util.*; import onjava.*; class Customer { private static long counter = 1; private final long id = counter++; @Override public String toString() { return "Customer " + id; } } class Teller { private static long counter = 1; private final long id = counter++; @Override public String toString() { return "Teller " + id; } } class Bank { private List tellers = new ArrayList<>(); public void put(BankTeller bt) { tellers.add(bt); } } public class BankTeller { public static void serve(Teller t, Customer c) { System.out.println(t + " serves " + c); } public static void main(String[] args) { // Demonstrate create(): RandomList tellers = Suppliers.create( RandomList::new, Teller::new, 4); // Demonstrate fill(): List customers = Suppliers.fill( new ArrayList<>(), Customer::new, 12); customers.forEach(c -> serve(tellers.select(), c)); // Demonstrate assisted latent typing: Bank bank = Suppliers.fill( new Bank(), Bank::put, BankTeller::new, 3); // Can also use second version of fill(): List customers2 = Suppliers.fill( new ArrayList<>(), List::add, Customer::new, 12); } } /* Output: Teller 3 serves Customer 1 Teller 2 serves Customer 2 Teller 3 serves Customer 3 Teller 1 serves Customer 4 Teller 1 serves Customer 5 Teller 3 serves Customer 6 Teller 1 serves Customer 7 Teller 2 serves Customer 8 Teller 3 serves Customer 9 Teller 3 serves Customer 10 Teller 2 serves Customer 11 Teller 4 serves Customer 12 */ OnJava8-Examples-1.0/generics/BasicBounds.java000066400000000000000000000033071374004044700212400ustar00rootroot00000000000000// generics/BasicBounds.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface HasColor { java.awt.Color getColor(); } class WithColor { T item; WithColor(T item) { this.item = item; } T getItem() { return item; } // The bound allows you to call a method: java.awt.Color color() { return item.getColor(); } } class Coord { public int x, y, z; } // This fails. Class must be first, then interfaces: // class WithColorCoord { // Multiple bounds: class WithColorCoord { T item; WithColorCoord(T item) { this.item = item; } T getItem() { return item; } java.awt.Color color() { return item.getColor(); } int getX() { return item.x; } int getY() { return item.y; } int getZ() { return item.z; } } interface Weight { int weight(); } // As with inheritance, you can have only one // concrete class but multiple interfaces: class Solid { T item; Solid(T item) { this.item = item; } T getItem() { return item; } java.awt.Color color() { return item.getColor(); } int getX() { return item.x; } int getY() { return item.y; } int getZ() { return item.z; } int weight() { return item.weight(); } } class Bounded extends Coord implements HasColor, Weight { @Override public java.awt.Color getColor() { return null; } @Override public int weight() { return 0; } } public class BasicBounds { public static void main(String[] args) { Solid solid = new Solid<>(new Bounded()); solid.color(); solid.getY(); solid.weight(); } } OnJava8-Examples-1.0/generics/BasicHolder.java000066400000000000000000000006041374004044700212200ustar00rootroot00000000000000// generics/BasicHolder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class BasicHolder { T element; void set(T arg) { element = arg; } T get() { return element; } void f() { System.out.println( element.getClass().getSimpleName()); } } OnJava8-Examples-1.0/generics/BasicSupplierDemo.java000066400000000000000000000010351374004044700224120ustar00rootroot00000000000000// generics/BasicSupplierDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; import java.util.stream.*; public class BasicSupplierDemo { public static void main(String[] args) { Stream.generate( BasicSupplier.create(CountedObject.class)) .limit(5) .forEach(System.out::println); } } /* Output: CountedObject 0 CountedObject 1 CountedObject 2 CountedObject 3 CountedObject 4 */ OnJava8-Examples-1.0/generics/ByteSet.java000066400000000000000000000007111374004044700204170ustar00rootroot00000000000000// generics/ByteSet.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ByteSet { Byte[] possibles = { 1,2,3,4,5,6,7,8,9 }; Set mySet = new HashSet<>(Arrays.asList(possibles)); // But you can't do this: // Set mySet2 = new HashSet<>( // Arrays.asList(1,2,3,4,5,6,7,8,9)); } OnJava8-Examples-1.0/generics/CRGWithBasicHolder.java000066400000000000000000000007351374004044700224150ustar00rootroot00000000000000// generics/CRGWithBasicHolder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Subtype extends BasicHolder {} public class CRGWithBasicHolder { public static void main(String[] args) { Subtype st1 = new Subtype(), st2 = new Subtype(); st1.set(st2); Subtype st3 = st1.get(); st1.f(); } } /* Output: Subtype */ OnJava8-Examples-1.0/generics/CaptureConversion.java000066400000000000000000000033011374004044700225070ustar00rootroot00000000000000// generics/CaptureConversion.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class CaptureConversion { static void f1(Holder holder) { T t = holder.get(); System.out.println(t.getClass().getSimpleName()); } static void f2(Holder holder) { f1(holder); // Call with captured type } @SuppressWarnings("unchecked") public static void main(String[] args) { Holder raw = new Holder<>(1); f1(raw); // warning: [unchecked] unchecked method invocation: // method f1 in class CaptureConversion // is applied to given types // f1(raw); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method f1(Holder) // warning: [unchecked] unchecked conversion // f1(raw); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method f1(Holder) // 2 warnings f2(raw); // No warnings Holder rawBasic = new Holder(); rawBasic.set(new Object()); // warning: [unchecked] unchecked call to set(T) // as a member of the raw type Holder // rawBasic.set(new Object()); // ^ // where T is a type-variable: // T extends Object declared in class Holder // 1 warning f2(rawBasic); // No warnings // Upcast to Holder, still figures it out: Holder wildcarded = new Holder<>(1.0); f2(wildcarded); } } /* Output: Integer Integer Object Double */ OnJava8-Examples-1.0/generics/CheckedList.java000066400000000000000000000021251374004044700212230ustar00rootroot00000000000000// generics/CheckedList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using Collection.checkedList() import typeinfo.pets.*; import java.util.*; public class CheckedList { @SuppressWarnings("unchecked") static void oldStyleMethod(List probablyDogs) { probablyDogs.add(new Cat()); } public static void main(String[] args) { List dogs1 = new ArrayList<>(); oldStyleMethod(dogs1); // Quietly accepts a Cat List dogs2 = Collections.checkedList( new ArrayList<>(), Dog.class); try { oldStyleMethod(dogs2); // Throws an exception } catch(Exception e) { System.out.println("Expected: " + e); } // Derived types work fine: List pets = Collections.checkedList( new ArrayList<>(), Pet.class); pets.add(new Dog()); pets.add(new Cat()); } } /* Output: Expected: java.lang.ClassCastException: Attempt to insert class typeinfo.pets.Cat element into collection with element type class typeinfo.pets.Dog */ OnJava8-Examples-1.0/generics/ClassCasting.java000066400000000000000000000011071374004044700214160ustar00rootroot00000000000000// generics/ClassCasting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.util.*; public class ClassCasting { @SuppressWarnings("unchecked") public void f(String[] args) throws Exception { ObjectInputStream in = new ObjectInputStream( new FileInputStream(args[0])); // Won't Compile: // List lw1 = // List<>.class.cast(in.readObject()); List lw2 = List.class.cast(in.readObject()); } } OnJava8-Examples-1.0/generics/ClassTypeCapture.java000066400000000000000000000015471374004044700223030ustar00rootroot00000000000000// generics/ClassTypeCapture.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Building {} class House extends Building {} public class ClassTypeCapture { Class kind; public ClassTypeCapture(Class kind) { this.kind = kind; } public boolean f(Object arg) { return kind.isInstance(arg); } public static void main(String[] args) { ClassTypeCapture ctt1 = new ClassTypeCapture<>(Building.class); System.out.println(ctt1.f(new Building())); System.out.println(ctt1.f(new House())); ClassTypeCapture ctt2 = new ClassTypeCapture<>(House.class); System.out.println(ctt2.f(new Building())); System.out.println(ctt2.f(new House())); } } /* Output: true true false true */ OnJava8-Examples-1.0/generics/ComparablePet.java000066400000000000000000000005201374004044700215540ustar00rootroot00000000000000// generics/ComparablePet.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ComparablePet implements Comparable { @Override public int compareTo(ComparablePet arg) { return 0; } } OnJava8-Examples-1.0/generics/CompilerIntelligence.java000066400000000000000000000010301374004044700231300ustar00rootroot00000000000000// generics/CompilerIntelligence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class CompilerIntelligence { public static void main(String[] args) { List flist = Arrays.asList(new Apple()); Apple a = (Apple)flist.get(0); // No warning flist.contains(new Apple()); // Argument is 'Object' flist.indexOf(new Apple()); // Argument is 'Object' } } OnJava8-Examples-1.0/generics/CountedObject.java000066400000000000000000000006321374004044700215720ustar00rootroot00000000000000// generics/CountedObject.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class CountedObject { private static long counter = 0; private final long id = counter++; public long id() { return id; } @Override public String toString() { return "CountedObject " + id; } } OnJava8-Examples-1.0/generics/CovariantArrays.java000066400000000000000000000016721374004044700221570ustar00rootroot00000000000000// generics/CovariantArrays.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Fruit {} class Apple extends Fruit {} class Jonathan extends Apple {} class Orange extends Fruit {} public class CovariantArrays { public static void main(String[] args) { Fruit[] fruit = new Apple[10]; fruit[0] = new Apple(); // OK fruit[1] = new Jonathan(); // OK // Runtime type is Apple[], not Fruit[] or Orange[]: try { // Compiler allows you to add Fruit: fruit[0] = new Fruit(); // ArrayStoreException } catch(Exception e) { System.out.println(e); } try { // Compiler allows you to add Oranges: fruit[0] = new Orange(); // ArrayStoreException } catch(Exception e) { System.out.println(e); } } } /* Output: java.lang.ArrayStoreException: Fruit java.lang.ArrayStoreException: Orange */ OnJava8-Examples-1.0/generics/CovariantReturnTypes.java000066400000000000000000000010031374004044700232060ustar00rootroot00000000000000// generics/CovariantReturnTypes.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Base {} class Derived extends Base {} interface OrdinaryGetter { Base get(); } interface DerivedGetter extends OrdinaryGetter { // Overridden method return type can vary: @Override Derived get(); } public class CovariantReturnTypes { void test(DerivedGetter d) { Derived d2 = d.get(); } } OnJava8-Examples-1.0/generics/CreatorGeneric.java000066400000000000000000000012171374004044700217360ustar00rootroot00000000000000// generics/CreatorGeneric.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. abstract class GenericWithCreate { final T element; GenericWithCreate() { element = create(); } abstract T create(); } class X {} class XCreator extends GenericWithCreate { @Override X create() { return new X(); } void f() { System.out.println( element.getClass().getSimpleName()); } } public class CreatorGeneric { public static void main(String[] args) { XCreator xc = new XCreator(); xc.f(); } } /* Output: X */ OnJava8-Examples-1.0/generics/CuriouslyRecurringGeneric.java000066400000000000000000000005021374004044700242120ustar00rootroot00000000000000// generics/CuriouslyRecurringGeneric.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class GenericType {} public class CuriouslyRecurringGeneric extends GenericType {} OnJava8-Examples-1.0/generics/Diamond.java000066400000000000000000000005371374004044700204210ustar00rootroot00000000000000// generics/Diamond.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Bob {} public class Diamond { public static void main(String[] args) { GenericHolder h3 = new GenericHolder<>(); h3.set(new Bob()); } } OnJava8-Examples-1.0/generics/DogsAndRobotMethodReferences.java000066400000000000000000000023011374004044700245250ustar00rootroot00000000000000// generics/DogsAndRobotMethodReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // "Assisted Latent Typing" import typeinfo.pets.*; import java.util.function.*; class PerformingDogA extends Dog { public void speak() { System.out.println("Woof!"); } public void sit() { System.out.println("Sitting"); } public void reproduce() {} } class RobotA { public void speak() { System.out.println("Click!"); } public void sit() { System.out.println("Clank!"); } public void oilChange() {} } class CommunicateA { public static

void perform(P performer, Consumer

action1, Consumer

action2) { action1.accept(performer); action2.accept(performer); } } public class DogsAndRobotMethodReferences { public static void main(String[] args) { CommunicateA.perform(new PerformingDogA(), PerformingDogA::speak, PerformingDogA::sit); CommunicateA.perform(new RobotA(), RobotA::speak, RobotA::sit); CommunicateA.perform(new Mime(), Mime::walkAgainstTheWind, Mime::pushInvisibleWalls); } } /* Output: Woof! Sitting Click! Clank! */ OnJava8-Examples-1.0/generics/DogsAndRobots.cpp000066400000000000000000000012651374004044700214160ustar00rootroot00000000000000// generics/DogsAndRobots.cpp // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. #include using namespace std; class Dog { public: void speak() { cout << "Arf!" << endl; } void sit() { cout << "Sitting" << endl; } void reproduce() {} }; class Robot { public: void speak() { cout << "Click!" << endl; } void sit() { cout << "Clank!" << endl; } void oilChange() {} }; template void perform(T anything) { anything.speak(); anything.sit(); } int main() { Dog d; Robot r; perform(d); perform(r); } /* Output: Arf! Sitting Click! Clank! */ OnJava8-Examples-1.0/generics/DogsAndRobots.java000066400000000000000000000017411374004044700215540ustar00rootroot00000000000000// generics/DogsAndRobots.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // No (direct) latent typing in Java import typeinfo.pets.*; class PerformingDog extends Dog implements Performs { @Override public void speak() { System.out.println("Woof!"); } @Override public void sit() { System.out.println("Sitting"); } public void reproduce() {} } class Robot implements Performs { public void speak() { System.out.println("Click!"); } public void sit() { System.out.println("Clank!"); } public void oilChange() {} } class Communicate { public static void perform(T performer) { performer.speak(); performer.sit(); } } public class DogsAndRobots { public static void main(String[] args) { Communicate.perform(new PerformingDog()); Communicate.perform(new Robot()); } } /* Output: Woof! Sitting Click! Clank! */ OnJava8-Examples-1.0/generics/DogsAndRobots.py000066400000000000000000000011521374004044700212570ustar00rootroot00000000000000# generics/DogsAndRobots.py # (c)2020 MindView LLC: see Copyright.txt # We make no guarantees that this code is fit for any purpose. # Visit http://OnJava8.com for more book information. class Dog: def speak(self): print("Arf!") def sit(self): print("Sitting") def reproduce(self): pass class Robot: def speak(self): print("Click!") def sit(self): print("Clank!") def oilChange(self): pass def perform(anything): anything.speak() anything.sit() a = Dog() b = Robot() perform(a) perform(b) output = """ Arf! Sitting Click! Clank! """ OnJava8-Examples-1.0/generics/DynamicProxyMixin.java000066400000000000000000000040631374004044700224770ustar00rootroot00000000000000// generics/DynamicProxyMixin.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.reflect.*; import java.util.*; import onjava.*; import static onjava.Tuple.*; class MixinProxy implements InvocationHandler { Map delegatesByMethod; @SuppressWarnings("unchecked") MixinProxy(Tuple2>... pairs) { delegatesByMethod = new HashMap<>(); for(Tuple2> pair : pairs) { for(Method method : pair.a2.getMethods()) { String methodName = method.getName(); // The first interface in the map // implements the method. if(!delegatesByMethod.containsKey(methodName)) delegatesByMethod.put(methodName, pair.a1); } } } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { String methodName = method.getName(); Object delegate = delegatesByMethod.get(methodName); return method.invoke(delegate, args); } @SuppressWarnings("unchecked") public static Object newInstance(Tuple2... pairs) { Class[] interfaces = new Class[pairs.length]; for(int i = 0; i < pairs.length; i++) { interfaces[i] = (Class)pairs[i].a2; } ClassLoader cl = pairs[0].a1.getClass().getClassLoader(); return Proxy.newProxyInstance( cl, interfaces, new MixinProxy(pairs)); } } public class DynamicProxyMixin { public static void main(String[] args) { @SuppressWarnings("unchecked") Object mixin = MixinProxy.newInstance( tuple(new BasicImp(), Basic.class), tuple(new TimeStampedImp(), TimeStamped.class), tuple(new SerialNumberedImp(), SerialNumbered.class)); Basic b = (Basic)mixin; TimeStamped t = (TimeStamped)mixin; SerialNumbered s = (SerialNumbered)mixin; b.set("Hello"); System.out.println(b.get()); System.out.println(t.getStamp()); System.out.println(s.getSerialNumber()); } } /* Output: Hello 1494331653339 1 */ OnJava8-Examples-1.0/generics/EpicBattle.java000066400000000000000000000036061374004044700210620ustar00rootroot00000000000000// generics/EpicBattle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Bounds in Java generics import java.util.*; interface SuperPower {} interface XRayVision extends SuperPower { void seeThroughWalls(); } interface SuperHearing extends SuperPower { void hearSubtleNoises(); } interface SuperSmell extends SuperPower { void trackBySmell(); } class SuperHero { POWER power; SuperHero(POWER power) { this.power = power; } POWER getPower() { return power; } } class SuperSleuth extends SuperHero { SuperSleuth(POWER power) { super(power); } void see() { power.seeThroughWalls(); } } class CanineHero extends SuperHero { CanineHero(POWER power) { super(power); } void hear() { power.hearSubtleNoises(); } void smell() { power.trackBySmell(); } } class SuperHearSmell implements SuperHearing, SuperSmell { @Override public void hearSubtleNoises() {} @Override public void trackBySmell() {} } class DogPerson extends CanineHero { DogPerson() { super(new SuperHearSmell()); } } public class EpicBattle { // Bounds in generic methods: static void useSuperHearing(SuperHero hero) { hero.getPower().hearSubtleNoises(); } static void superFind(SuperHero hero) { hero.getPower().hearSubtleNoises(); hero.getPower().trackBySmell(); } public static void main(String[] args) { DogPerson dogPerson = new DogPerson(); useSuperHearing(dogPerson); superFind(dogPerson); // You can do this: List audioPeople; // But you can't do this: // List dogPs; } } OnJava8-Examples-1.0/generics/Erased.java000066400000000000000000000011061374004044700202420ustar00rootroot00000000000000// generics/Erased.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} public class Erased { private final int SIZE = 100; public void f(Object arg) { // error: illegal generic type for instanceof if(arg instanceof T) {} // error: unexpected type T var = new T(); // error: generic array creation T[] array = new T[SIZE]; // warning: [unchecked] unchecked cast T[] array = (T[])new Object[SIZE]; } } OnJava8-Examples-1.0/generics/ErasedTypeEquivalence.java000066400000000000000000000007201374004044700232670ustar00rootroot00000000000000// generics/ErasedTypeEquivalence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ErasedTypeEquivalence { public static void main(String[] args) { Class c1 = new ArrayList().getClass(); Class c2 = new ArrayList().getClass(); System.out.println(c1 == c2); } } /* Output: true */ OnJava8-Examples-1.0/generics/ErasureAndInheritance.java000066400000000000000000000014071374004044700232460ustar00rootroot00000000000000// generics/ErasureAndInheritance.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class GenericBase { private T element; public void set(T arg) { element = arg; } public T get() { return element; } } class Derived1 extends GenericBase {} class Derived2 extends GenericBase {} // No warning // class Derived3 extends GenericBase {} // Strange error: // unexpected type // required: class or interface without bounds public class ErasureAndInheritance { @SuppressWarnings("unchecked") public static void main(String[] args) { Derived2 d2 = new Derived2(); Object obj = d2.get(); d2.set(obj); // Warning here! } } OnJava8-Examples-1.0/generics/FactoryConstraint.java000066400000000000000000000026071374004044700225220ustar00rootroot00000000000000// generics/FactoryConstraint.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import onjava.*; class IntegerFactory implements Supplier { private int i = 0; @Override public Integer get() { return ++i; } } class Widget { private int id; Widget(int n) { id = n; } @Override public String toString() { return "Widget " + id; } public static class Factory implements Supplier { private int i = 0; @Override public Widget get() { return new Widget(++i); } } } class Fudge { private static int count = 1; private int n = count++; @Override public String toString() { return "Fudge " + n; } } class Foo2 { private List x = new ArrayList<>(); Foo2(Supplier factory) { Suppliers.fill(x, factory, 5); } @Override public String toString() { return x.toString(); } } public class FactoryConstraint { public static void main(String[] args) { System.out.println( new Foo2<>(new IntegerFactory())); System.out.println( new Foo2<>(new Widget.Factory())); System.out.println( new Foo2<>(Fudge::new)); } } /* Output: [1, 2, 3, 4, 5] [Widget 1, Widget 2, Widget 3, Widget 4, Widget 5] [Fudge 1, Fudge 2, Fudge 3, Fudge 4, Fudge 5] */ OnJava8-Examples-1.0/generics/Fibonacci.java000066400000000000000000000013431374004044700207170ustar00rootroot00000000000000// generics/Fibonacci.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Generate a Fibonacci sequence import java.util.function.*; import java.util.stream.*; public class Fibonacci implements Supplier { private int count = 0; @Override public Integer get() { return fib(count++); } private int fib(int n) { if(n < 2) return 1; return fib(n-2) + fib(n-1); } public static void main(String[] args) { Stream.generate(new Fibonacci()) .limit(18) .map(n -> n + " ") .forEach(System.out::print); } } /* Output: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 */ OnJava8-Examples-1.0/generics/FilledList.java000066400000000000000000000014261374004044700210770ustar00rootroot00000000000000// generics/FilledList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import onjava.*; public class FilledList extends ArrayList { FilledList(Supplier gen, int size) { Suppliers.fill(this, gen, size); } public FilledList(T t, int size) { for(int i = 0; i < size; i++) this.add(t); } public static void main(String[] args) { List list = new FilledList<>("Hello", 4); System.out.println(list); // Supplier version: List ilist = new FilledList<>(() -> 47, 4); System.out.println(ilist); } } /* Output: [Hello, Hello, Hello, Hello] [47, 47, 47, 47] */ OnJava8-Examples-1.0/generics/GenericArray.java000066400000000000000000000016171374004044700214210ustar00rootroot00000000000000// generics/GenericArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class GenericArray { private T[] array; @SuppressWarnings("unchecked") public GenericArray(int sz) { array = (T[])new Object[sz]; } public void put(int index, T item) { array[index] = item; } public T get(int index) { return array[index]; } // Method that exposes the underlying representation: public T[] rep() { return array; } public static void main(String[] args) { GenericArray gai = new GenericArray<>(10); try { Integer[] ia = gai.rep(); } catch(ClassCastException e) { System.out.println(e.getMessage()); } // This is OK: Object[] oa = gai.rep(); } } /* Output: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer; */ OnJava8-Examples-1.0/generics/GenericArray2.java000066400000000000000000000020521374004044700214750ustar00rootroot00000000000000// generics/GenericArray2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class GenericArray2 { private Object[] array; public GenericArray2(int sz) { array = new Object[sz]; } public void put(int index, T item) { array[index] = item; } @SuppressWarnings("unchecked") public T get(int index) { return (T)array[index]; } @SuppressWarnings("unchecked") public T[] rep() { return (T[])array; // Unchecked cast } public static void main(String[] args) { GenericArray2 gai = new GenericArray2<>(10); for(int i = 0; i < 10; i ++) gai.put(i, i); for(int i = 0; i < 10; i ++) System.out.print(gai.get(i) + " "); System.out.println(); try { Integer[] ia = gai.rep(); } catch(Exception e) { System.out.println(e); } } } /* Output: 0 1 2 3 4 5 6 7 8 9 java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to [Ljava.lang.Integer; */ OnJava8-Examples-1.0/generics/GenericArrayWithTypeToken.java000066400000000000000000000015311374004044700241130ustar00rootroot00000000000000// generics/GenericArrayWithTypeToken.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.reflect.*; public class GenericArrayWithTypeToken { private T[] array; @SuppressWarnings("unchecked") public GenericArrayWithTypeToken(Class type, int sz) { array = (T[])Array.newInstance(type, sz); } public void put(int index, T item) { array[index] = item; } public T get(int index) { return array[index]; } // Expose the underlying representation: public T[] rep() { return array; } public static void main(String[] args) { GenericArrayWithTypeToken gai = new GenericArrayWithTypeToken<>( Integer.class, 10); // This now works: Integer[] ia = gai.rep(); } } OnJava8-Examples-1.0/generics/GenericCast.java000066400000000000000000000022731374004044700212340ustar00rootroot00000000000000// generics/GenericCast.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; class FixedSizeStack { private final int size; private Object[] storage; private int index = 0; FixedSizeStack(int size) { this.size = size; storage = new Object[size]; } public void push(T item) { if(index < size) storage[index++] = item; } @SuppressWarnings("unchecked") public T pop() { return index == 0 ? null : (T)storage[--index]; } @SuppressWarnings("unchecked") Stream stream() { return (Stream)Arrays.stream(storage); } } public class GenericCast { static String[] letters = "ABCDEFGHIJKLMNOPQRS".split(""); public static void main(String[] args) { FixedSizeStack strings = new FixedSizeStack<>(letters.length); Arrays.stream("ABCDEFGHIJKLMNOPQRS".split("")) .forEach(strings::push); System.out.println(strings.pop()); strings.stream() .map(s -> s + " ") .forEach(System.out::print); } } /* Output: S A B C D E F G H I J K L M N O P Q R S */ OnJava8-Examples-1.0/generics/GenericHolder.java000066400000000000000000000011651374004044700215560ustar00rootroot00000000000000// generics/GenericHolder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class GenericHolder { private T a; public GenericHolder() {} public void set(T a) { this.a = a; } public T get() { return a; } public static void main(String[] args) { GenericHolder h3 = new GenericHolder(); h3.set(new Automobile()); // type checked Automobile a = h3.get(); // No cast needed //- h3.set("Not an Automobile"); // Error //- h3.set(1); // Error } } OnJava8-Examples-1.0/generics/GenericHolder2.java000066400000000000000000000007531374004044700216420ustar00rootroot00000000000000// generics/GenericHolder2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class GenericHolder2 { private T obj; public void set(T obj) { this.obj = obj; } public T get() { return obj; } public static void main(String[] args) { GenericHolder2 holder = new GenericHolder2<>(); holder.set("Item"); String s = holder.get(); } } OnJava8-Examples-1.0/generics/GenericMethods.java000066400000000000000000000011331374004044700217370ustar00rootroot00000000000000// generics/GenericMethods.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class GenericMethods { public void f(T x) { System.out.println(x.getClass().getName()); } public static void main(String[] args) { GenericMethods gm = new GenericMethods(); gm.f(""); gm.f(1); gm.f(1.0); gm.f(1.0F); gm.f('c'); gm.f(gm); } } /* Output: java.lang.String java.lang.Integer java.lang.Double java.lang.Float java.lang.Character GenericMethods */ OnJava8-Examples-1.0/generics/GenericReading.java000066400000000000000000000025501374004044700217110ustar00rootroot00000000000000// generics/GenericReading.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class GenericReading { static List apples = Arrays.asList(new Apple()); static List fruit = Arrays.asList(new Fruit()); static T readExact(List list) { return list.get(0); } // A static method adapts to each call: static void f1() { Apple a = readExact(apples); Fruit f = readExact(fruit); f = readExact(apples); } // A class type is established // when the class is instantiated: static class Reader { T readExact(List list) { return list.get(0); } } static void f2() { Reader fruitReader = new Reader<>(); Fruit f = fruitReader.readExact(fruit); //- Fruit a = fruitReader.readExact(apples); // error: incompatible types: List // cannot be converted to List } static class CovariantReader { T readCovariant(List list) { return list.get(0); } } static void f3() { CovariantReader fruitReader = new CovariantReader<>(); Fruit f = fruitReader.readCovariant(fruit); Fruit a = fruitReader.readCovariant(apples); } public static void main(String[] args) { f1(); f2(); f3(); } } OnJava8-Examples-1.0/generics/GenericVarargs.java000066400000000000000000000014351374004044700217460ustar00rootroot00000000000000// generics/GenericVarargs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class GenericVarargs { @SafeVarargs public static List makeList(T... args) { List result = new ArrayList<>(); for(T item : args) result.add(item); return result; } public static void main(String[] args) { List ls = makeList("A"); System.out.println(ls); ls = makeList("A", "B", "C"); System.out.println(ls); ls = makeList( "ABCDEFFHIJKLMNOPQRSTUVWXYZ".split("")); System.out.println(ls); } } /* Output: [A] [A, B, C] [A, B, C, D, E, F, F, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z] */ OnJava8-Examples-1.0/generics/GenericsAndCovariance.java000066400000000000000000000012241374004044700232150ustar00rootroot00000000000000// generics/GenericsAndCovariance.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class GenericsAndCovariance { public static void main(String[] args) { // Wildcards allow covariance: List flist = new ArrayList<>(); // Compile Error: can't add any type of object: // flist.add(new Apple()); // flist.add(new Fruit()); // flist.add(new Object()); flist.add(null); // Legal but uninteresting // We know it returns at least Fruit: Fruit f = flist.get(0); } } OnJava8-Examples-1.0/generics/GenericsAndReturnTypes.java000066400000000000000000000007311374004044700234510ustar00rootroot00000000000000// generics/GenericsAndReturnTypes.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface GenericGetter> { T get(); } interface Getter extends GenericGetter {} public class GenericsAndReturnTypes { void test(Getter g) { Getter result = g.get(); GenericGetter gg = g.get(); // Also the base type } } OnJava8-Examples-1.0/generics/HasF.java000066400000000000000000000004131374004044700176600ustar00rootroot00000000000000// generics/HasF.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class HasF { public void f() { System.out.println("HasF.f()"); } } OnJava8-Examples-1.0/generics/HijackedInterface.java000066400000000000000000000007201374004044700223630ustar00rootroot00000000000000// generics/HijackedInterface.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} class Cat extends ComparablePet implements Comparable{ // error: Comparable cannot be inherited with // different arguments: and // class Cat // ^ // 1 error public int compareTo(Cat arg) { return 0; } } OnJava8-Examples-1.0/generics/Holder.java000066400000000000000000000023751374004044700202650ustar00rootroot00000000000000// generics/Holder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.Objects; public class Holder { private T value; public Holder() {} public Holder(T val) { value = val; } public void set(T val) { value = val; } public T get() { return value; } @Override public boolean equals(Object o) { return o instanceof Holder && Objects.equals(value, ((Holder)o).value); } @Override public int hashCode() { return Objects.hashCode(value); } public static void main(String[] args) { Holder apple = new Holder<>(new Apple()); Apple d = apple.get(); apple.set(d); // Holder Fruit = apple; // Cannot upcast Holder fruit = apple; // OK Fruit p = fruit.get(); d = (Apple)fruit.get(); // Returns 'Object' try { Orange c = (Orange)fruit.get(); // No warning } catch(Exception e) { System.out.println(e); } // fruit.set(new Apple()); // Cannot call set() // fruit.set(new Fruit()); // Cannot call set() System.out.println(fruit.equals(d)); // OK } } /* Output: java.lang.ClassCastException: Apple cannot be cast to Orange false */ OnJava8-Examples-1.0/generics/Holder1.java000066400000000000000000000005221374004044700203360ustar00rootroot00000000000000// generics/Holder1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Automobile {} public class Holder1 { private Automobile a; public Holder1(Automobile a) { this.a = a; } Automobile get() { return a; } } OnJava8-Examples-1.0/generics/InheritBounds.java000066400000000000000000000020051374004044700216130ustar00rootroot00000000000000// generics/InheritBounds.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class HoldItem { T item; HoldItem(T item) { this.item = item; } T getItem() { return item; } } class WithColor2 extends HoldItem { WithColor2(T item) { super(item); } java.awt.Color color() { return item.getColor(); } } class WithColorCoord2 extends WithColor2 { WithColorCoord2(T item) { super(item); } int getX() { return item.x; } int getY() { return item.y; } int getZ() { return item.z; } } class Solid2 extends WithColorCoord2 { Solid2(T item) { super(item); } int weight() { return item.weight(); } } public class InheritBounds { public static void main(String[] args) { Solid2 solid2 = new Solid2<>(new Bounded()); solid2.color(); solid2.getY(); solid2.weight(); } } OnJava8-Examples-1.0/generics/InstantiateGenericType.cpp000066400000000000000000000007271374004044700233320ustar00rootroot00000000000000// generics/InstantiateGenericType.cpp // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // C++, not Java! template class Foo { T x; // Create a field of type T T* y; // Pointer to T public: // Initialize the pointer: Foo() { y = new T(); } }; class Bar {}; int main() { Foo fb; Foo fi; // ... and it works with primitives } OnJava8-Examples-1.0/generics/InstantiateGenericType.java000066400000000000000000000021751374004044700234700ustar00rootroot00000000000000// generics/InstantiateGenericType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; import java.lang.reflect.InvocationTargetException; class ClassAsFactory implements Supplier { Class kind; ClassAsFactory(Class kind) { this.kind = kind; } @SuppressWarnings("deprecation") @Override public T get() { try { return kind.newInstance(); } catch(Exception e) { throw new RuntimeException(e); } } } class Employee { @Override public String toString() { return "Employee"; } } public class InstantiateGenericType { public static void main(String[] args) { ClassAsFactory fe = new ClassAsFactory<>(Employee.class); System.out.println(fe.get()); ClassAsFactory fi = new ClassAsFactory<>(Integer.class); try { System.out.println(fi.get()); } catch(Exception e) { System.out.println(e.getMessage()); } } } /* Output: Employee java.lang.InstantiationException: java.lang.Integer */ OnJava8-Examples-1.0/generics/IterableFibonacci.java000066400000000000000000000017651374004044700223770ustar00rootroot00000000000000// generics/IterableFibonacci.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Adapt the Fibonacci class to make it Iterable import java.util.*; public class IterableFibonacci extends Fibonacci implements Iterable { private int n; public IterableFibonacci(int count) { n = count; } @Override public Iterator iterator() { return new Iterator() { @Override public boolean hasNext() { return n > 0; } @Override public Integer next() { n--; return IterableFibonacci.this.get(); } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } }; } public static void main(String[] args) { for(int i : new IterableFibonacci(18)) System.out.print(i + " "); } } /* Output: 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 */ OnJava8-Examples-1.0/generics/LatentReflection.java000066400000000000000000000033261374004044700223070ustar00rootroot00000000000000// generics/LatentReflection.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using reflection for latent typing import java.lang.reflect.*; // Does not implement Performs: class Mime { public void walkAgainstTheWind() {} public void sit() { System.out.println("Pretending to sit"); } public void pushInvisibleWalls() {} @Override public String toString() { return "Mime"; } } // Does not implement Performs: class SmartDog { public void speak() { System.out.println("Woof!"); } public void sit() { System.out.println("Sitting"); } public void reproduce() {} } class CommunicateReflectively { public static void perform(Object speaker) { Class spkr = speaker.getClass(); try { try { Method speak = spkr.getMethod("speak"); speak.invoke(speaker); } catch(NoSuchMethodException e) { System.out.println(speaker + " cannot speak"); } try { Method sit = spkr.getMethod("sit"); sit.invoke(speaker); } catch(NoSuchMethodException e) { System.out.println(speaker + " cannot sit"); } } catch(SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException(speaker.toString(), e); } } } public class LatentReflection { public static void main(String[] args) { CommunicateReflectively.perform(new SmartDog()); CommunicateReflectively.perform(new Robot()); CommunicateReflectively.perform(new Mime()); } } /* Output: Woof! Sitting Click! Clank! Mime cannot speak Pretending to sit */ OnJava8-Examples-1.0/generics/LinkedStack.java000066400000000000000000000020311374004044700212310ustar00rootroot00000000000000// generics/LinkedStack.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A stack implemented with an internal linked structure public class LinkedStack { private static class Node { U item; Node next; Node() { item = null; next = null; } Node(U item, Node next) { this.item = item; this.next = next; } boolean end() { return item == null && next == null; } } private Node top = new Node<>(); // End sentinel public void push(T item) { top = new Node<>(item, top); } public T pop() { T result = top.item; if(!top.end()) top = top.next; return result; } public static void main(String[] args) { LinkedStack lss = new LinkedStack<>(); for(String s : "Phasers on stun!".split(" ")) lss.push(s); String s; while((s = lss.pop()) != null) System.out.println(s); } } /* Output: stun! on Phasers */ OnJava8-Examples-1.0/generics/ListMaker.java000066400000000000000000000006731374004044700207420ustar00rootroot00000000000000// generics/ListMaker.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ListMaker { List create() { return new ArrayList<>(); } public static void main(String[] args) { ListMaker stringMaker = new ListMaker<>(); List stringList = stringMaker.create(); } } OnJava8-Examples-1.0/generics/ListOfGenerics.java000066400000000000000000000006151374004044700217230ustar00rootroot00000000000000// generics/ListOfGenerics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ListOfGenerics { private List array = new ArrayList<>(); public void add(T item) { array.add(item); } public T get(int index) { return array.get(index); } } OnJava8-Examples-1.0/generics/ListOfInt.java000066400000000000000000000011271374004044700207150ustar00rootroot00000000000000// generics/ListOfInt.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Autoboxing compensates for the inability // to use primitives in generics import java.util.*; import java.util.stream.*; public class ListOfInt { public static void main(String[] args) { List li = IntStream.range(38, 48) .boxed() // Converts ints to Integers .collect(Collectors.toList()); System.out.println(li); } } /* Output: [38, 39, 40, 41, 42, 43, 44, 45, 46, 47] */ OnJava8-Examples-1.0/generics/LostInformation.java000066400000000000000000000016651374004044700222000ustar00rootroot00000000000000// generics/LostInformation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class Frob {} class Fnorkle {} class Quark {} class Particle {} public class LostInformation { public static void main(String[] args) { List list = new ArrayList<>(); Map map = new HashMap<>(); Quark quark = new Quark<>(); Particle p = new Particle<>(); System.out.println(Arrays.toString( list.getClass().getTypeParameters())); System.out.println(Arrays.toString( map.getClass().getTypeParameters())); System.out.println(Arrays.toString( quark.getClass().getTypeParameters())); System.out.println(Arrays.toString( p.getClass().getTypeParameters())); } } /* Output: [E] [K, V] [Q] [POSITION, MOMENTUM] */ OnJava8-Examples-1.0/generics/Manipulation.java000066400000000000000000000010721374004044700215010ustar00rootroot00000000000000// generics/Manipulation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} class Manipulator { private T obj; Manipulator(T x) { obj = x; } // Error: cannot find symbol: method f(): public void manipulate() { obj.f(); } } public class Manipulation { public static void main(String[] args) { HasF hf = new HasF(); Manipulator manipulator = new Manipulator<>(hf); manipulator.manipulate(); } } OnJava8-Examples-1.0/generics/Manipulator2.java000066400000000000000000000005021374004044700214130ustar00rootroot00000000000000// generics/Manipulator2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Manipulator2 { private T obj; Manipulator2(T x) { obj = x; } public void manipulate() { obj.f(); } } OnJava8-Examples-1.0/generics/Manipulator3.java000066400000000000000000000004701374004044700214200ustar00rootroot00000000000000// generics/Manipulator3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Manipulator3 { private HasF obj; Manipulator3(HasF x) { obj = x; } public void manipulate() { obj.f(); } } OnJava8-Examples-1.0/generics/Mixins.cpp000066400000000000000000000023311374004044700201500ustar00rootroot00000000000000// generics/Mixins.cpp // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. #include #include #include using namespace std; template class TimeStamped : public T { long timeStamp; public: TimeStamped() { timeStamp = time(0); } long getStamp() { return timeStamp; } }; template class SerialNumbered : public T { long serialNumber; static long counter; public: SerialNumbered() { serialNumber = counter++; } long getSerialNumber() { return serialNumber; } }; // Define and initialize the static storage: template long SerialNumbered::counter = 1; class Basic { string value; public: void set(string val) { value = val; } string get() { return value; } }; int main() { TimeStamped> mixin1, mixin2; mixin1.set("test string 1"); mixin2.set("test string 2"); cout << mixin1.get() << " " << mixin1.getStamp() << " " << mixin1.getSerialNumber() << endl; cout << mixin2.get() << " " << mixin2.getStamp() << " " << mixin2.getSerialNumber() << endl; } /* Output: test string 1 1452987605 1 test string 2 1452987605 2 */ OnJava8-Examples-1.0/generics/Mixins.java000066400000000000000000000034071374004044700203140ustar00rootroot00000000000000// generics/Mixins.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface TimeStamped { long getStamp(); } class TimeStampedImp implements TimeStamped { private final long timeStamp; TimeStampedImp() { timeStamp = new Date().getTime(); } @Override public long getStamp() { return timeStamp; } } interface SerialNumbered { long getSerialNumber(); } class SerialNumberedImp implements SerialNumbered { private static long counter = 1; private final long serialNumber = counter++; @Override public long getSerialNumber() { return serialNumber; } } interface Basic { void set(String val); String get(); } class BasicImp implements Basic { private String value; @Override public void set(String val) { value = val; } @Override public String get() { return value; } } class Mixin extends BasicImp implements TimeStamped, SerialNumbered { private TimeStamped timeStamp = new TimeStampedImp(); private SerialNumbered serialNumber = new SerialNumberedImp(); @Override public long getStamp() { return timeStamp.getStamp(); } @Override public long getSerialNumber() { return serialNumber.getSerialNumber(); } } public class Mixins { public static void main(String[] args) { Mixin mixin1 = new Mixin(), mixin2 = new Mixin(); mixin1.set("test string 1"); mixin2.set("test string 2"); System.out.println(mixin1.get() + " " + mixin1.getStamp() + " " + mixin1.getSerialNumber()); System.out.println(mixin2.get() + " " + mixin2.getStamp() + " " + mixin2.getSerialNumber()); } } /* Output: test string 1 1494331663026 1 test string 2 1494331663027 2 */ OnJava8-Examples-1.0/generics/MultipleInterfaceVariants.java000066400000000000000000000005711374004044700241700ustar00rootroot00000000000000// generics/MultipleInterfaceVariants.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} package generics; interface Payable {} class Employee implements Payable {} class Hourly extends Employee implements Payable {} OnJava8-Examples-1.0/generics/NeedCasting.java000066400000000000000000000007521374004044700212310ustar00rootroot00000000000000// generics/NeedCasting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.util.*; public class NeedCasting { @SuppressWarnings("unchecked") public void f(String[] args) throws Exception { ObjectInputStream in = new ObjectInputStream( new FileInputStream(args[0])); List shapes = (List)in.readObject(); } } OnJava8-Examples-1.0/generics/NonCovariantGenerics.java000066400000000000000000000005551374004044700231270ustar00rootroot00000000000000// generics/NonCovariantGenerics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import java.util.*; public class NonCovariantGenerics { // Compile Error: incompatible types: List flist = new ArrayList(); } OnJava8-Examples-1.0/generics/NotSelfBounded.java000066400000000000000000000011141374004044700217110ustar00rootroot00000000000000// generics/NotSelfBounded.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class NotSelfBounded { T element; NotSelfBounded set(T arg) { element = arg; return this; } T get() { return element; } } class A2 extends NotSelfBounded {} class B2 extends NotSelfBounded {} class C2 extends NotSelfBounded { C2 setAndGet(C2 arg) { set(arg); return get(); } } class D2 {} // Now this is OK: class E2 extends NotSelfBounded {} OnJava8-Examples-1.0/generics/ObjectHolder.java000066400000000000000000000012271374004044700214070ustar00rootroot00000000000000// generics/ObjectHolder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ObjectHolder { private Object a; public ObjectHolder(Object a) { this.a = a; } public void set(Object a) { this.a = a; } public Object get() { return a; } public static void main(String[] args) { ObjectHolder h2 = new ObjectHolder(new Automobile()); Automobile a = (Automobile)h2.get(); h2.set("Not an Automobile"); String s = (String)h2.get(); h2.set(1); // Autoboxes to Integer Integer x = (Integer)h2.get(); } } OnJava8-Examples-1.0/generics/OrdinaryArguments.java000066400000000000000000000014161374004044700225200ustar00rootroot00000000000000// generics/OrdinaryArguments.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class OrdinarySetter { void set(Base base) { System.out.println("OrdinarySetter.set(Base)"); } } class DerivedSetter extends OrdinarySetter { void set(Derived derived) { System.out.println("DerivedSetter.set(Derived)"); } } public class OrdinaryArguments { public static void main(String[] args) { Base base = new Base(); Derived derived = new Derived(); DerivedSetter ds = new DerivedSetter(); ds.set(derived); // Compiles--overloaded, not overridden!: ds.set(base); } } /* Output: DerivedSetter.set(Derived) OrdinarySetter.set(Base) */ OnJava8-Examples-1.0/generics/Performs.java000066400000000000000000000003711374004044700206370ustar00rootroot00000000000000// generics/Performs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public interface Performs { void speak(); void sit(); } OnJava8-Examples-1.0/generics/PlainGenericInheritance.java000066400000000000000000000014171374004044700235560ustar00rootroot00000000000000// generics/PlainGenericInheritance.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class GenericSetter { // Not self-bounded void set(T arg) { System.out.println("GenericSetter.set(Base)"); } } class DerivedGS extends GenericSetter { void set(Derived derived) { System.out.println("DerivedGS.set(Derived)"); } } public class PlainGenericInheritance { public static void main(String[] args) { Base base = new Base(); Derived derived = new Derived(); DerivedGS dgs = new DerivedGS(); dgs.set(derived); dgs.set(base); // Overloaded, not overridden! } } /* Output: DerivedGS.set(Derived) GenericSetter.set(Base) */ OnJava8-Examples-1.0/generics/PrimitiveGenericTest.java000066400000000000000000000023271374004044700231520ustar00rootroot00000000000000// generics/PrimitiveGenericTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; import java.util.*; import java.util.function.*; // Fill an array using a generator: interface FillArray { static T[] fill(T[] a, Supplier gen) { Arrays.setAll(a, n -> gen.get()); return a; } static int[] fill(int[] a, IntSupplier gen) { Arrays.setAll(a, n -> gen.getAsInt()); return a; } static long[] fill(long[] a, LongSupplier gen) { Arrays.setAll(a, n -> gen.getAsLong()); return a; } static double[] fill(double[] a, DoubleSupplier gen) { Arrays.setAll(a, n -> gen.getAsDouble()); return a; } } public class PrimitiveGenericTest { public static void main(String[] args) { String[] strings = FillArray.fill( new String[5], new Rand.String(9)); System.out.println(Arrays.toString(strings)); int[] integers = FillArray.fill( new int[9], new Rand.Pint()); System.out.println(Arrays.toString(integers)); } } /* Output: [btpenpccu, xszgvgmei, nneeloztd, vewcippcy, gpoalkljl] [635, 8737, 3941, 4720, 6177, 8479, 6656, 3768, 4948] */ OnJava8-Examples-1.0/generics/RandomList.java000066400000000000000000000014051374004044700211150ustar00rootroot00000000000000// generics/RandomList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class RandomList extends ArrayList { private Random rand = new Random(47); public T select() { return get(rand.nextInt(size())); } public static void main(String[] args) { RandomList rs = new RandomList<>(); Arrays.stream( ("The quick brown fox jumped over " + "the lazy brown dog").split(" ")) .forEach(rs::add); IntStream.range(0, 11).forEach(i -> System.out.print(rs.select() + " ")); } } /* Output: brown over fox quick quick dog brown The brown lazy brown */ OnJava8-Examples-1.0/generics/RestrictedComparablePets.java000066400000000000000000000007121374004044700237730ustar00rootroot00000000000000// generics/RestrictedComparablePets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Hamster extends ComparablePet implements Comparable { public int compareTo(ComparablePet arg) { return 0; } } // Or just: class Gecko extends ComparablePet { public int compareTo(ComparablePet arg) { return 0; } } OnJava8-Examples-1.0/generics/ReturnGenericType.java000066400000000000000000000005121374004044700224550ustar00rootroot00000000000000// generics/ReturnGenericType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class ReturnGenericType { private T obj; ReturnGenericType(T x) { obj = x; } public T get() { return obj; } } OnJava8-Examples-1.0/generics/SelfBounding.java000066400000000000000000000016701374004044700214240ustar00rootroot00000000000000// generics/SelfBounding.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class SelfBounded> { T element; SelfBounded set(T arg) { element = arg; return this; } T get() { return element; } } class A extends SelfBounded {} class B extends SelfBounded {} // Also OK class C extends SelfBounded { C setAndGet(C arg) { set(arg); return get(); } } class D {} // Can't do this: // class E extends SelfBounded {} // Compile error: // Type parameter D is not within its bound // Alas, you can do this, so you cannot force the idiom: class F extends SelfBounded {} public class SelfBounding { public static void main(String[] args) { A a = new A(); a.set(new A()); a = a.set(new A()).get(); a = a.get(); C c = new C(); c = c.setAndGet(new C()); } } OnJava8-Examples-1.0/generics/SelfBoundingAndCovariantArguments.java000066400000000000000000000016341374004044700256040ustar00rootroot00000000000000// generics/SelfBoundingAndCovariantArguments.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface SelfBoundSetter> { void set(T arg); } interface Setter extends SelfBoundSetter {} public class SelfBoundingAndCovariantArguments { void testA(Setter s1, Setter s2, SelfBoundSetter sbs) { s1.set(s2); //- s1.set(sbs); // error: method set in interface SelfBoundSetter // cannot be applied to given types; // s1.set(sbs); // ^ // required: Setter // found: SelfBoundSetter // reason: argument mismatch; // SelfBoundSetter cannot be converted to Setter // where T is a type-variable: // T extends SelfBoundSetter declared in // interface SelfBoundSetter // 1 error } } OnJava8-Examples-1.0/generics/SelfBoundingMethods.java000066400000000000000000000006061374004044700227460ustar00rootroot00000000000000// generics/SelfBoundingMethods.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SelfBoundingMethods { static > T f(T arg) { return arg.set(arg).get(); } public static void main(String[] args) { A a = f(new A()); } } OnJava8-Examples-1.0/generics/Shape.java000066400000000000000000000010341374004044700200770ustar00rootroot00000000000000// generics/Shape.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Shape { private static long counter = 0; private final long id = counter++; @Override public String toString() { return getClass().getSimpleName() + " " + id; } public void rotate() { System.out.println(this + " rotate"); } public void resize(int newSize) { System.out.println(this + " resize " + newSize); } } OnJava8-Examples-1.0/generics/SimpleDogsAndRobots.java000066400000000000000000000011111374004044700227150ustar00rootroot00000000000000// generics/SimpleDogsAndRobots.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Removing the generic; code still works class CommunicateSimply { static void perform(Performs performer) { performer.speak(); performer.sit(); } } public class SimpleDogsAndRobots { public static void main(String[] args) { CommunicateSimply.perform(new PerformingDog()); CommunicateSimply.perform(new Robot()); } } /* Output: Woof! Sitting Click! Clank! */ OnJava8-Examples-1.0/generics/SimpleHolder.java000066400000000000000000000007471374004044700214400ustar00rootroot00000000000000// generics/SimpleHolder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SimpleHolder { private Object obj; public void set(Object obj) { this.obj = obj; } public Object get() { return obj; } public static void main(String[] args) { SimpleHolder holder = new SimpleHolder(); holder.set("Item"); String s = (String)holder.get(); } } OnJava8-Examples-1.0/generics/SimpleQueue.java000066400000000000000000000010261374004044700212760ustar00rootroot00000000000000// generics/SimpleQueue.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A different kind of Iterable collection import java.util.*; public class SimpleQueue implements Iterable { private LinkedList storage = new LinkedList<>(); public void add(T t) { storage.offer(t); } public T get() { return storage.poll(); } @Override public Iterator iterator() { return storage.iterator(); } } OnJava8-Examples-1.0/generics/Square.java000066400000000000000000000003371374004044700203040ustar00rootroot00000000000000// generics/Square.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Square extends Shape {} OnJava8-Examples-1.0/generics/Store.java000066400000000000000000000043731374004044700201440ustar00rootroot00000000000000// generics/Store.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Building a complex model using generic collections import java.util.*; import java.util.function.*; import onjava.*; class Product { private final int id; private String description; private double price; Product(int idNumber, String descr, double price) { id = idNumber; description = descr; this.price = price; System.out.println(toString()); } @Override public String toString() { return id + ": " + description + ", price: $" + price; } public void priceChange(double change) { price += change; } public static Supplier generator = new Supplier() { private Random rand = new Random(47); @Override public Product get() { return new Product(rand.nextInt(1000), "Test", Math.round( rand.nextDouble() * 1000.0) + 0.99); } }; } class Shelf extends ArrayList { Shelf(int nProducts) { Suppliers.fill(this, Product.generator, nProducts); } } class Aisle extends ArrayList { Aisle(int nShelves, int nProducts) { for(int i = 0; i < nShelves; i++) add(new Shelf(nProducts)); } } class CheckoutStand {} class Office {} public class Store extends ArrayList { private ArrayList checkouts = new ArrayList<>(); private Office office = new Office(); public Store( int nAisles, int nShelves, int nProducts) { for(int i = 0; i < nAisles; i++) add(new Aisle(nShelves, nProducts)); } @Override public String toString() { StringBuilder result = new StringBuilder(); for(Aisle a : this) for(Shelf s : a) for(Product p : s) { result.append(p); result.append("\n"); } return result.toString(); } public static void main(String[] args) { System.out.println(new Store(5, 4, 3)); } } /* Output: (First 8 Lines) 258: Test, price: $400.99 861: Test, price: $160.99 868: Test, price: $417.99 207: Test, price: $268.99 551: Test, price: $114.99 278: Test, price: $804.99 520: Test, price: $554.99 140: Test, price: $530.99 ... */ OnJava8-Examples-1.0/generics/SuperTypeWildcards.java000066400000000000000000000006351374004044700226420ustar00rootroot00000000000000// generics/SuperTypeWildcards.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SuperTypeWildcards { static void writeTo(List apples) { apples.add(new Apple()); apples.add(new Jonathan()); // apples.add(new Fruit()); // Error } } OnJava8-Examples-1.0/generics/Templates.cpp000066400000000000000000000010321374004044700206340ustar00rootroot00000000000000// generics/Templates.cpp // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. #include using namespace std; template class Manipulator { T obj; public: Manipulator(T x) { obj = x; } void manipulate() { obj.f(); } }; class HasF { public: void f() { cout << "HasF::f()" << endl; } }; int main() { HasF hf; Manipulator manipulator(hf); manipulator.manipulate(); } /* Output: HasF::f() */ OnJava8-Examples-1.0/generics/ThrowGenericException.java000066400000000000000000000036601374004044700233250ustar00rootroot00000000000000// generics/ThrowGenericException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface Processor { void process(List resultCollector) throws E; } class ProcessRunner extends ArrayList> { List processAll() throws E { List resultCollector = new ArrayList<>(); for(Processor processor : this) processor.process(resultCollector); return resultCollector; } } class Failure1 extends Exception {} class Processor1 implements Processor { static int count = 3; @Override public void process(List resultCollector) throws Failure1 { if(count-- > 1) resultCollector.add("Hep!"); else resultCollector.add("Ho!"); if(count < 0) throw new Failure1(); } } class Failure2 extends Exception {} class Processor2 implements Processor { static int count = 2; @Override public void process(List resultCollector) throws Failure2 { if(count-- == 0) resultCollector.add(47); else { resultCollector.add(11); } if(count < 0) throw new Failure2(); } } public class ThrowGenericException { public static void main(String[] args) { ProcessRunner runner = new ProcessRunner<>(); for(int i = 0; i < 3; i++) runner.add(new Processor1()); try { System.out.println(runner.processAll()); } catch(Failure1 e) { System.out.println(e); } ProcessRunner runner2 = new ProcessRunner<>(); for(int i = 0; i < 3; i++) runner2.add(new Processor2()); try { System.out.println(runner2.processAll()); } catch(Failure2 e) { System.out.println(e); } } } /* Output: [Hep!, Hep!, Ho!] Failure2 */ OnJava8-Examples-1.0/generics/TupleList.java000066400000000000000000000013151374004044700207660ustar00rootroot00000000000000// generics/TupleList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Combining generic types to make complex generic types import java.util.*; import onjava.*; import java.util.stream.*; public class TupleList extends ArrayList> { public static void main(String[] args) { TupleList tl = new TupleList<>(); tl.add(TupleTest2.h()); tl.add(TupleTest2.h()); tl.forEach(System.out::println); } } /* Output: (Vehicle@7cca494b, Amphibian@7ba4f24f, hi, 47) (Vehicle@3b9a45b3, Amphibian@7699a589, hi, 47) */ OnJava8-Examples-1.0/generics/TupleTest.java000066400000000000000000000022441374004044700207740ustar00rootroot00000000000000// generics/TupleTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; public class TupleTest { static Tuple2 f() { // Autoboxing converts the int to Integer: return new Tuple2<>("hi", 47); } static Tuple3 g() { return new Tuple3<>(new Amphibian(), "hi", 47); } static Tuple4 h() { return new Tuple4<>( new Vehicle(), new Amphibian(), "hi", 47); } static Tuple5 k() { return new Tuple5<>( new Vehicle(), new Amphibian(), "hi", 47, 11.1); } public static void main(String[] args) { Tuple2 ttsi = f(); System.out.println(ttsi); // ttsi.a1 = "there"; // Compile error: final System.out.println(g()); System.out.println(h()); System.out.println(k()); } } /* Output: (hi, 47) (Amphibian@1540e19d, hi, 47) (Vehicle@7f31245a, Amphibian@6d6f6e28, hi, 47) (Vehicle@330bedb4, Amphibian@2503dbd3, hi, 47, 11.1) */ OnJava8-Examples-1.0/generics/TupleTest2.java000066400000000000000000000022151374004044700210540ustar00rootroot00000000000000// generics/TupleTest2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; import static onjava.Tuple.*; public class TupleTest2 { static Tuple2 f() { return tuple("hi", 47); } static Tuple2 f2() { return tuple("hi", 47); } static Tuple3 g() { return tuple(new Amphibian(), "hi", 47); } static Tuple4 h() { return tuple( new Vehicle(), new Amphibian(), "hi", 47); } static Tuple5 k() { return tuple(new Vehicle(), new Amphibian(), "hi", 47, 11.1); } public static void main(String[] args) { Tuple2 ttsi = f(); System.out.println(ttsi); System.out.println(f2()); System.out.println(g()); System.out.println(h()); System.out.println(k()); } } /* Output: (hi, 47) (hi, 47) (Amphibian@14ae5a5, hi, 47) (Vehicle@135fbaa4, Amphibian@45ee12a7, hi, 47) (Vehicle@4b67cf4d, Amphibian@7ea987ac, hi, 47, 11.1) */ OnJava8-Examples-1.0/generics/UnboundedWildcards1.java000066400000000000000000000031711374004044700227040ustar00rootroot00000000000000// generics/UnboundedWildcards1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class UnboundedWildcards1 { static List list1; static List list2; static List list3; static void assign1(List list) { list1 = list; list2 = list; //- list3 = list; // warning: [unchecked] unchecked conversion // list3 = list; // ^ // required: List // found: List } static void assign2(List list) { list1 = list; list2 = list; list3 = list; } static void assign3(List list) { list1 = list; list2 = list; list3 = list; } public static void main(String[] args) { assign1(new ArrayList()); assign2(new ArrayList()); //- assign3(new ArrayList()); // warning: [unchecked] unchecked method invocation: // method assign3 in class UnboundedWildcards1 // is applied to given types // assign3(new ArrayList()); // ^ // required: List // found: ArrayList // warning: [unchecked] unchecked conversion // assign3(new ArrayList()); // ^ // required: List // found: ArrayList // 2 warnings assign1(new ArrayList<>()); assign2(new ArrayList<>()); assign3(new ArrayList<>()); // Both forms are acceptable as List: List wildList = new ArrayList(); wildList = new ArrayList<>(); assign1(wildList); assign2(wildList); assign3(wildList); } } OnJava8-Examples-1.0/generics/UnboundedWildcards2.java000066400000000000000000000021721374004044700227050ustar00rootroot00000000000000// generics/UnboundedWildcards2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class UnboundedWildcards2 { static Map map1; static Map map2; static Map map3; static void assign1(Map map) { map1 = map; } static void assign2(Map map) { map2 = map; } static void assign3(Map map) { map3 = map; } public static void main(String[] args) { assign1(new HashMap()); assign2(new HashMap()); //- assign3(new HashMap()); // warning: [unchecked] unchecked method invocation: // method assign3 in class UnboundedWildcards2 // is applied to given types // assign3(new HashMap()); // ^ // required: Map // found: HashMap // warning: [unchecked] unchecked conversion // assign3(new HashMap()); // ^ // required: Map // found: HashMap // 2 warnings assign1(new HashMap<>()); assign2(new HashMap<>()); assign3(new HashMap<>()); } } OnJava8-Examples-1.0/generics/Unconstrained.java000066400000000000000000000007541374004044700216630ustar00rootroot00000000000000// generics/Unconstrained.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Other {} class BasicOther extends BasicHolder {} public class Unconstrained { public static void main(String[] args) { BasicOther b = new BasicOther(); BasicOther b2 = new BasicOther(); b.set(new Other()); Other other = b.get(); b.f(); } } /* Output: Other */ OnJava8-Examples-1.0/generics/UseList.java000066400000000000000000000004611374004044700204320ustar00rootroot00000000000000// generics/UseList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import java.util.*; public class UseList { void f(List v) {} void f(List v) {} } OnJava8-Examples-1.0/generics/UseList2.java000066400000000000000000000004411374004044700205120ustar00rootroot00000000000000// generics/UseList2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class UseList2 { void f1(List v) {} void f2(List v) {} } OnJava8-Examples-1.0/generics/Vehicle.java000066400000000000000000000003231374004044700204160ustar00rootroot00000000000000// generics/Vehicle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Vehicle {} OnJava8-Examples-1.0/generics/WatercolorSets.java000066400000000000000000000040641374004044700220250ustar00rootroot00000000000000// generics/WatercolorSets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import generics.watercolors.*; import java.util.*; import static onjava.Sets.*; import static generics.watercolors.Watercolors.*; public class WatercolorSets { public static void main(String[] args) { Set set1 = EnumSet.range(BRILLIANT_RED, VIRIDIAN_HUE); Set set2 = EnumSet.range(CERULEAN_BLUE_HUE, BURNT_UMBER); System.out.println("set1: " + set1); System.out.println("set2: " + set2); System.out.println( "union(set1, set2): " + union(set1, set2)); Set subset = intersection(set1, set2); System.out.println( "intersection(set1, set2): " + subset); System.out.println("difference(set1, subset): " + difference(set1, subset)); System.out.println("difference(set2, subset): " + difference(set2, subset)); System.out.println("complement(set1, set2): " + complement(set1, set2)); } } /* Output: set1: [BRILLIANT_RED, CRIMSON, MAGENTA, ROSE_MADDER, VIOLET, CERULEAN_BLUE_HUE, PHTHALO_BLUE, ULTRAMARINE, COBALT_BLUE_HUE, PERMANENT_GREEN, VIRIDIAN_HUE] set2: [CERULEAN_BLUE_HUE, PHTHALO_BLUE, ULTRAMARINE, COBALT_BLUE_HUE, PERMANENT_GREEN, VIRIDIAN_HUE, SAP_GREEN, YELLOW_OCHRE, BURNT_SIENNA, RAW_UMBER, BURNT_UMBER] union(set1, set2): [BURNT_SIENNA, BRILLIANT_RED, YELLOW_OCHRE, MAGENTA, SAP_GREEN, CERULEAN_BLUE_HUE, ULTRAMARINE, VIRIDIAN_HUE, VIOLET, RAW_UMBER, ROSE_MADDER, PERMANENT_GREEN, BURNT_UMBER, PHTHALO_BLUE, CRIMSON, COBALT_BLUE_HUE] intersection(set1, set2): [PERMANENT_GREEN, CERULEAN_BLUE_HUE, ULTRAMARINE, VIRIDIAN_HUE, PHTHALO_BLUE, COBALT_BLUE_HUE] difference(set1, subset): [BRILLIANT_RED, MAGENTA, VIOLET, CRIMSON, ROSE_MADDER] difference(set2, subset): [BURNT_SIENNA, YELLOW_OCHRE, BURNT_UMBER, SAP_GREEN, RAW_UMBER] complement(set1, set2): [BURNT_SIENNA, BRILLIANT_RED, YELLOW_OCHRE, MAGENTA, SAP_GREEN, VIOLET, RAW_UMBER, ROSE_MADDER, BURNT_UMBER, CRIMSON] */ OnJava8-Examples-1.0/generics/Wildcards.java000066400000000000000000000224351374004044700207630ustar00rootroot00000000000000// generics/Wildcards.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Exploring the meaning of wildcards public class Wildcards { // Raw argument: static void rawArgs(Holder holder, Object arg) { //- holder.set(arg); // warning: [unchecked] unchecked call to set(T) // as a member of the raw type Holder // holder.set(arg); // ^ // where T is a type-variable: // T extends Object declared in class Holder // 1 warning // Can't do this; don't have any 'T': // T t = holder.get(); // OK, but type information is lost: Object obj = holder.get(); } // Like rawArgs(), but errors instead of warnings: static void unboundedArg(Holder holder, Object arg) { //- holder.set(arg); // error: method set in class Holder // cannot be applied to given types; // holder.set(arg); // ^ // required: CAP#1 // found: Object // reason: argument mismatch; // Object cannot be converted to CAP#1 // where T is a type-variable: // T extends Object declared in class Holder // where CAP#1 is a fresh type-variable: // CAP#1 extends Object from capture of ? // 1 error // Can't do this; don't have any 'T': // T t = holder.get(); // OK, but type information is lost: Object obj = holder.get(); } static T exact1(Holder holder) { return holder.get(); } static T exact2(Holder holder, T arg) { holder.set(arg); return holder.get(); } static T wildSubtype(Holder holder, T arg) { //- holder.set(arg); // error: method set in class Holder // cannot be applied to given types; // holder.set(arg); // ^ // required: CAP#1 // found: T#1 // reason: argument mismatch; // T#1 cannot be converted to CAP#1 // where T#1,T#2 are type-variables: // T#1 extends Object declared in method // wildSubtype(Holder,T#1) // T#2 extends Object declared in class Holder // where CAP#1 is a fresh type-variable: // CAP#1 extends T#1 from // capture of ? extends T#1 // 1 error return holder.get(); } static void wildSupertype(Holder holder, T arg) { holder.set(arg); //- T t = holder.get(); // error: incompatible types: // CAP#1 cannot be converted to T // T t = holder.get(); // ^ // where T is a type-variable: // T extends Object declared in method // wildSupertype(Holder,T) // where CAP#1 is a fresh type-variable: // CAP#1 extends Object super: // T from capture of ? super T // 1 error // OK, but type information is lost: Object obj = holder.get(); } public static void main(String[] args) { Holder raw = new Holder<>(); // Or: raw = new Holder(); Holder qualified = new Holder<>(); Holder unbounded = new Holder<>(); Holder bounded = new Holder<>(); Long lng = 1L; rawArgs(raw, lng); rawArgs(qualified, lng); rawArgs(unbounded, lng); rawArgs(bounded, lng); unboundedArg(raw, lng); unboundedArg(qualified, lng); unboundedArg(unbounded, lng); unboundedArg(bounded, lng); //- Object r1 = exact1(raw); // warning: [unchecked] unchecked method invocation: // method exact1 in class Wildcards is applied // to given types // Object r1 = exact1(raw); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method exact1(Holder) // warning: [unchecked] unchecked conversion // Object r1 = exact1(raw); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method exact1(Holder) // 2 warnings Long r2 = exact1(qualified); Object r3 = exact1(unbounded); // Must return Object Long r4 = exact1(bounded); //- Long r5 = exact2(raw, lng); // warning: [unchecked] unchecked method invocation: // method exact2 in class Wildcards is // applied to given types // Long r5 = exact2(raw, lng); // ^ // required: Holder,T // found: Holder,Long // where T is a type-variable: // T extends Object declared in // method exact2(Holder,T) // warning: [unchecked] unchecked conversion // Long r5 = exact2(raw, lng); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method exact2(Holder,T) // 2 warnings Long r6 = exact2(qualified, lng); //- Long r7 = exact2(unbounded, lng); // error: method exact2 in class Wildcards // cannot be applied to given types; // Long r7 = exact2(unbounded, lng); // ^ // required: Holder,T // found: Holder,Long // reason: inference variable T has // incompatible bounds // equality constraints: CAP#1 // lower bounds: Long // where T is a type-variable: // T extends Object declared in // method exact2(Holder,T) // where CAP#1 is a fresh type-variable: // CAP#1 extends Object from capture of ? // 1 error //- Long r8 = exact2(bounded, lng); // error: method exact2 in class Wildcards // cannot be applied to given types; // Long r8 = exact2(bounded, lng); // ^ // required: Holder,T // found: Holder,Long // reason: inference variable T // has incompatible bounds // equality constraints: CAP#1 // lower bounds: Long // where T is a type-variable: // T extends Object declared in // method exact2(Holder,T) // where CAP#1 is a fresh type-variable: // CAP#1 extends Long from // capture of ? extends Long // 1 error //- Long r9 = wildSubtype(raw, lng); // warning: [unchecked] unchecked method invocation: // method wildSubtype in class Wildcards // is applied to given types // Long r9 = wildSubtype(raw, lng); // ^ // required: Holder,T // found: Holder,Long // where T is a type-variable: // T extends Object declared in // method wildSubtype(Holder,T) // warning: [unchecked] unchecked conversion // Long r9 = wildSubtype(raw, lng); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method wildSubtype(Holder,T) // 2 warnings Long r10 = wildSubtype(qualified, lng); // OK, but can only return Object: Object r11 = wildSubtype(unbounded, lng); Long r12 = wildSubtype(bounded, lng); //- wildSupertype(raw, lng); // warning: [unchecked] unchecked method invocation: // method wildSupertype in class Wildcards // is applied to given types // wildSupertype(raw, lng); // ^ // required: Holder,T // found: Holder,Long // where T is a type-variable: // T extends Object declared in // method wildSupertype(Holder,T) // warning: [unchecked] unchecked conversion // wildSupertype(raw, lng); // ^ // required: Holder // found: Holder // where T is a type-variable: // T extends Object declared in // method wildSupertype(Holder,T) // 2 warnings wildSupertype(qualified, lng); //- wildSupertype(unbounded, lng); // error: method wildSupertype in class Wildcards // cannot be applied to given types; // wildSupertype(unbounded, lng); // ^ // required: Holder,T // found: Holder,Long // reason: cannot infer type-variable(s) T // (argument mismatch; Holder // cannot be converted to Holder) // where T is a type-variable: // T extends Object declared in // method wildSupertype(Holder,T) // where CAP#1 is a fresh type-variable: // CAP#1 extends Object from capture of ? // 1 error //- wildSupertype(bounded, lng); // error: method wildSupertype in class Wildcards // cannot be applied to given types; // wildSupertype(bounded, lng); // ^ // required: Holder,T // found: Holder,Long // reason: cannot infer type-variable(s) T // (argument mismatch; Holder // cannot be converted to Holder) // where T is a type-variable: // T extends Object declared in // method wildSupertype(Holder,T) // where CAP#1 is a fresh type-variable: // CAP#1 extends Long from capture of // ? extends Long // 1 error } } OnJava8-Examples-1.0/generics/coffee/000077500000000000000000000000001374004044700174255ustar00rootroot00000000000000OnJava8-Examples-1.0/generics/coffee/Americano.java000066400000000000000000000004061374004044700221660ustar00rootroot00000000000000// generics/coffee/Americano.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.coffee; public class Americano extends Coffee {} OnJava8-Examples-1.0/generics/coffee/Breve.java000066400000000000000000000003761374004044700213410ustar00rootroot00000000000000// generics/coffee/Breve.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.coffee; public class Breve extends Coffee {} OnJava8-Examples-1.0/generics/coffee/Cappuccino.java000066400000000000000000000004101374004044700223470ustar00rootroot00000000000000// generics/coffee/Cappuccino.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.coffee; public class Cappuccino extends Coffee {} OnJava8-Examples-1.0/generics/coffee/Coffee.java000066400000000000000000000006321374004044700214600ustar00rootroot00000000000000// generics/coffee/Coffee.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.coffee; public class Coffee { private static long counter = 0; private final long id = counter++; @Override public String toString() { return getClass().getSimpleName() + " " + id; } } OnJava8-Examples-1.0/generics/coffee/CoffeeSupplier.java000066400000000000000000000036211374004044700232050ustar00rootroot00000000000000// generics/coffee/CoffeeSupplier.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java generics.coffee.CoffeeSupplier} package generics.coffee; import java.util.*; import java.util.function.*; import java.util.stream.*; import java.lang.reflect.InvocationTargetException; public class CoffeeSupplier implements Supplier, Iterable { private Class[] types = { Latte.class, Mocha.class, Cappuccino.class, Americano.class, Breve.class, }; private static Random rand = new Random(47); public CoffeeSupplier() {} // For iteration: private int size = 0; public CoffeeSupplier(int sz) { size = sz; } @Override public Coffee get() { try { return (Coffee) types[rand.nextInt(types.length)] .getConstructor().newInstance(); // Report programmer errors at run time: } catch(InstantiationException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { throw new RuntimeException(e); } } class CoffeeIterator implements Iterator { int count = size; @Override public boolean hasNext() { return count > 0; } @Override public Coffee next() { count--; return CoffeeSupplier.this.get(); } @Override public void remove() { // Not implemented throw new UnsupportedOperationException(); } } @Override public Iterator iterator() { return new CoffeeIterator(); } public static void main(String[] args) { Stream.generate(new CoffeeSupplier()) .limit(5) .forEach(System.out::println); for(Coffee c : new CoffeeSupplier(5)) System.out.println(c); } } /* Output: Americano 0 Latte 1 Americano 2 Mocha 3 Mocha 4 Breve 5 Americano 6 Latte 7 Cappuccino 8 Cappuccino 9 */ OnJava8-Examples-1.0/generics/coffee/Latte.java000066400000000000000000000003761374004044700213470ustar00rootroot00000000000000// generics/coffee/Latte.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.coffee; public class Latte extends Coffee {} OnJava8-Examples-1.0/generics/coffee/Mocha.java000066400000000000000000000003761374004044700213250ustar00rootroot00000000000000// generics/coffee/Mocha.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.coffee; public class Mocha extends Coffee {} OnJava8-Examples-1.0/generics/decorator/000077500000000000000000000000001374004044700201605ustar00rootroot00000000000000OnJava8-Examples-1.0/generics/decorator/Decoration.java000066400000000000000000000027511374004044700231170ustar00rootroot00000000000000// generics/decorator/Decoration.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java generics.decorator.Decoration} package generics.decorator; import java.util.*; class Basic { private String value; public void set(String val) { value = val; } public String get() { return value; } } class Decorator extends Basic { protected Basic basic; Decorator(Basic basic) { this.basic = basic; } @Override public void set(String val) { basic.set(val); } @Override public String get() { return basic.get(); } } class TimeStamped extends Decorator { private final long timeStamp; TimeStamped(Basic basic) { super(basic); timeStamp = new Date().getTime(); } public long getStamp() { return timeStamp; } } class SerialNumbered extends Decorator { private static long counter = 1; private final long serialNumber = counter++; SerialNumbered(Basic basic) { super(basic); } public long getSerialNumber() { return serialNumber; } } public class Decoration { public static void main(String[] args) { TimeStamped t = new TimeStamped(new Basic()); TimeStamped t2 = new TimeStamped( new SerialNumbered(new Basic())); //- t2.getSerialNumber(); // Not available SerialNumbered s = new SerialNumbered(new Basic()); SerialNumbered s2 = new SerialNumbered( new TimeStamped(new Basic())); //- s2.getStamp(); // Not available } } OnJava8-Examples-1.0/generics/dogsandrobots.go000066400000000000000000000013061374004044700213750ustar00rootroot00000000000000// generics/dogsandrobots.go // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package main import "fmt" type Dog struct {} func (this Dog) speak() { fmt.Printf("Arf!\n")} func (this Dog) sit() { fmt.Printf("Sitting\n")} func (this Dog) reproduce() {} type Robot struct {} func (this Robot) speak() { fmt.Printf("Click!\n") } func (this Robot) sit() { fmt.Printf("Clank!\n") } func (this Robot) oilChange() {} func perform(speaker interface { speak(); sit() }) { speaker.speak(); speaker.sit(); } func main() { perform(Dog{}) perform(Robot{}) } /* Output: Arf! Sitting Click! Clank! */ OnJava8-Examples-1.0/generics/watercolors/000077500000000000000000000000001374004044700205425ustar00rootroot00000000000000OnJava8-Examples-1.0/generics/watercolors/Watercolors.java000066400000000000000000000010701374004044700237070ustar00rootroot00000000000000// generics/watercolors/Watercolors.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package generics.watercolors; public enum Watercolors { ZINC, LEMON_YELLOW, MEDIUM_YELLOW, DEEP_YELLOW, ORANGE, BRILLIANT_RED, CRIMSON, MAGENTA, ROSE_MADDER, VIOLET, CERULEAN_BLUE_HUE, PHTHALO_BLUE, ULTRAMARINE, COBALT_BLUE_HUE, PERMANENT_GREEN, VIRIDIAN_HUE, SAP_GREEN, YELLOW_OCHRE, BURNT_SIENNA, RAW_UMBER, BURNT_UMBER, PAYNES_GRAY, IVORY_BLACK } OnJava8-Examples-1.0/gradle.properties000066400000000000000000000000311374004044700177450ustar00rootroot00000000000000org.gradle.parallel=true OnJava8-Examples-1.0/gradle/000077500000000000000000000000001374004044700156355ustar00rootroot00000000000000OnJava8-Examples-1.0/gradle/checkstyle.gradle000066400000000000000000000004301374004044700211500ustar00rootroot00000000000000apply plugin: 'checkstyle' checkstyle { ignoreFailures = true configFile = new File(rootProject.projectDir, 'checkstyle.xml') sourceSets = [sourceSets.main] } tasks.withType(Checkstyle) { reports { xml.enabled = false html.enabled = true } } OnJava8-Examples-1.0/gradle/findbugs.gradle000066400000000000000000000003241374004044700206150ustar00rootroot00000000000000/* apply plugin: 'findbugs' findbugs { ignoreFailures = true sourceSets = [sourceSets.main] } tasks.withType(FindBugs) { reports { xml.enabled = false html.enabled = true } } */ OnJava8-Examples-1.0/gradle/java.gradle000066400000000000000000000013331374004044700177360ustar00rootroot00000000000000apply plugin: 'java' sourceCompatibility = '1.8' targetCompatibility = '1.8' compileJava { options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation" } sourceSets { main { java { srcDir projectDir exclude "tests/**" } resources { srcDir projectDir include '*.xml' } } test { java { srcDir file("tests") } } } repositories { jcenter() } dependencies { // Logging: compile 'org.slf4j:slf4j-api:1.7.21' compile 'ch.qos.logback:logback-classic:1.1.7' // You can also use the JDK's built-in logging as the back end: // compile group: 'org.slf4j:slf4j-jdk14:1.7.21' }OnJava8-Examples-1.0/gradle/jmh.gradle000066400000000000000000000004551374004044700175770ustar00rootroot00000000000000apply plugin: 'me.champeau.gradle.jmh' sourceSets { jmh { java { srcDir projectDir } } } jmh { jmhVersion = '1.17.4' duplicateClassesStrategy = 'warn' failOnError = true // See https://github.com/melix/jmh-gradle-plugin // for other options } OnJava8-Examples-1.0/gradle/junit-jupiter.gradle000066400000000000000000000033731374004044700216340ustar00rootroot00000000000000import org.apache.tools.ant.util.TeeOutputStream dependencies { testImplementation(platform('org.junit:junit-bom:5.7.0')) testImplementation('org.junit.jupiter:junit-jupiter') } test { useJUnitPlatform() testLogging { events "passed", "skipped", "failed" } } /* NEW: (REQUIRES CODE REWRITES IN BOOK AND TEST CODE) -> http://junit.org/junit5/docs/current/user-guide/ ext { junitJupiterVersion = '5.0.0-M3' } dependencies { testCompile "org.junit.jupiter:junit-jupiter-api:${junitJupiterVersion}" testRuntime "org.junit.jupiter:junit-jupiter-engine:${junitJupiterVersion}" } junitPlatform { platformVersion '1.0.0-M3' filters { packages { exclude 'collectiontopics.jmh' } includeClassNamePattern '.*' } } */ /* Store test output in $projectName/tests JUnit 5's junitPlatformTest runs as a "javaExec" rather than a "test", so we can't hook into the before/after test behavior. */ tasks.findByPath(":$name:test").configure { File testDir = file("tests") if(testDir.exists()) { File outFile = new File(testDir, 'report.txt') Writer taskOutput doFirst { taskOutput = project.file(outFile).newWriter() } testLogging.showStandardStreams = true onOutput { descriptor, event -> taskOutput.append(event.message) } doLast { // WARNING: if the task fails, this won't be executed and the file remains open. // The memory cache version doesn't have this problem. taskOutput.close() if(outFile.size() == 0) outFile.delete() else if(outFile.text.contains("0 tests found")) outFile.delete() } } } OnJava8-Examples-1.0/gradle/subprojects.gradle000066400000000000000000000022251374004044700213610ustar00rootroot00000000000000project(':validating') { jmh { include = 'validating.jmh.*' } } project(':equalshashcode') { dependencies { compile project(':typeinfo') compile project(':collections') } } project(':lowlevel') { dependencies { compile project(':enums') } } project(':strings') { dependencies { compile project(':generics') } } project(':serialization') { configurations.all { resolutionStrategy { force 'xml-apis:xml-apis:1.0.b2' } } dependencies { compile 'com.io7m.xom:xom:1.2.10' } } project(':interfaces') { dependencies { compile project(':polymorphism') } } project(':hiding') { dependencies { compile project(':com') } } project(':generics') { dependencies { compile project(':typeinfo') } } project(':collections') { dependencies { compile project(':typeinfo') } } configure(subprojects - project(':onjava')) { dependencies { compile project(':onjava') compile 'com.google.guava:guava:21.0' compileOnly "org.openjdk.jmh:jmh-core:${jmh.jmhVersion}" } } OnJava8-Examples-1.0/gradle/wrapper/000077500000000000000000000000001374004044700173155ustar00rootroot00000000000000OnJava8-Examples-1.0/gradle/wrapper/gradle-wrapper.jar000066400000000000000000001635031374004044700227370ustar00rootroot00000000000000PK A META-INF/PK Am±>=@?META-INF/MANIFEST.MFóMÌËLK-.Ñ K-*ÎÌϳR0Ô3àåòÌ-ÈIÍMÍ+I, ê†d–ä¤Z)¸%¦ä¤*„%¤ñrñrPK Aorg/PK A org/gradle/PK Aorg/gradle/wrapper/PK A•%Ó¦¹/org/gradle/wrapper/BootstrapMainStarter$1.classRËnÓ@=Ó¸u1¦„ôEy”@_IikÁ6ˆU‘@.,RuØLì!™ÊGã ü6 ±àø(ı ]t1ssÎÕ¹÷ÎÏ_ßxŠ½ó¸³ˆ»îá¾M|4ži£ÝsZ«}.à穸k£ÞŒ‡=eÏd/c¦ç‰ÌÎ¥Õeié0“c“ ”=<ÚO¦õ±b»í+7.Pÿ£ômïB%œÀÚßM• Ñ-°wźláƒ6i<øZ2³93Ööìèê³#ð‡Ò±w¹Úºl hÂãâòø¹æx8F×èE´‚v~ÿÄ—ê9à½P%pw8Ð.ÑR3êSò ѵ²ÜAcî+jŸgèQEoN SzéÝB£z÷±Œ•ªÄjÅ\Ã:­‡ÛØÀ zQ^ÅÁoPK Ai,«$ -org/gradle/wrapper/BootstrapMainStarter.classVÛSWÿsÙ°,ˆ1*‰‚±BI/µV°V(Ð-m´Ú.É!¬nvéf£Ðjï­½<÷·þ ö%Ø2µÓ—v¦“ãô;»IIb¼ÀÌÙ³ßõ÷]7ÿ>ýý1€£øIF2^à C˜”0%cïÊðA•0#aVF —d\Æ{2æǼŒd\ÁUq¼BNP®…p]ÂR2"¸!c7%|؉^|$A aQØÊ‹£ .aIÆ~ †¢„eeÊ4¹1´r™—‚§tSwN3øÉ+ þŒUà ÛUÝ䳕Ò"·çµEƒ(aÕÊkÆÍÖÅ{èw–u²‘T-»˜.ÚZÁà黶¶²Âíô9ËrʽÌhº™u4Ûáö8C ,® ‰ëê-펖64³˜Î:¶nÇ=Šn¥/èwñhv‘<ìl#Ì {.'­aénVfèð¸ÓšMèó–éðUÇ [µ´'bÔÓ0¹“^˜SXB¹D¨]ÃŽß.I¸üî,[†Xƒ€Í— žwÒ$w7'nm¥ž¼H«ÙSçI¾‹r•¿=£­¸btr6±šç+Žn™e ·¨:KºYPµŠ™_æ¶_¢%u­ÉPŒ-q iûõgôÅóºMÐ-{\f­Šç‚I‰jWË”0 `ƒ NãÊÂV8sÓÑKüØ «bâ¦åÄ Ê‡ÃãÎ2_t+¯c‹OŸ‹ëf\Ðɧ¾XâCƒå¡CÏ–“K‹·­„Û ”ò³ç9%¥9 ,¬HøX Ê©£ ‚; îŠc«Ö|‚OÜÃ}Ê.µwÊë¦TkÊ)¢à3|N­*Z‚RÛRU_àK_ákê¤zÒ3†U梾 ¾Á`\­4‹T ä[ßá‚ïñ€¦ì‡làˆ‚ð#ÃÐ+*0ô>¯iò¶X åìiFZ$K–]Òh²O&žÕÆñõêVoÑæ‰ÞÕFW¬€c-ÌM‘ßD²qh§Æ›ë:U“TŸ‘T…ñ–ÊÔ;#RäNv­ìðRózH$['tk=ÊeÍæ&Å›¬o²º§çh‰8ò6¿lsÜ•¯ØÂPý=ÒäÖ£ ðeîdÚ,±Xâî: º×¶Ø`»Ô¶Ùl"´zñϼ¤”žNòEë/¨›w¬Û¼¥-j=𒶨‘¨¨y1/ [Ö\ûf òUÚe÷“v¡S/7,¶ƒxBY|·šÍ™ZI,<ñJ¶ìG xâÏ&–¯Ó[šžŒžá °_é² Ct]b :OI Ó“a£$EÊì$úî>¶ÙCÿ w¾\Øïÿœo4ûÁ Hn"”#RGÎw¨ ¹ŠNb(Utm {ÌÿÛ£þ*z¢þðŽ*Âch ¼“¤#9_xW¶ŠÝcÁhyGè}ÏÕ¨ÿ/ô®CŽúC”A€ö» Sè¤s/A݇ô¡Ÿ~8Œ#Ž E¯Rü7q%Š½BÑß# ܤ@-8q;Dv˜{Kã0À*ŽÐÍG¶ÎÑ¢cäM%Ê8N¼›äãMœ „½UK•Ç;I¼1¢D°í ú%Ğↄ„ˆDvN¹˜Þ¦ŸDôí©Õâg¢ùèy|±Üpxïö©#Uô­c€ýëèÙÄþÜâU˜ý]£ý¿@õ}Ⱥ¥iˆP8T©(Õj@§ ö1*BŽ“Ü ºqg)öæÁ?ßð Þ2Ç õhÁ )¥È˜$NÖᔉÓx± œ‘š³&Îa¨Ã15ð’‰(^Žœ™ú˜ÈaTŠóÆ \00Îq¼rYø yÏ/§Ë>/9"½äó…á§óʘa¨+ G”y ŽnwpØ[r—.ú^Ù•JÞ®ÂU®{|±h{ÕÊÆá…0°៴];8Íp>¹ Ç‚ì™by%âÚ”·]q¡:?+üI>ë¦9ï¹3Å}[>×”á`ή0t‹+¼ê;Ef°r.­C¯T9œÚסÿˆF¥I”j¶BÀƒjehŽ»eQbhIæ¯òEžvE¾4‘ËŒŽÊœ ^*É ›¢EÏ¥ A^¸å`Ž*;Ê`®—£„P¼6Æj'$Ww½¼, ^–S‚zr «µXõ}²<Ú3é¼o{éÜøÈõ¢XlÏ%mTÙbÕ¡)yÄMÅ¥v7^Àuš±MŠë*³àUÉ'kK–Ñõ8ýÐÂ~\´ÐŠ½ÚÐna:,E?±ê7ðŠ… ,Æ‹Þ›g LZ¸„)ÓÒò*•uÚ û”Ö¡Ò§'ªn`Ï‹ £Dœ1ðš…×qÙ¸làM†Ìÿè:%½‰7>{U©:½1Þ ZRv¨}Ç·…^ªµî2« ’B£ñò âíªp‹"Ó³ÅpV–ƒ‘yˆ^!ðm·Lƒ·Èª¿BOæ¶:® §øvÁˆcrhGœ¶­Ô&ç|oIdj›†1.‡B›ç×å årr†´y›ÚÖ±KÍÐE·aÄšåÄÐõ×,‡†ÖœZÃdß$ÒÓ,é5Zã©°Tï2B©¾eh)má;Ê«“d+t’Ÿ“ï¨Ç—hÄW„ô5á~ÊÝ8¤®Û¸Âej'‘C´§Ù¬á½}Á®ú›ïbOêChŸÁLuµ†W “¼y QR†š#Á˜–æO“K/ï¢.ÉJS¬ ù ]ößÖw”Ý÷„ôúð#Nà'Å.Eœ mƒÝ žBR±DYCj׫ÎõÑ^‡µšÞ¯å5ÊÙ˜™êì^A}Ìtæô„~ GˆY8¡¿‡’sB_…I´c‡ï¢!„éTB§*ÞFÓ þ ¢3íú ïßQàDЪ¥ñêHþLEý…ó+Žá7²ÿI'~G`©TŽ¹F"Ÿ¦Du²˜tòiÕ˜ìFzY•S;™”¦’ªƒ6p΀Õ@yÑ QËk‚²’ÞñXIë¾ÑyË£éÚ;«Ø³Šæ6ZQÑþÞ¡ÕÇkhq<§ÐBÄ\z>'Õ?/]>ÈS†æ¿PK AѺNì,À4org/gradle/wrapper/Download$ProxyAuthenticator.class•UÝSQÿ]D×E‰PSó#5TPûÒ4S1ÊB%PÓìe…ÜÂ]Z–Ô¨gëœé¡¦/{èj¦éÜDG‡{Î=çwÎý³ç^þ~ü`/ExÐ'¢ž/ôW#€ ×D bHÀM÷ ¸åÀm.‹aF¸ÇÕQc"îc\„ xª SB Ucª¦šã ^߃=¤'†ºˆª)s¹5ÅX×ÒdqGô„œ^’ •ï F»¹®fÉ5ô­íÉœ¹®h¦šMÝ`f4M1Bi9›U3ÑT0eÈÉ´Ü4äLF1‚Óú¦–Öåd÷É£ M)ÅŒRø¦n$K|ª®1ty}‘Wò[9¨)fðtepfxÞ#7/ŠIËZ*7 UKÈA SOèi†j ¿˜Uˆ¿3nʉ׳rƪUÀ4C§÷Ì"Gym[ íçĸž3JXå}t¹œŸ„4JxˆGK˜Á O0+aó åULåÔtR1$DñŒRŠeHˆa^@\Âje wéösz)ไe¬pj/$´£CÀ*Càÿ¾)CCñœ2Gë™ýbpÑ,Ä”79%Kð…í oZÙÞ[:ÇÒwCRó»/‚c¨ŒÆæ—Wz.š·„%}•ÅX„L¥¬ÈB(©tÏPÃǼ8‚ž#üñ!­â-Ñè‹õ{OºOF‚O·©šˆJ j;k*ų©Ûæ6Õy¡Ü”tøàC]å6"aê¡uÙ˜4 ™Hؽ¾Uz—O9b5Ä/XË£‚zëÁ°ñ{†+´ ’¤qG¥¶÷¤ØÐDk•eüŒfð«`Ђ6’v>ä…à/´³“\öçQñöwˆV™GUdÂÊ.½yT»EZò¨Ùƒ4Û÷ ¾R—óÐå®ÝCÝÜ>\+}ýy\Ú…{‡ø\Þ±èr>môx_!â;Üø~¢ãâømñô—0œ¸†NŠrc]¤1ÂúÑMš3-TqݪˆýAÜêÆBA#$m…n°Ó»Ñp(äáš—Nàa~ ß‹V’ÍÄÀC ®ãs9èß©ቦPK A$É~ãX !org/gradle/wrapper/Download.class­Z xÇu~±KpyA%è„eÐ’u’–l‘¢$H¼D”)Y’WÀ’„báÅB8Žíȉí(vl'qœ¦n›¦n›8‘œ”EÛJÈ­Ý6é÷HÛôH´MO×½’°ÿ  @B´Ó¯ú„Ù™7oÞ{óŽfWzãGW_#¢-ü¬‡VÓïyè}«½·Dóû¢ù…þÐCnú#1ø¶àúc•þÄCJßQéÏúsUÒ_xè/é»úý•hþZ°ýhþÖC»é{ ýBï¡:ú-¡ï{èËôbúŸDóÏ*ý‹‡^¤UèßÄómÑü»hÞÍxèKôŸú/úoÑüO9Tÿ@¥zèG4£0©ÌÚÄ%e$þÔUp)»<ôE.SÙía…UHàrA)WØ£p…‡¶Ñ·TÖðäJÑT©\-ž5BR­Â^˜Í‹D³X4KDS'š¥¢Y&ŸÂË^¡òJíçZl„W©¼ÚC'yÊ~•oRy­ Þ §ò: òz•7xèë¼Qåz…7 RƒÊ*7)ô…›=à•o26+¼Eá[UÞªò6•·«¼CåÂÆ]B{«Êm*ߦòn•÷¨|»Êw¨¼W,lW¸Cá}LZ07¬Ž˜žLI¦5ûŒ=³÷™ñ˜©Gú,sÔ2’É®hÒ6ÀÈäéÜäÞ”=fÄíhX·M«{÷ôí95ÔÙ öö€­ëý¬ÞÓã£-!ÛŠÆGÛ˜*;ÌxÒÖãöK*w2U´îßßÙ*<†K‰ê‰©ª¯¿÷@g(tªã d—ŠˆÁºŽÞžžÎŽh85ìîì8Õìê †:1³/„Åk˜|ý{÷e`rÇÌÑQ±]¦5Ú2j鑘Ñ2a鉄aµtÉIXª`Ü£Lô† +5ãL5‰yþh.&çFîƒd÷mÑxÔÞÃÔ^¿€ó½7Ÿ²iˆÉÕaF`duW4nô¤ÆOÖ€~:fÿ›a=6¤[Q1vˆ.{,Š ¯ZÈd˜h.hÙ³Ý÷º•a3>MYÆÜì’n/­L•![ŸéÖÎnÔˆ£‰QŸ‘7ì–Áþ £%j¶ìÆ ©AÑ#aR«)1’v4îèª*\‹è<6b‹k²:ƒqÛ°âz RIÃÚ;j8YŸNŒˆÔ(9ÞÅñÔx¿!Œ¬°M[uñQ{,O’É’ø"™Í°3%T hð ìZ–ov )n„…Q°¡ô¦Ùé>cØÑqÃLÙ9ãÁWŠ1S]nƒ½);‘²CÇtIj–äfƒñüI%©ƒVlŽÿºÚÞ¯ð…*Tø‡sÌQ¦Õs³i®óWB“q[?W`sJˆ©CôÚõd4<736 ü|'‰ð„sc$ˆZ0>bOëIcûÖÎxXÖÒ†ú"9Z ÍjF ;³Èê6ì1!^žÇg#1hkÉÌ_3$s–WÉ ­B¬ì=}»JжõZº‹ ®%y\ù’Œ;òÝ2«ÐYš·B"|—œ@Ⱥ˜jáTL·Áœ'ÖVᶥçâÕ„N˜vã-'Ëiq}Q A2âqtTdÀÖÎNåhn3™âr3™OÜk…Q4ž™²Â†(V@D‰BŽFÐÑ<¡ÑéA¢”FSŠ©m[÷.g $r·F¢ó}Œž@Æl;Hä›W¸Gã^ºŠbÉÙ¦ÀBz矬BUŸÂG4îçÆ<¨ñÕèYzJ£Kô’Æwò0ð3[´ízŒH~i;ò!-JÈ?&šãßÅ'4ºLiÞ 7áWap³ ¤Æ'ùNÌl×ønÖ5>-š0chðˆÆ£<¦pTã{øŒÆ1a÷çæTD²Y©„mDŽklr‚iQxzsé³<«Á?¡'ýy Âì„Â÷jlqRc›VRø¬ÆœÐøœˆÌšwEÔÈÜülOEc²zj³šAôXæ¸_ãI¾O4ïCñûGt83Òê·325~?½)lº•ž_Eü€h>(¼ò è=$š‡3+>ß.€‚€•Y#ûq*@aÞä¢ýÒ¿múº•4üB']§×™Êdþi|ža:toO°ç€0)vtp` Ï/1Õ_ª~ó¬aùõ8œ4Â8’ý³¸)”dÏ-?ùÈtðGPVôtJðü}1ˆ*–%£p¥?•S  F…:ÓŠÞç@¸;c„F/ÓU?ÌÑøQ~ ›@d,Ð.ZãÇù£HÌYØE…ÍA8/ðÇœ„Ï_».·¢*»f&ÜŽž|ðUø ŸäÃû›wjü?]À—]º¨"3ùõ\àÜx,p:öé¶nO& Gð¬<Ók`gLkÇÕÚd:‘ŸoEüšôODí±âMúã¦íO¦ j"~Ð&ŽþCCÝð»7Sº§t3xTWHìsð\$ù3BèÀY®5gäÀpuf8>KQÌd s:xÐ+ ë°W¬O¶¬Oúë×'ÛäßMy]?ÉŸœAšà¾ÜmoÕB º÷¡[²%è@N¢bwl¿øu!ŒâyìùuÝUþ1ËœÈ\K—=t™ÿ¿ÝªÅe&?'A°ŠÂ/–Ú“ò,_ÐMRÊìþç¼Ðy’†íƒˆXÞµ €Oʨju ÄŒ«k²‡þìÚ=~&µ’ò" ee›Ò9Îì]…Q?ÿêî«/~csUØn¸ÓÓE>¨èIâ˜U¾ßÒGÇå ;ñž’w>%ø[&¬v£€ôXrN>dÝt,c¬D>Ô|¿Ib[¦6  Ñ7ŸÍyU“D®8âÖ¿K ³ „c³¯YwYs|Þš|)ó^Ü–ÝhΈÆÏšg¿]Eœq|á4Ê½ê ‡µOÚâû[]±ŠÏ+ë;JA‘³ïqîÓ×í9VÙü “»n¢ÕtŒ˜L*'Ù”Bÿ,•Ð-§s4™߇ñûòÆïÇøþ¼ñ0~ `ì¯cè{Å™|>ì<ñR…§¼Ð‡Ñ~£A*#žå ÜÔøùm^!Ÿ™DøIÚˆö <~)x\ÝHØ>$f?5Qi;€4D4‡0{Ô;i57§0ÝE#tuµ| iz7Ò1ŒhFèyÌ|…FišÆè :ôº—¾K}+¾~›ÆéŠÃš¯£{yY ›·PŠ·Óüyy²…~–>5 ´ßOÏÑga èø `F9ôž¥Ï¢çö$öôôŸ;4¬6††kÜMh”æЊ_œsOyv^……Ó¸h½‚KÝ«¨‚×pH\“{;˜1ÈÙ›ÂoÈÈhÄoʽyqLü–Ü›Çÿ7ä=Å*ú&ze³~=78Gjþ] „Ë_)àZü£»Š¹Õ8$ÄÿX 0÷ü/PK AyL¢¡Ê1org/gradle/wrapper/DownloadProgressListener.classuÁ ‚@Eï+ÓjDËöEÐ@Û–EERûI¦ˆ#3cþ[‹> Š4Úv‡»9œ×ûñ°ÂÀƒç¡O˜Äª.r%ãÐJ[™ÍM Ç„ñ,Èä]Š‚­8Ÿökߟ_ÃPU:â]š3aºý©G­ÍÆ©±\°^¶&a¡t"-ãœE­eY²ÿÂè›Ë›¼8\3Ž¬K tÐŽBNûÐkØûPK A!9|¶„ 3org/gradle/wrapper/ExclusiveFileAccessManager.class•WÛsWÿYÒÚ«u|iªVÍMNZ*;±•JŠlB×NåKœÆŽ[—t-دvÅjÇÜSšB[(·¶ÐP`x¡ 3íL«$x†ô©Ì0à }á…0¿³+9¾%L=öÙs¾óÝ¿ß÷íúOÿýýÁ¯t<ŠgZ ãYµÌjxNG_ÔpNGϨ×Ô Íx^mMEœSKA-EµH ›1¯¶ ::`éÔvIÃb3lIÅžDIGŽºqu”ñåfxJ_¥~O¡ªc—u,áJ ê§íÄñ–ñ _Õð5öñÉ¡± #ùñá SgGFòÏ tŽ_2/›YÛtæ³S¾g9óý­C®SñMÇŸ1íªhñ­’t«þDE@äv”]ÛÎ;¾ô.›¶"Æ,Çò Ä2ù|÷Œ@tÈ-R°mÜrä©jiNzÓæœ-•=·`Ú3¦g©sõ,jÉŽ»Þ|vÞ3‹¶Ì.yf¹,½ìð•‚]­X—åˆeËÁBAV*¦cÎKŽÆÍ€ 0˜ ã°Ü¬âëOUß²³×)T=O:~vÈ´me±¿{]Ô“s—dÁWÊ䕲å-3ÄQºd»…EÝ!£C½…Óq¤] 0ŠE•(¹Þ;&f£*2³B5ûþ?ÍÊ^¨¤£±}Òò虫\j÷L§è–ÂøC¶‡ÖlÙtGuZÝÛ5Ó[" äMn,Ér¹Q–‡ïíõÀôtÿ1•„)ß,,N˜å@LÃ×5|CÃ75|K@gùdÙ·ˆ'ÂhÊšwL¿êQ÷ÄÀtnkŽ}¢2†ts¥óÒŸ&J',ÛVXjÊt³Š%syNÙnE>]µ¤o3•É;6‚‹ÄlK¡q¸oF3åV½B½ÖûîŽÌ>%l W Ä!½8$`¬ÍÀ ø¶À›»ïDÕ²‹Ò3ð"®x ßèýD]AÌõÙ…EßU úð²Wðªï©åûx•À¹cóLÕQ­½V$ÃCnÕ.¦×O#€&¤A7zxŠ N5@¸ïT3„Ï(ïúåz˜§Yò4©}Ï ˆž] Ò³û4½?ˆE¹vqÝÀ<Ì ŠáÓøLø¥˜ÁNŠpÿ8>K.š‰ü1´â‰DgÖ[A|ö4n›khéLp©Á¸ÖS½¼ÍESÑv\ÇcêÙöêÙ~]+蘭ËvvRˆÜ÷5dwÞ¹˜ÈÅÊý=ï#rÍ<ª‰\KªåT´¤öúÛ8º‚äloç7ð`.–ŠÕÊÅSñ WÿšŠßÄ®TŒ U4]»‰Ýï¬~¨Tô®7½‡6•‰övîãþà7ÝBZ §§Hè Ò«@'¼c ¥¿›KlÏ“¸3Ö1·™ÿ¿ãcÑƶ‰õDQDDwp>¨žäPõzp}”ÕÊ@8B gmγ*& _$W™Ô ëö+ôkôŽrÖ}¿F¿A?~‹Ô(µ‚AZÆÇ8‰ðÃñŸü:üÆ°ŠqÁ¤Ð8­ Ó›“"‰¼Ø…Q±câï?… z5)“çqj…™sDP·hí hô F›9Òˆ‹Ž¸ë§uì>cÄÑ~êþiMȈvz5ÀHMü¾ ªŠø †ð$?b‡)n¬IŽPò$)SÐþƒã¢üݳŠhÑ ǧB¢†¤†<£À¿q¢ÏÒ0¶Ê.Ò¶åƒÃx½dÐ(§øÇWW½§Žw@óMì߉¥ß­5S< Ÿ ’a„<õÀuõ.«ËŸç3ôäGhí¹…GÞAtü=’£dl¥Ù¦@]± …ùßéçysŽýùü:õmŒšO• ‘ ²¼8x4ó?PK Aì„,y†-org/gradle/wrapper/GradleUserHomeLookup.classSÛNÛ@= $vŒÔ”K J)$´ÄÚÒ E¢`@"\”@¤Õ-Þsc-ÂÄg¥ØOˆN™QMž} (1ŠáìÁ#Šj€ RŽ`뛿Í€i­õm¹õßP/ÊQ«ðWM:‡Ü‰â;"¢¬+) Q¤gc@'Q„)‹f! Ip @"p€å´Hw·bo’8=N%ŤډÓ;RN² ½8½÷êôÞCÇÉ?»§Ó•éË÷¡¹7oþWç½yüá+V‰ ž¡b3ž©Bųäðl9Ü­à9**$¹ÏUð<Ï÷ã~¼PΫx^ìÇKüx©‚{TÔJÆZ\‹/Sñr¼BÁ+UÌtɯRñjÜ+aï“ÃkäðZ÷ãu ^ïÇüx£ 7)x³Š…x‹Šx«‚·©X,îÇ ôãí*Âx‡Šwâ]òëÝrxÞëÇE?.©¨Äûäüý*>€ªÈ`XÅRñ0F|HÁeëqEÅ]¸êLJå†øñQ“Ÿ—‹ŸPñI|ª ŸÆg<"9?+!Iþ>/‡/¨ø"¾¤âËøŠ‚¯ªØŽ¯ ÌêØÛÒi?²¯§}ï‘ÎîíGºw÷vuïDNè§õ¦¸žhê±­Xr`ƒÀÔV3™²õ¤½_§ PÉö¶öÞ–®H{[§.˲g_W{oŽ:¯€Z²©bc,³7 ”…ö øZÍ~J«‰Ä’Æ®tâ˜aõêÇâ†TÒŒêñýº“ó,ÑgÆRK"¦5Ð4`éýq£éŒ¥ VS‡3=àÎvê±$ò%ø+03|¨ÔdGºn ¯ÎcY@Í"o×-j—#f6m‹Å ®VY&협’Å2M»-FÞŠ!ÝJüX˜¯g4kj5 =Ù/Ýíð¨2j&OHnX[¼¡ç\Ê6»s¢òZǶC1‡ìãç!Ò‘ÓŸ·ìÓRE°t‘k_ÚŽÅ›ÆéÒNk•í4´³"n HeçzE!â,r_M–Ò~Öˆ¦m“ü‹¼ørI··Ÿ®9 ¾ÎàèýýÅn¸)\™Œ­êJr•^PÄÞPÎÚ¬Bù2¦…KØüqf¥Ô-—IÃnÚ··‹k‚ræ{Î%mýlÎò„òm—Ù×S©6ãø63ìo·,Çþ©=¶=¹Srr^Á7V…'Žj‰ª[&µéF!T{Ì´5ÜôžYr¾VHLˆ6óL2nêýö¢GÑÖ`#¥á(è×ÐD§BÃ7ñ-ú¿øP2‡&sð ²NsÙ–§ ¸|Y áÛøŽ‚ïjø¾OžSå§Ò1ÃXý; ?À5ü?Vð â§Ì¢ñCÔ©§D ?ÃÏüBÃ/ñ+ 1àš˜kŠ˜©‰Yb63R1Gs%qžÌB¯{(¥Ìù,‰ã2ò\£å;NÖÍxÜ<³/y2ÉÃØ=Ö…&Ó”*Ì,è:ÏÖyˆî\©›ˆ‡)2¨§Z¬tÂHÚ©–Õýòxl m19—Ô¸Rcd/(w:òd­ñl™yÛœâÀB=`ØùíböX»(m¢J¶Ç lDUÎCaÙÐP4˜î%FÞ;Òv‹¬p1}°pâîKx wB·¬)i¡“jç…õ˜Ò`xßÓj‹e“vø†À^u¬+y®”OG€b8VÐôC^iã)­ٞk^%בs‹çU¦ØÅmª“—W³:¦æÄw¦ÒÄrRZ·xݘWææLº±ô.¼%+dÙ¥Ë;–fCq]Þ¬ùׇ']/ÌúÉm¥WjÆ©N­uM§Ñ6Ë4ëE›é¾Ž)ŸbH­˜}®©˜gÃXé¾.‡ëù^qïE|ê” Ž¯oöõÖXùˆÉ]%sM·xG6ó ˜m:E½ˆS^;gç;«wÐ2ÏÈ{£ã¾žè á\ÛSi=NÍÈçwûÙ††ƒdàÑOè ÜíÞ?ä±Ç+r3<öJMÜŽ•dæÉÆì6ªR6`8u¿Ð¤1 ó™ (¥RiÛ̾¾œL•¤â¾SR_éö±ä©1ݱы>aíÎu©%“ãä‹‚ŠgŸÜ^µŽ‚×WÄ4O¦‡x½ lØ›!ÿ—ð!ˆvB`gSPÅywÞ\ã|wÞ¼†ó=yóiðó›7uŽ½¤4ñWð·¼qS.9,û8V8ÄösÔ\Àø[‰>$7‹{¨TiWGPY:ßNå»FQÑ7 ¥Ùôeà?ô•_Fe_Y ª§ÏÐz2˜šAõ8¹F’§IòQÔrg ¹€A(”u¯Ž‡ÇóÔâNíõ‹#Áp$9&¿ùöÈF9J¬)Ò2:rá¾Æ@Ã0G°”>Ì’–æ‘ÆRMÅ€m¨C–Ð|iÔL •€óuÔ1J•/¾¬ÀµÙ´ªbü–¹ÿ.%׎¼äªrüBØ9ˆ–,ß,Gá –óoE )°2ƒ[‡±ª®;nVŽ¯Ñ,Ü£tÔ»7 f°:ƒ5¬Íà¶`jdëû–ãö«ÑØÁÆû0[›|—±¹¯¬±g[†qÇU:¨å!l¸ɪÕ6Œö‹r “g6Ñ[ ™£ÛüªaʨaOÑ<ž 0ù‰ÚuPÏNYêÞÈÀÕpßiœá¬Ž;Ïâµï¤Ugñ$~Ícª¹«Oæ_-|{¬{ • î u)ªÊGgÖà>'€ª ¶Ý‹énä9éÈ Sª=‚.éƲ¼P÷S¬9̵qw.prÐZ1‡bø¢ÍŠYŸS=ŠíD¯¡¨aì(ŽÎÉ<¸ê,œ`*K®§ÿPK AúâæªÛ"org/gradle/wrapper/IDownload.classEÁ Â0 †ÿÌéæ¼ ^õbÁë®* AÑ{ÝÊØ(í¨Óùl|JìTf $_òçÏóuX ï¡ë! ø‰®”ÔÌai'$|TÆ:Ü/Ó ?&áãNJø„@ÅÕXaXQÕГ7é†&° ã°zDèV„çÊ™&¦§œ6ÝX”›Ùú`ÚÑ-³×6¦˜L͉ôv·ÓeLµÌCz~@Få@º«Yá%üHÁ™ë'ø©„Ÿ)ø9~¡à<~©àWxLÁãøµ‚ß°þß"N˜iÓ ÍavÂyܲ‘ 'ð; ¿WðüQÁ“ø“‚?ã/D\˜„¨V+mĪMË©N›·ëÉjJ jÇ¢N4 „º55e™-$õ¯|à¿áï žÂ¤ÀÒiïu§MGOhSBÙWt„ìäå³%+i/ÆŒÀ•³‚FàúKLÑ\г¥‹Êva:PÑ™^hw4*\–ó’kQž—–^\)¡6jkªãæ®À†’•¶dœQŸ|5\$çÇ5g—ʧöò@¢y—šÐŠ³pú6`Ù&•‘ÆšewÆRæÄr,oIàÚšRe¿¸~—멶Ð\s©nõ”gçB²së`Ê2ÒŽ¶Ku†È1j4ª¥è¢ZIWU|ÎWPá1æP™³j›YmÃlj 9ù49ÞUÌ[:–¥y‹c™‡ìžc)G£«Ü§Ùvþ±‹NæÐù45‘gõjÖ¼yΚ !±¨„BR’gáyq)¤P€ƒ1.(Ìe%ÔOßWßU½¶N·qMᡶøm”;ÖšguhéwXñ¸ Öpg/˜ÙÀ¾¨0Š„aŧM[˦mš»ií9‡l¼H›vX(65¼ºÈc…Àá „(÷)ß÷Xô²,JË|ˆ®{v³‹˜g>BúT᫪ÉßÏD¢‘†ÔT—v”j›ßt»œ7°s1` tù.U½z’ÿÊ{ÒÍ„×z¶e÷%Ø’øK)y9XÁÆÿû튢u’,5N V>]¤æêE¾#¼+§Ká%TÓ—N È>+*ø)P¿%ÛÓƒÈíéMäöô,r{z7Ñ7¢~;ð|ân§ÑÊ Q]]ýD]ÃÊêÇà« ûÇ௠ƨ Ǭ‡ôQ–áfjƒÄ¬Ä-ÔVÑI@ºwÄšèAÁOÚ#=¾[`=eòY„úëDYóÎBîG¹7S2˜_¹€š ŽÓ»—V}\6ŠõõTŽ¢™/z‹&pygÃ"D]Õ©ÓXBý„‰~iŸ'´ò>Hþðû6ÓÜ?e]ËG1<« ˧Lhñ‡ýYQbWfI+¯"‚Æ ®&¢ ª½ÍkX|ØÏñ!ì÷¤]Û—³x+ZÜÝç ´Â3¸N`›yt½ çe¨%X¤¤†”„ƒtLÏš¬¢ppµ}'þ;™•È .ƒzÖG?ÚlÈn”yjOඖ@‘è‰ô,dá•+½©/;m.P˜Ç¶Š-"…«§Âœ>òG=„ç†d©k-«&°†â±¶Ïœ:‹uý<ºb7LBˆƒ"!’ô1ïw1u7®qÿ‡QƒÕ„ï5„§µè¡û}4$¼Ç ß#„òã„ï; Ý' ߧ ݾ#Ì=I¨~íb nëq‹Ø†±]â v‹ö’¦na£GÜ=âzÅ#Ø'Σ_<ñö‹‸€[]L‚Lú—a7ö‚ORNõ’v?É®Ç^IÒ~ô‘mFuû5âqôÓ®Àˆ¸—rk?ñ÷àYìÃÓ¢/ÀA’r ®äi¢÷ön#O¨´Ò ùöIIè~ æßHv9BÂà,–•{­‡%4ý þQA#6? :T±•Ò.î¥"n‚r8ƒõ§Jf¯âdO0%†Ú!—^Ça·†áî%`¢“F•´¶Þ_7­ö@þPK AØ ’$|-org/gradle/wrapper/Install$InstallCheck.class•”]OA†ßi·]ºÝB-~ ¢|K[*[ šÅIŒ&E/0MðnX†²°ýÈn«þ#o¸ÐD¢ÑÄK/üQÆ3³K[J 4MÏÌÙ÷9ïÙ™Ý?üPÂ#qäeXNP(Èð@¦+:Šr\5@IǃQõø¾+^6j‚a´|ÄßsËiX/W<¦ Üq۞ؾϫ´"¬py½jí´<§^¥Uz¸ŠÁ|U÷[Üu·…}¬Òºð¶\îûÂgØÌ^TçÊ ¯j&¬o6…g…”…^ÕѶûTd¬ìÔÅëvmOxoùž«\5lîV¸çÈ<¼¨×ÎLë~Û¶)aØÈžïp˜êñ'NÝi=e˜ïƒ hªBf[‡U¦‚áøá9ŽØgˆfsïR;-noófØ”ÁU' «Å"C!{e¸dE>»€’l è?g 5 Útþ%ÏÚR}u2eÒØi´=[Ȳݶ"!&nâ–‰Q\3a"eÂ@ÒÄîêXgXº¢#¸-ÃC†t×Û›½#a·&ÿQ›TÁ ½Q zñ"ÈH4ËH;4&('w JÙ:4šÆOÄwYþôÏJ5N1.ï° \§¹¬Â Å0d“ƒy6€0uŽ¸‰ÈCÂ.eQǨüH~ùZ¾pŠè—&C%À¦¡±$Ø,FÙœBÎ2Lâ fÎÔL6¡=ù°Ìså½Tþ+´ßеOТ't!Úãu±Çk*ߣ ‘ä3–Á4U xVÈ‹‘íØI_Ïã=œf%‡Äs˜¿ &3ýl°x‹ÄÑ«‰ïwv¼+þŽÈeâ”/u6»WÌ.ûœU1‡´Ú}úd„6êPK Aävp£.- org/gradle/wrapper/Install.class­Y |TÕÕ?'³¼ax,‰„0lH +aGb“$%, ÔêKò’ŒÌß¼1 ]´­µ­­ZjÑV­]è‚­¨$h*ÚÚZ[—jmk­»Ý»}Ú~~¥Mÿç¾™É$yøûø…ûÞ»÷ÜsÏò?çž{ç‡ÿ¹ï-á¿i/çKS ÍÒL‘¦pš©ÒÉç´ •rHãéâŸ<¤ ϱ™ÒÌ òl>SšpçðÜ ೤™§qq¦ð|¡_ qI€Kƒt—i\¤é\¤»¹RzÊ[•¼-Òxq ò^¤:^&ŸË¥Y!ÍÊñtŒÏð*«exuÞËk¤óœ¯•ç¹A~׸VFêDúuBX¤"^àóä¹Aㆠ­äŸ¤UXÒl’¦Iøl–©[üNéÙªq³ÆÛ¼=À;¤cgjù]Ò´éyÞ¥ñnß-¯é|~O6ò…_¤ÍÂ}#n•6iVjܤíljÜäNî’&¤Òsqvs(À{ä•fecp"ÈÝ|É8¶8)*ÙNÉóR¨GãÞ u‰U»¸o<½Î{¥y¯Æï RŒ›¤y¿~@ãË4¾A H'íIªÑ#X¤9Ò7ì”…Å„×k(IÓ®ïöl1àÓŠE’I‰ÄàhnP4O°8-Ûï€ÊlßjíN2MÚ퉔ūZz}Š¶­¼Q$?ðénE"Ï1æ+!i¹6‰:œ°‰Òc dÄ›³Q»:ë5£!Ž%­T7ŒžK2ÁR]"3âˆ?D +u_ “F’;#qlcÐÕSRº j%’M†o\»5%ÝZ.ö¡–L©íRâ+ÐÖu,À>c·[žðîý.NÅ÷F ñ™®q–럷­¾¬”1µ Y¬^F$­ÁÙ!Á’a²9§_2£°Š²Šr˜ÕÇS13›Ú=J,o»)û‹¶7“*‹Æ®î@’?¡ñ'Õ¶Dw_N¦bZXâšÁÜes ³y˜Ôù×üË¿CIêZéôgþ½ÎGþ‘ÿ”±ð˜²Mç×$õýYÜW®Êz“iÆ[€sq’[NæpÚÖe%zœãßÄ‘Õ jô1ñ1ÂQ9µ.Ó·RT¤ì.ih§›ÁÜnEPwšöHí'—”Ž¾™6Š(ç¢aJ‰ëÕBødvgºðt®ÞÖJÁ(±Õy(«ÞðKtÙë•+Þv¡6Òj§¬œ{é7Ò'´׳–ÂvW€7»ª ¸F\ô8å•ñ6h¸Øåú ô$×;^ ¬]𵻶TnŒRÝí†-µ:ÈùÚ¢‰$züíéˆð–”ÊuRþÈ,©®?ÇÛ‰ ÷@…% ®òã<Õiw)lËšb;9 Ï(©KŸ½8ª8±vnä;‘‘C‹$ëcÝ6N­þµ#¨“Óf»ÇZØUül;Xjös\Å:õó7Ù ëzàÉ1ËúÙ-ìk !`toB!Öl–-˜$å^£‘Š£(°6è™í~+3%Y}–¤Ï”£ÈO]¿y êÉq%.¶”‹ çþÂÉN5­ÉD4e›äÆ‹ÙëdüqriµÞ¹ŠÊǨI®ËÔ¶°§ÑDuò{C,1ÂÔñDµiÔ‘fj‰Ë…‰Š†¤XZÄÍuÔðíÖcDlÔØ Tlædò¢œ5òušû儬wÆðPú–Kzµê*kÍi!yÌ…˜¤ÈM™ÛÃœš »šJ Ò‰(ó=r[pzWËU¦PR§ØS ÔÌU[è„×rõ’èYKö¡šŽ9™oKº€gšJK®ÎprvhÙXä.p{söG¨œÕ*›5&zÖ É™5ri\×ÐfïæŽ`ºAÝB& ¹^Ë…Jr½5òBlR—‘Ü”°Ìú¨ƒ[ ããf¯þíŸlÑ`.ç ÑÛã\r‡†‘5æò«*W××{'‚°¯Û‹Ish/•‘BôºŒ˜.ÇW} äÎïr¡žWÒ>õ¼Š®Æó Ð^CEû1|]^<ç• Ð¸²A ¶ŒÏ§GH?BÊÊVVq„üe•GhâaµÂÇÑN'?Ú¹˜¦)td˜G³©oóéZŒ”9<éôI"õ&2±z©òÔ›ÈåAïut=zDš£$ ϵåý4išÉMe÷ÐD¼äW{CÞ~*¨öÉãŒj?ú'„üƒ4¥¥,äù*Ê+¨°Ÿ¦>HEwŽ’³:–sd­¤´’/RrnpVËʹ–n OA"­¢ýôip Ò2ºöõ`n}†n†f3 çgés šK3é¼ùéVÌöbæm˜ƒã¸£ß¾FöL;J¡Mƒ4½¥|€f4yVxó'Ó·Õ¾BoÞ­4³2ä맙+¼…Þ[†þZòy ¡ä¬ƒC¿ªì§ÙI¯öËKÈÿ@E?Yí¤pËÍ©öyVø ý!ï±ÛiQ> …¼…þ¥8Js«µÖOgyo£ñ!ßäEý4ogÈ']Å;¯ðóÁ¡'d¹ùwBÈIt6 Ï¥õô(³í B´P«@çb¸xIQZ@12Žy­¡$fYTçJQõÐNê¥Vê£n´Þ @¾°ë…‰/W&ï€I “/Ðaœx~‰¾ Svãý ­Ñ.ZN_Á¨¸nÖ5ûé«04 =_£¯+Ù¯¤Ctdn¢óèàâÅêké›t'ø X—‘6¶~öjT¤Ñ]ÝÍÝCô&Í^¯Ñ‘À(ß…ù8ÍרîMš0•ý4†æxúDþ2xÐ×Ty/-`:@S J¼÷Si‹§¢ù(•¥ò;1RÌs+†*Gyyˆ šRÕ÷A´h‘ ,¾SÉ ¾˜OãÐ~z_ ÷!ய¡Õ=Ý {\„ºVé«$ÌÚ¬CÁ”ÕÛQØ6\.¢{é>ØìL5e´¤Ú[)!ºô&Z ´.ÛY°\S –7·xѱ¢¹ÅWÙÜÔŠÂÕ¾AZÙò ÐÙÎâÏÑy?–»‘Æ#è¦ÀÐ!ºI¡f)žg3µÀȵ*dýøÒ·¡ŸÔ+é;x“ôS—µC=¤R¤¼I¸æ©·ïª°>¬’(ÿ s5ü=œu|žŠáƒ´ QW-iiõZƒÇš&h½´Rœyl…Œ…¾ÛiŽâ'Ï9@zEH»—Öæ‘|/VŒvî×Áÿ ~ýM€« Z-Þ7„ç.¦|(—Ñ÷é(ɲŠnL;<€™â漬sžûÑ# —“gILËÆ1~€?†‰f Ð=ÙåbI§âÿcô¸³mÀ€~%úCØ6Î=@ÞÃTÔR^ðŽªÙÄMƒTÛâ¿ŸêZ<ëàõ‚zø®_ß<@ç9y|ò8rPÃZ?H[éüùn MÔT¼¾¶Þúûé-Õ‡©(¤lub%hî§æÈbâmMi¦Ãv^±S¥wõS‹tì…±Whƒ´ß]pA?½G`ˆG?]ØO†6…°«h»zÞ€$âÀpME{¬=ûÝó(¿MÕ€Y-`µ0ºXÙo\F?Àü'ÁéQècðÉ“àö8€üöa_x Àý1fþDy´p݉Ýè ŒIðƒþ)¬ÖE³@uÖ\J[éiP{±ÞùôSú|s hŸ¡Ÿ£o?<û =«ÀþP©°FA ýB½¨z. öz †°n ãcüÕiT«ÑómÔPè8ÍFŸÁ›KDB´$;'„Áöz1]DtáKbjzq”Z~jo,/0û©#ï‹äóòÊÆv÷ˆþs˜÷YÀý9eŒ©‡´:M¤—TÌŠÈBzž&äÉï+éUÂ’ïV–«0[ˆGç&ÏÚYØç”)@VÌZDW¶Ö›Èç9t…!øH— ‹4WÅ÷K°üËXøÄÖ«ðÅ/‘f…­îZBÈF`1¨^ŘÎSÛ”sæƒò×J•Y?¬¤ß(?ˆÈóoš¨ÑoyÖ›`’'¿¥K„§°¸DÒõƒÔ%ÅAÄAòŲÃì‘&‚—(v1'fâ¨H”«Ôë§n„ÂÓƒt âÈj16@ɲQ-…¼Ò• ùèR‰©žƒ4Á‰®žöÀÁ¡OÉ¢½ÒPo¡ò±—.ÀÎoA:‹lõ Â'RLîÃ.´/kÀ&€è/ýM¦ÿA®~ÆùŒ÷O:‡þ—ÞAÿ§ƒ×%X¸ ô>$œËØCW°—öáy-ž×±O{+ì2ÞÓÿ»»ÕŸè5x|2jŒ?c-I|×g}=ý5½Ó]ô×áË¡ " ÿ©¼Êiÿ¦É½Ž8;NUņVµœËº5zƒP,y“Æå Áë¾,‰ Q‚ç|£fb‰Ì>²bü&pöÙj®ÅùØrMå¨èf¶¬ðÞL+*U½×wpè5s6²SÏð^¨JXŸÇS>ë4“'¡Z™Ló8?gÏ/ÎZ¢ö¾CY¢UÎkjÏwj, [Dÿ§ê®Ã*ÆòŽKmtÏq*äa¡'à­ãi¡ë1K,­••co WÖ~µÄ %BØ!ƒ4úOÚ-eGvg`‚Ó®"VT>ÉÏî¬u‡ÀaÉyìq™ì?µÉ^@Ë™\NX~U̹Ïv’?«•ßÑ |üð½ ï¡Óäàqi3ou$-`fœc<‡]99§ª@–Sœœ²&;;eM€ƒ*ÓçZ|<`ãæÎ<÷eÞÚŸËq'°Âx¢›1Ø÷ ŒAy@5èë÷+Ì{prØKïCìN!çßžƒÊoÜPK Að¿:öo4org/gradle/wrapper/Logger.class…“koÒ`Çÿ—UncŒá@Ø&s*]7¼‹11$KHð’°`²wÏÊ“®³´¬_ÅO¡Fgâ ?€ÊxžRŽ5KÓÓçrÎÿw.éï??h G ·b¸‚Û1TP£†º4w¤¹+ͶUÁŽ‚]†èÉØ.;`XxfX†ûœ!R9¨öèÓ²û‚!Ý1,ñj<8Î>?4éd¹ckÜìqÇ{ÿ0â#†bÇvtUwxßꇇÂQ;¶® §É6m!Wéó÷\5¹¥«]×1,½)Ê@ŒF\÷s ©®Ëµw/ùÐ'.Hq«Ï°3«×:âNWœŒ…¥‰fuæâ…ç-Ce"Úè„!ÇÐÔl·U£#—;²›m"x©*­@o¦ÑÛbˆwí±£‰=C•˜ôj[Æ$‘B#‰’ î%qŸc”‰±I![3ŒÌ”‘¡JgŒ´ÇXó&Õ¡ovÂHIFií ó” Qª¤V÷(µIØ”’õ)rµŽ /‡,®Ó*üœñÈåàꊧPæ¹*qw(¤PÝ&nü_Ý–7Û›PK AJJ¯'ï8org/gradle/wrapper/PathAssembler$LocalDistribution.class•QÛJÃ@=›¤­ñïwjÅ7EA(*(‚¾mÛ¥nIÙ¦Š¥`|ðü(qv[Ī ¾ÌÌ™™3sf÷íýå@ËY¤0ƒmf]Ì»X`pk²•\Ê&Ãp¹Áoy ãà@†b§W*IÅÞ•‘Lö–sýMýhýœÁ)Æ5Á0R–‘8jßT„:ã•2~9®òðœ+©q/é$W²Å0fj%Z§d¥È8bð£H¨bÈ[-A-ÛåXÕƒºâµPwŠ7›B'<¹Ú§ú Sk?†Ð ~]$_SæœÑÜú÷[³ÔG¯ Ó¸­ª¢ ü¾%[šç!ƒEp=¤áºXb(ü_ 1*BÕƒãJCT;§_qå¯iX¥OLÑÏZðµŠ|-ˆ¼ Fú²d ]P‡M~$ÿ –ßèÀÊov`?ªghYI¶A´k #ÄeVº4Âc€‰ôxf"½Ð¢ØÇxoM@^×Rù'XŸÃÓ&©Ì@¯ÛÐÈ0ñ+ÙþN¾ÿ…laÒØ)Œ’ק:˜#]™PK A´çtx7‘&org/gradle/wrapper/PathAssembler.class•VéÕ=cKy<^¢Ø 6vPœ@dI¶šM›˜”Ø2‰À²]oÔ `FÒDžDš1³$viKiÓB÷–®iéBWº‹¤·¤Ë·þM-¿Þ;3–l!ø ÷î{ºïÜs—wçýûí7ßp ÿ’p?Ö;0 MÂU\“H*ñPæAaðö/žaJ°Î;KvÏ×%ˆ¸ÁÛ›!Ë5Am%-«lø…Òcªeãº:½i«ºå†= »Ñ(:B†bèW‚Ãß]µSË ™}BÀá]6Kõ¢ÞÑ&ð *? î$%ÍMÈÈþj\ˆç˜.Ž™Wy“ŠOYó xHÆœñ#iüXÆ“xJÆ*æe<Š,ÝíÝÈ2~‚WdäQ [ÞÌbÒÑJÕ”ñSÖù~NAIÉø¯&ðK¿béU¼"àÔû/zÆøµˆßÈø-~'â÷2æ0O>›~PÄdü¯áO2þŒ×ô¹ìÊ„™šÔŠÝV‹Lí V˜@•iÕlQ» ŽnkeuןCS†S*DuÃŽ®SÁF5}ñ£^ÉŒ3ömr›„¿àMÛø«Œ¿±ÛÛl.únn èmî2Þª¿)Òu¨Ž4SÄßeüƒ5RÙr…œ‰RF5+êè×tãñím83—»ªæí=[‹~©Ÿx÷˜ÇF› õ`Sœtk¯/Ö²à›•Ù"Ϧtªª±÷týýRãff;>kêÍ-€V¼»DíÌãè/<÷´<¿»ÓßÝ"JiŠrÉPˆºh)WÔeSp¤õÍoDLÞ½&ÜÿÓ¹¼®’q¿y¢|rÿíÛúÂÜ?¼îˆrÿ 9Å&¸`ìò$»*øÖB±Œ·ÓË´L`¼Õg ±³´n7¸_ºë¤7‘/¨›sW²wò¿Ãrr;M÷P,ÓÚ."übQŸq”’Õ„çU÷ÙÑK{ |˲ղÄyÓ ŒÙ[ûY¡7Î(=Þ€v àƒ8 ¢Uâ´þð®u’~Ô3IÓµPÏÑê~ššƒñ„×\ÕÐ(Ñ #€#x˜$ÙSÂyLÒÌS>À#¤ÉºÄo ­ÒM´€(¡EF\¤Cž¶ÄÓbiLû˜o“%‘æ›ñDí5²ñd ÁÙøX¢†Ð™À6ÄUþ+\CÇ6¤Õ:i%WÑé¦a @C=5ôž îèأ٣ëJÉÆ¡Ð6®B5ôUêÞ "Dc üPî¡F‚¢Ä&Æ\Ï.zœëžÝ¤Ø\ :ð,ýwšPzà CR;-Ó·ê4EfŠô£ GÆ I!Ò¤ï˜ ‹VšOĉ`ûmôWq¨†Ã³ _<úcýJS O’ÑS.½¸S§wÂ¥"¸ezwaÖ¥×Æ_*ŸÀ«tŽOŽGîº,œM’µ»·1´ RÃ5é=^Å=•ì6Ž®FF(WÇî¸ÈG)éQÂk„ï<“è$·{)á#”òcdù=@!Ñóÿ£X û¢E,ÑÙc$/cÅõf¼Î~»ì?FrBN$;müðY_¥“\|}‰Q»÷¡¡—LTíCUÜWqï sŠ¸ž=F‰›!+Yt‘ß»%ëž­[ëÃ%ךH—ñYòíþ]ô<ãˆo÷y:ɘƒ§Ù$§æÞsÃdg:Ɔ¾ÏÙV¹¥K9#½ªÛ]QÛ¶ìÎÍ”nv¦-m•¾Î½†v^g-£*6`Ja©Èà#Y­" GANÅ lª¸‰”Š-|,Ðûì÷ƒg+[ò *øDŧøLÅ縥â |©â+|­â|+ÐXyvyÊ) î'ð1MnÄBʶ6‹w{/(æè¶æX,£Ö(~> WÙ¹Ê## IŽÀ±=×þ›(¾DÚÊÊWFîÙ$v tð$õ0;©À/èÓð~Ç*˜x¤BDôV©`ª -nýµ|/âº#·¿ÿŽÐ)ãÚÅøy­eðǤ2FIiÙý&Ñ^ÓÊ«,=A•5ò²ñÙ¶ì’áð¾´Tã‘mªMëfRص/}6·’-Æ·„bU ñ$eñgþ‡èRevXà|ø3%Àóò_ ๡~Šcg5hçOÈW‚ò -aŽ‚£¯÷Äï.¤›²Ö5¢T ô —cúÐOƒÅ_ð ü¶‹šå{ðLõæáý¾¾»»ðÑP;½ e™™ý3ýyÔñ؆:â•JÐ{3»P—wÑ@ô¡æÃy42ESÍ÷pä~GwÐ"03°ƒV;¸L¥M`Äôæq¬¹=çî ¿4éÈãøˆ/è£öZú‚>×u‚Þœô`iûÑNß]xÈG7Yø κcÃA=·#7?£”ÇáÇ ÆI4¹lv1ê4ýÝ$ Ĩn¼Ìq˜³R!9K€MÏ-²z›™À9üBÔ¯r‰œäWÊ)´5È"è î,µÛìÊ9z|Œ~…_=/±’ÊÈ!Ž~üLë0›Ä÷8WIþH±-_„Ú÷{ÉÿM F1µWÁU>…Ë ¯=€ÿ’‚úŽ‡¨SpñL<`¦×Ý–_b†qW»üPK Aª=©°?-org/gradle/wrapper/WrapperConfiguration.class“mOAÇg¡ôÚãJKŸ|iᤠ" HULCß-œåH¹’»«&~*M$&¾ðø¡Œ3w ”e›˜&3³3óŸýíîõÏß_¿ Ë:¤ÀÒàaæ’`@EƒG xLá<™2OÈ<%³¨Á’ÏŽxN£8m—ÁPíˆæ–kÖöÖÖ3Ýõ5îÛ ²QO‹»M«Ž5·)÷½çÁ!ƒBwª~È+ó õÎ1í«sM¢(ê/;®¬0è/•wÄ^´°ž®9®ý®sÜ°½¼Ñ ÷nïóÖ÷Z‹d,8t|åZÛkZM´lë‹ÇONlÏÚü‹¶ûÉiv,.âsñmâìî£nsúô =ÌN æN8¡u‰ ѽÐÆØq$&ƒL*AîÂ=HL)£ÆìBCO*A4dF r_ ¢É s¨©ôÉ )%È  2¯)©AeEÔ,õÉ ²$!ƒÂçX Ìþywã ¬âyõ%^}9„¯°úÏ3à 2¦y~žÉOȸ¨`;¾Êä¯)Hãƒ^V0ƒYWðõ^”а¿;98ÐÝ14ØÝß724Ð3’èOt K÷×Njí-;Þž´-#;¾[ÂüN3›·µ¬}HËt eû’]„rbbßàAqy1ypßÈ–mÛG’C½–éNŒ$ûº*=” 8%g™9ݲ =/a©£zÁ62í‰â9©¿ ÄuÀÈþ NÃlç=qÔ¤Ìì˜1.aCi·[Z:£·Ÿ²´Ýk?ìÌ‚§`i¶aféRݘi‘œãzÊÞoX4šÖ”„­ÑrðÛ!vÖSºF`N3Mš-ì1²z_arT·µQÖ5Üc¦´Ì!Í2xï²Ý®\ò)éá&* Ÿ´µÔ‰^-çÞ«Ùcd {¯„õZú»nÃ! ]«÷$E×锞s=°' r|Ë™¸4gé9ÍÒ÷yJ¬Ñƒ Y†„EÑ Ž€¬n· ts@òfÁJ•BU¢(Eò2æÈDK×ÒÒ²2t!cjé„'-BF–Y×&‹vÑÝÙ\ÁvŽwËø†Œ—d¼Lî×m¯z¤”^B<úÿd‰¬ )G£Go..?¤n.¶LÆ—Öaš6é§åz5¶K³lÝq hÖ8Y[ç#ƒ”0H M·(aɨþ-ÊÂW ÃvÐœ$›ç‘ûÜ`Pm¬‹Þ¬Ü?}U·b§ú4FÙásïN‘Òú˜VÈÜè\;ïéˆ/TÈÒ,P¡§©(ŽHždHW)¯(±MËî5òyb-Ù«$E;µ¸¤¢"6² Íÿ»vÈ o±JˆVð;Û6w»±ÔîT â›$Ú¯º™ö-†T|ß¡Æ]²y µI½XjZ]"%ðÈ)Y¿6¿>’6i›5íˆ~šªg#•M «”;•Šïâ{,í5Ÿ;¬¯ÃëUÀkUD· u=‚£*®ãû$$í)Õ-¯«ø^Q‘ÇI?dIe ÍžPñ#æø1ë½Ää„F/Q²0©â'Æi?e6õ!#—¤(莄Ÿ1õçeøLø%ê|º%y°Ó,dÒÂKÜ¢"§|j™“¡ÙS¿RqŒmý5ÿ¿Uñ;^ýG©Q¥Ëšh†&Ÿ…}#YÜŽI¯§7w<}EüAÅñ'æLÇQQñWüMÆßUüÿ”°¯ÏŒˆDœ2ì‰È }ʉx>§§Œ1COGŒ¬¯)7rƒ’a…W¡äTÖÖN{üRçÓ“Ë|88a™§œ÷«ÄÛïAXTY¬Öø¾oeÝ‚zfu”Ç‘´y±¥º®¡çtR³ý{…·»:‰íßvêý:ÉZ˜¯|`GË_8檫x†8󨊣¾¢êò~Ì•œ£7ó:§Ë+x‹µ@¤ü-I Ý:bäqJÞ»q(¸Kq6±Û·ßb¤…j &™šÐù˜Ïï};dm§?JßpõEö¤“›)º@a Ú¦¨ƒÅ•führ%’•Qßæ¦2&ÛÔxëg“lL¿->lDÚÜé×ÁM6øuF¿g–ôÊÛºߊ C±šþ!Ì£BµhÀ^ÜG»×Ю ›h¿Ï³_FûÏ~í;=ûU´ßïÙ7Ӿ˳_‹0·kZ‡¹c‹™z8ÍóIvz‰³v¨¡Ð0ixUñpõ,sÏ¢fò´€ë§Ña\‡ªs oе(ŽC´ÖØ BÏbùj‡ÃJà%Ì®Ž%¯@Åü«,,V.£ZÈX@3#Œ8šÐæ‘Õêš‘¼RMô`:B¥ûéB€N¦c³X@À xÑe,Žµ^F8¿Œº8isOÆ[¯`IìQfQ?ƒ¥b^ÆÓ –Ï¢aÎÙ ç¬Iœ­tÎV9gw‘‡"3Xí6;‡kc‹s¶Ö9['ÎÖ_@cŸpÃÇ qvCÛ,bW/’þ<…guÐE4n"kÖÐÿÅÍXBÿ™èeÛ(¦Û‰rÅ}îÇNLbÅnº¿—öà<îÅ ÿ„pa€öKq‡…K§éÆ0 VìHI¬8Cª„K—¢ê?RMÁ“Q%Ó¿Vš£tʯ<Z‹0«hn!çÅ{È£­×9o(g.¡nmt²‘rgíÓñRHÃ"2„¸ü ÑLòŽDÆrõ â.<€7’^¬MÒ«h–Éî7Ñ.@§#Ä}¬¨Éâ "áð¦l¾%Þ4‹-‡çp÷°XnŶÊÌê%úPG ”2kµ«‚›Yu™ è¸2Ÿ&"[²rÛ‡É÷ôÆ[g°ƒ~;/@éã¹M´–dÕ客ÔäT­¥P, Ia’UOs#ÍMä\Ö#"t[éf8¯80Œ´£HyCTÏ!âøÈHsˆôš¢ºcô£/··ÐÌÖ…œTÜUYÇÇ<¹0ýßîÞòýÊËãžËÁâåã8áú*C9ö­ŽôÝ»mñÊŒ=‹HN@N3XL¹Ìˆ[[Å\ mRH # SdL9¾\ö¸ÙŠÅ¥l¥ 9O†ŠC(ˆ.ÊH']¤„Tí µú!Ùž ތīS´ª˜§]ÌçhµDL…³yW !p 5 éÖk¶N¯<ÚXœzZ*%q3a0LQwxˆ|q†,8‹åx˜’é¢?æñcKQ—–¢.-®.¼š"öc#ÞLg‘d ª_EXÆ™`-q-z3AiÌ·šD#»7è6²á×þ¶^á—Ç=n*êÒäê"á-‚ÿáÿPK AÔe‹ #gradle-wrapper-classpath.properties+(ÊÏJM.)¶M/JLÉIÕMÎÉä**Í+ÉÌMµåPK A)gradle-wrapper-parameter-names.propertiesPK Aorg/gradle/cli/PK AÕÜ?®<S1org/gradle/cli/AbstractCommandLineConverter.class•T]oA= ‹ëÚ"¶µ~C?”R*O¦Òh4!­ÒÄÇaY×m`— C£Âߢ/4ÑÄà2ÞP–´ôaçÞ9{ï¹sæÞÝ?þPFÙ@;:v D°c@ÇóÀ{xY9y†xÕõ\Ycˆfs§ Ú‘ß±V®g{m[´x»KHªá[¼{Ê…ì' &?»†bÃNɼӵKV×-ÕÛ)¸%ü^{€ìÈ÷Îm!mQaظÌõµÿŸ¯|¢j«U©›n†Ãl㌟óR—{Né…¬•ì¤}f[²’ C¤… ‡´¬-¢ k’ôÚ–Á=,È÷¹Ø‚ak^ÀÌÁß«Š^tÊê Ö”Âõ¥-JŒ×_,»/]ßèØc¸ÕtË¡ +;Xš¨rŠîCµuVQ CWˆ uÁhúCaÙoÜ ™«ú¶Ô1aà6Cúºë2Qľ‰LÜÃK†Â &„!9¯‰a{ Qá23Quá {¶'§M¡†Ð~rÕÝìõ3|i153 ¯mnžDevf¨èÎ߆J…£–š~-C…Hý;"d©9´š´«“edcù °äDq‡Ö¸SX¡Õ`I²w/!)²Œ:·FyÝ7²ÙÍ_ˆ|¼@ô8_AË #ÄöFˆŸVX! ÊK`öªR~œ;©xëô†)ï>=ŠNâRnpŽ´âØœœcÿhÿ˜âŸ¯òÏ”ô4=c/ƒ-e·ÿPK A׃µ³Xì ;org/gradle/cli/AbstractPropertiesCommandLineConverter.class­V[WUþN2ÉÀ0å H¡°Ô„¤ÄKKµIQJ©†‹¦‚Ø;L†0fâÌáOøîZ¾ûZ_¢t­ºúìÿñA—·}N.iÊ2Y9çì}öÞç;ûvòëßOð6¾Q0Œ÷e| `ó|¸£`w,â'?ä«û ÒøHÁÇÈô` Ë=˜Å V»ð‰>íB¶ƒxÀ‰Ïø°&cë.cCÆ Á”i™Þƒ?]cì¼ÁЗ1-c¹¼·i8´Í"qB[׊kšcrºÆ”¼mÓe¸™±B¢àhù¢‘Ћfb~ÓõM÷V»d8ži¸ öÞžfå¹ÙÛÚ'¦á$ F]èp¥ä™¶Å0‰fv´}-QÔ¬B"ë9¦U Ñ‘Ñ»†§™E#Ï0ÖfÏÕ³f±[·­-³PvòTä4ØÐV5Ç%\ÜÁ’X3L¾Xž¤íÚQgIW‘‘´¬W]Àp§0™?¡•¬:£ì™ÅÄ’VJFOѹ’MA`i Ò®q¸¦ËÆâAÉ1\W@ µó¦\ì¶AÜŠ€A)5"É“ã4‚¡æä8,ÕäF³hªJ+gŽ ^Èzš¾KÂŽŒ‡añ@7ª e<¢ fÍ‚¥y"¨ß¾´;D='þûš+›;†î%£­,†üW»’J /G¬dí²£÷L¶Xg<Ãm©x# ý§íªx ã*&0.ãKo 'ã+A“|gºŒ<ß¡o©(`[†©b»*ŠØSaÁ¦¼¾­¢„¯ Â«ÂC™û”%M—UÅ4¥Ü¹zÝù%ÜLEu|tššg·1qBuÞ)”÷ Ëk$1Ãø‹ú 5ÖÈÃÖxE;i1g¯÷Yu[së°¨ª¯D:2ÜKZMÍu6ò?Al©†T'¶[ô'\íL’z ½¢o’B‘“EŸ1]^„½Í†.³õ¡&…z6ðK®Z6<ñ¶ÒS+Y‚h~ßu.›VÞ8XÙb·»uš÷ù2©¿iÕî°•t»ežÔd£N§Û¾³áH;¾4A†Á?2/y/• ™jéŸÀ~¤…£43Œ1𺸄ˀ$ñ¾ æ‰Ú<Ég’yWjFK$í§ùj,ð ¾ ÿtþì†D“”­ °¯ ¸'R® kýøÔ$G è}/aŠNäÆ«ÖªÄjŠ~Œäú¨ýDH›ñæARüôßèô ͹?·‚î ”#ô0,_;‚Êðiqá9|·¤)Ô[Aßl øq"û0àÇú%ÊT‘Âéq¯Ô¶þù9þ„NêËäR7¦È3ä…wÈó„oƒ="\ü× Ó bôÓjŠèkDóÛæ·ÊQ0Þ¾Îá-úé#KuïsÎuâÜQ‘þÄ€ŒÙ¿ác¿cøÚº)Q‚á=áÐ[ýótx’V¿p¢2‹?Ç`á'g[©:¶é«YMᶘçþPK A}­ÎyGK1org/gradle/cli/CommandLineArgumentException.class•‘ÍJ1…Oú3£µ¶Zm+êÂî´UÜV " Âà–îÓi˜FfĘ́¯åªàÂð¡Ä$-U´fq“{rïwOÈûÇë€34K(`Ë„mu çœ žöê‡þ=}¤^DEèõSÅEØ=.å˜T}.Øm˜ÐQ¤•š/ ©â&Ÿ‹…t‚_ªÐ GÌ "î]Ê8¦bl *Ìb&Ò«ç€=¤\Š.³$¡¡¥þrAÐ^âí›2˜(ùdæ[ÃÅ€f‰&Õ—V”ú2S»æÆoë/c§PFŽ ‚Î?^E°û5ÿ.)Ùâ-äõ/˜•1ttuÖÓyNïN»3y±÷+:–¬ÚÔ•;XէƬJëk–â ŒuÍ0¬Êœu£gäõî¶;ÇSä~ÂötÓ¾…ÌÊ0w3§*6¬ÅMÛ]ûPK A³ßâúg)org/gradle/cli/CommandLineConverter.classQMKÃ@}ÓÖÆÔ¯ª'Ï"4 F<6¥ EQ($xߦë²%ÝÈvSúÛ<øüQâ6…L ]Xvæ;÷†™Ÿß¯o÷8wÐupJp’L-¸6„~/œ²óS¦„ÿb¸fã”%ìu<å‰ ¼*Dè<.þid¦æÎn$…b&לpW'<(a‘ÑR‰`ÄqàÙKxî…™¾Ðl’r?I¥ÿÆôœOFÙlÆÔ$”jçήwÚøºvRm_Uˆ%J¡¡ïÐÄýªñ°vJQ–ë„?ÉÔê_”äFë%p}»b.·;o¾ºÿ-7Û‰Zä3®ÌfSm¡Õi¶M´l¶g³–ÅÛplÔÀ~Qqk*[9Àa¯‘#ïÉPK ASf Õg&org/gradle/cli/CommandLineOption.classV[wUÝ“¦4™^ˆ´i¡\ä"iBµ´ ­ÜZ.Å^ÐÖŠÓdL¦™0™pïwü¼ø¦¼ð .UYË哾ùü.—¸Ïd:™Ü¤Ë‡œós¾³¿ÛþNæ÷~þÀËø&Œm8'ã|œkE–Zqo é¢Þ‰à.Eð .‹A•±AšŒwÃh/ÝÊ iEHzWÂœ¯Š…ª8ɉÁC^ܾ&KFA†-A6ó¶næ :¦®¨×ÕTÑÖÔœfJhÓ³9Õ.Zš„Ý•§c¥¥¡æ²©9ÛÒsÙÑü¡¨V¶¸ªåìù[y^ÚäÓ7ÔB*›«÷Æâf$£Ò–î8#!Z /!¬çÒÅeÕæJ‚´Dÿ²–YÌ/êöŠ„¡jÿL+›ÊZjÆÐRiCO›««j.3¥ç´YLjão8£å--­ÚZFB˘žÓíÃbqŸùI[³ÔeCí_73šHafŠ«Ëš5/΄ÃfZ5TKkw³Åtà Ú+:3¼ëÙNUædz-¡»ÒÓë©çkƒê´ÍÙjúê´šw®Ê(ʸ.!¹a‘pV³g×)³)Þ_Cš½Õ{ œ‰¬¨…c.[$ Çk¨Ò¿‘lª¹'è´¡«{âRS|~2ävÆ?á§êæõx+ÉÚbi…¢ÁÈzkNu#£Y¢ j>¯å2ÓZ¡ fYËT¼¡òR­QŽ–ûxu¤Wx8R‹º± Eë1Ã0oøÐïgëmñŽ¦¥ž74ŸŠ¢Ór_q9éë\…WO•w¸–/jÝh¼Šz"#ñÿåÐzÎ,Zií¤.Zª»FkP *Ø$}ÙÂiµ°B+ ¶c‡Œ› na·‚]bèÇïᶂ÷1£à|(¡³º 2>Rð1>aÑÊ Sz´‰5 ‚‚½xAÁ$>UDœé¼P~Ã.*8…Ó ö•Êï%>Ä‚Ïñ…¸û¥‚¯ðµ‚;ÂôÎg¥¨ÂñÙå+ZšþEkߌõM' gÓ6-‡0 ë:ú ¦NVçÏŸ=!!¤{ŠÝLX`©e2zF»I«Áœ3Uö\É%ÑNµ§e5CC]ñZ]AáºmѸYC¶YÚb×Z.+ÈËØ&%ôÅÇÿëb Ý`¯ð)ð³sÜ4 º"((¼á{±j^×ð<ÿ¸·ñë QÁ*°>\¸ÄòÖ{ø#™åæœóÎü%ýNîíÇ׃\ý&9ŸI<†”x‚ÀùÇhzˆ`âG4?DKyGN®!$azÿZ%ÜÅV a ¿"2“ø Á5(,Þ{ú碑⸠!ŽÛ¹Š¡=èÆVú½£ôé$¥Ij¼Hôa¼Dÿ›„/üi;ÐßaÊ çÒÎ¥ƒ”»xÊšdôÉ8$ó‹¬ð«TŘfŠ+q½Yøúƒ£r²*6÷:^”ð›]Û%׸wG\788ˉ¤H€ir`ÂÎv?/'¨î’š†ì–ª†ØÙãç¨cæGaf„;B'”ˆFÖí|vévÊçrȵ#áx=Œ¶zCÄ8Pc.ÆÎÑ}‚vr cŠ¹ëü JRÌ°i1!¤hô¹ÇØìˆ]ÑnŠÉGˆ•S³…†À¯Ö«ÓÁ¢ô0§»ì ƒ.§jÈ5"GO¥ú† ý™ªñŽ¹nÝæJ0¶·ï.b4Öó-ÂÉÎл˜n=ðŒw³"`´á‚~´r<ña³s>Ìã)C—ÓÕ0Œ9y®mjú®V!:«©|¸Šk‚Ø"%²£ƒ…*ðÕý5&˜@TZ¥[AkI )†áª±Zb²=Níʆr2¦jŠÁ³ å¾sš¶噜É(…B`4JY:TCaôÙeºcªùU•¨°*çœb2ô”vŒTzCɘ‡gKEËÔ·N„ö¶R¯9‡r,m:µïBM}¯V´Î÷{"O.6¸ÿu1á³ ¢‹~è-ôëg~¿hW´ªƒKt/ÐO‘vs´¯£Ù }„+ ï£î=í]h§±YèØ,êÙ¼l$ë Ùã®ÖŠúÉ®“7õ½ Ü4O?Àõ îðgԻ𠞥þïh;_‘¦!ÈöѸwiýÞõP˜¶¾þCEÓžEVÐh`l­l í,…[±¨m'GT&p ÝDA¬nÓÊE‡ÀÂé!iØ/8<~Ù[$›"­ÀáVôì8z€b3%®ø‘+Ž>gÖ*hÅ/V!r'î·ßÂÀeš§Ém3=³:Irƒæ›n w„¿NÄ0ñ¾Š!ñØŠuñ2‹aÚíÂÍI·ôPK A¥D£¢&3org/gradle/cli/CommandLineParser$AfterOptions.class­•mOAÇÿ{-½r-´¨ >W+p€Š"ÆDð!$MFxa²´g9½î™í¡øü.¾D%ÑÄà‡2Î^ÏrÒ’cšìÎÌÎþffwnûó×·fqÛ€ŽQiŒu“4®£h ‰IS°tLë˜aÈT¼z‹jÉ6ÃPÉ“5«&yÕµ­ŠëXO¹lØÕ¥}Ÿ†ÔG8þ]†‘±x÷ñ2CrÉ«<§ +ÛõM[>ã›.YN”¼ wË\:JIËi0dï½ômùäïxB©ËBØrÉå†Mªu0r$f„Žî§¬óuþ~Ó^õ¹ô›F†þ±Ò+þ–[.5kÕ—Ž¨-Œo0$¸¬©äÚz<Aè˜eèkÊͨ´èS ÈbÅÑÆVçï…ùg<±â‰?ÕdþÊ`±Smññ¢‘t\cX>ÂÇcg‚>Ðv¦Õ@]7|”- ƪ·-+öCGõÅ@›Ï”ª0‹ ²j¸žE7 7æcékâµðÞ‰W7xØ’Š1§ãf·0Ï0y¬d˜8ÎÙ3Ì¿5èó?U†Ñ¶=ì¾ q~ :5úh˜hþkºmqéóåÕêƒ_ò2w·íC^€2 ô\¦é ¥G@õI]ÐTŸ‘¥‡´G¤i4gL¶Í,~Ab—T ½4ö"A;Ÿ£‹­Ã`È‘m éŽò:CóÙ¤ú÷3q‘æ‚äÓôhbÆoPK AŒ‹Müu <org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classÅVërÛTþŽ­ä¸²Ò:¦I à§I|‰sk›ØiK’^‰Üœr“Õ¨±¥Ž,Ó¾À[”˜2ÐþƒáxöHnb×Nä0áϹìÙ³ûí§=«ýóŸ_~0‡‡2Ncñ K2†°È‘“!aYF—ø‚«ŠÍ ǪP»&CÆuŽ!Üä¸%ã6>’1€uŽ¼Œ(68 wúoŒz|†a,oÙ•LÅV·«zF«™5«VSÍí¼aêwU»®Û9Ò^6LùÂpsÒ_ýu W¼Ý¢—›ÚdÖ¬má”l4jeݾ§–«$‰æ-M­nª¶!öM¡$à2 ­ê-[¿aØu§Ø(7m2(·MS·×ªj½®“Ú¢/ÈxWCiX;PíBNg, –YtTÛ)§âò}›ø”ã3%l1ÄüøTðŸ3,ùzºoî˜Ö³Kfž=ìHÁ9Œ T_1$w°bW5Ýt®?ÕôfœkšŒ5s$]%½˜—€±‰ñúÄ4Cä Y åGºæp|­@EYxÔ.ù†´~H@ÃÝ„]*ÿ[qèçrå‰jëí€;˜;þk§G柮G&Ž§Ä°ÞSEêõQɪ¦éõz|q†×|ïyÊóÕpŒj†Š( mªjÝa8ß ÓË”Ww[E–‚ñ^lqŸá6v¿ëÆÊ(=­»WN#¯#¡rN©YS‰–¥.8ÍÔ~éêrWøûß´ö¿€¹ÿ¿¨KÇ*bÔ; QËÅ"Q¼iD@Ôr0¼M»[´Ò¬$’?!H¦vüö¼CãIqÆæÑÇfð.ɆéŒô1J¶á®¨–’ŒáœoZý }4«{JÉÛEßFâGž£?õ3x/ÊJ#Òï˜õÄ'¾Gtr)IÛp‚ô•g{(EOJ¿âT)˜.>Gdƒ/ö-¥G¤WZo=sPß#—`K3‹Q–Ã[FŠ]FŽ]¥¶pÕ…¾àÚ‡®b“Y¬¦h@˜~R ¤Èæ(®!ijJ3n¿‘ã8B§# g›¡HW¢™»Ü±îú…a6ç:Nx*ûŽ9µÀg\Çó.{bµ€ î×¹èÚ¸„÷i^Eˆ¾`– Nó¸$úä,’ÔÏS‘DŸ¼Ñgq¢ŸÎâc)€/hþR’ÿPK A´*«ZMïForg/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.class¥S]OA=wû±P·RˇŠ"ˆUhAx1¦„¨MLšÔ¤„÷¡êàv—Ìn‰ÅÿÀ‹/˜ø`|öñãÎîƒEkâCçÎÜ9÷Ü{Ng?ÿðÀ&6 °Q)`Ì,9Ü5Ë=K&½l£fcÅÆ*!¿¥|m2ËÕ]B¶t%a¢¥|ù|Ðß“zGìyœ)·‚Žðv…Væœ&³Ñ+æ"”M?”~¨"u$Û‘V~¯ô…Q  NÓ÷¥nx" %œ©6mÜÁ#¥nÔóÖ›uBå_Єñ¶êù"ñ[šf)ÏýåØÖ°àm¦*´ƒîȧÊH›j·fŠpÉÁ\ëp ¥ß©LbÊûúèÿÙsì‰ ÂÔEŠ‹£Ý"L¦ïd'höü@KÓŸ0}Á›1/dü MXEÏnØü…qsYXÆ'>9|r9Ç\í=¬w¼±Pä5o’ô—yï$L Ì‘Œ…i±ft–cyeõ™í¹·ÈÍ›}ö˜³™˜©lôy:E¾Á¡1k-©LYÍn3q§2®òÎâ\Ãuæ™M&:åâÒcî#íÿ€ï2‹µ•OÈ­òïù㿈(&íJ`æR’‡­ÔºØ™p6k·0Ï÷,ÄøÛXŒã\‰ç·Øî*w™ÅM/ýPK A|ìRÎÐ&=org/gradle/cli/CommandLineParser$KnownOptionParserState.classÍXéwUÿ½6ͤÓK‘*EqDè’t‚;VkE¬´E­+. ɤ3ufÒ‚ŠHQpCqPð![ÿ>žäu¿\|ÂÿŸIø\@-V< á°À¥gØZ§YÍ“ˆæ€5ͨ-4Τ¦j§×ª¨ 窬ÓÕm͵løÅ Z n­ÍïÔpi S¬5ê¿—˜$뻦 —b^¡)ÄÌSº™tçÐd%f³ùâsT‹CPÅž`Åg^íá •€ôt ¤µÒÎH‘@Ú'ÙØ„N‚rŒ"#ÁŸ^häÛÁN°oGQ7AUß‘çt$‹ åYFRkº|²ôžÃyÞaCè@Æçg‚²°pPÆÉëèn'»Iì<:\(ð=õÄšÆpÑÁÿòÙ,§œÊá›Á«ía…µîà¿Ò±<çÔV²â8æŠoßSTÀ=âGŒˆŸ°KüŒQñ ½’~Ãqñ;~àWqÂóW”|²‹ò¶›â\Šãä¹ÊTÎÏÛ°kqS Žä'×Í'Q.á–¿QsŠw8¿Th·áÚDL)Ù GcMóCG!O Ø+žm>V6ådÜŒ¾ hd¬ ŠFÆí^Ñð©wŒ¬÷øÞ‰&Ï aÄà ‘îWÐ~qˆÿªpÐN߽̾2BIî þ7ÄÁ³!ù?PK A$ľ¢¥ô<org/gradle/cli/CommandLineParser$MissingOptionArgState.class•mOÓPÇÿwÝÖ*ˆLDÙ² ‘!¨ ·'š`0ÁWÖÌšîo;¢ñoôÓøB…Ä~?”ñܶÌKË’îœÛs~ç±íŸ¿¿~˜Å’Žr:’È'I*(uZG 7ÕÙŒ’Šq”ã˜eÐœ-ÏrD·†_øòK.]S®zÜ3Œ§B˜²js×5]†¹š#ņäuÛ,nÚV±ê4›\Ôk–0¿É#%Šr×–wŸ¡’í[cˆU:å3¤ WZÍ S¾â6œ®9›Ü^ãÒRzxóÞZ”îÈsËu-Ñ˲VµÐ;‹®žTJºÉ?n˜¤I/¸GQ²µw|›m.ÅUO’ÛRn!ÊeCåwä&à# Ö» º@ûë~Ê+ŽØ•:0ßÝrïæ`€´#:L‰:՞ͭÅ1Ç𦯉÷ö)û[ùPR—2Ãäq\ôU§%7ÍÇ–Ú’Ñ#63ª†V—Ûtœ201,¸ˆKî`<ŽE†ùþ–ˆaú$ýe˜=y&z·ƒaêà °ÜýÒýioÙ¦ SÊžx[t¿­¦)<†L/gdè핤÷=Ij$iˆ¨ ÑÉ0iOH‹Ð*ÏöÉ~"ºCj„ÌAæQòÜÂ{Iœ¡³ÑÀgI‚/),£ß9Œ…ÐÅªå »ˆ}kó4º¶ÝÁÑÚ çqÁçЖ„œgŸ2À`þ¢»(LïBû~÷ÉÇeÃ6n0Ä)I')BòeŒ‡à{a‚I¦㇡Ÿ;rL¶¡ÉvŽ\ Q_Q”ãëÿíÓ•;û‚ûêãŒÀ0À¥AS¸B’e4hØØΡdšv6lÒo¼’®ã†_єš Äh8%1õ+aêûUÂÒ' øPK ATK>ªÄ=org/gradle/cli/CommandLineParser$OptionAwareParserState.class­UÛnÓ@=›¤qâ¸$”6\Ê%¤)MÝKÚ@)½p)E¡ E*oÇÓĮօOá xá$ ˆJ|…˜MÝ’*A./Þ™³çŒgf퟿¾ÿPĽ8È©Ð0*w×TzŒ©Èc\…Ž “*L+(¨ˆcVAQÁu†„á4›Ü®•,ÛdÈ–Q/Ô¯5Ì‚Ñ° O¹pÍÚêÌCÔ{i¹¹™è\û èe˶¼; óÁð`ùñ CdÕ©Q²IéØh5«¦xÆ« ò ”ƒ7*\XÒö™.Cúɶg9öʾZÙãŵuÛ6Åjƒ»®I¸…À,s½™è]SMþ¶j’%¼} ÃP¾ôŠ¿æ…·ë…²',»¾4þœ!ÌE]&ܤ–8ö†c$Ž${¿]pÆGÓ짱õ˜oûRËNKæš%t×éi©¨!‰”†Ó˜ÓÐSnbXÁ¼†[XP°¨a Ë s™¬¼ðL±f ×+·ª~˜a°—[ªÝf˜:ç~½¨Z§)9höæOØS†É©­‚» cÁsž›mÏqÌrºœ |ê¯Õ¼ñ¯ðFËüËdUº©ºÔ©áÜ0L×ÍÍÍÐ-=ƽ”»õ_îïqk³Þ¥vr®l0.’¡Ï¥FÒå|©”œxò„¡!òJ„ÓšÒ'vÁtö!}ráOþYÐYŠ³,T6‚$Ëaˆ|iŠÑZÏíÔç ûÌ‹dKTTŸø‚ȇC¾(ÅÁò<ÑCž(.âÅ.#ãóì ¯*êŸ&ª>ZÙ7Dß!½eSZ2B™ÇÞ#¹‡ø¦oªÛo+5UÉÀ¦cÓºÅCÝ¢¯{•ö B£*^ÙvÒ#8G«Ni$èy6¢˜Ž+ùÿÑ1Eˆ8­3$r£]‹ØoPK A˜%àÌ»ª7org/gradle/cli/CommandLineParser$OptionComparator.class•TmOÓP~îÖÑQ:¯ ¾€ Ý ƒ2@Š.Ñ,YÀd†Äe4³¤kIÛ†?„/~#‰á³ÿƨ_ç¶ N6).]ÏË}Îsî=çô~ýõù €E”%d0#¡Ÿ¿ú0+bN‚UÂJ"E,IHs;'"V8|UÄSk"Öz6LÛô7’eA(;íªi;­æ¾á¾Ñ÷-ò Vºníé®ÉíÈ)øïL!»{䛎]všGº«ûŽË WlÛpË–îy!–ªŽÛP®~`jÝ2UÂ6uû€§y­»žáN_åÐÄz`Q¢W…kÂH-¡TˆÓ ôÃT|À%|‘ÎÚ4yÔ`õP?ÖUK·jÍwM»¡…kÉÚw÷º¯uz”Š-ÇÖ¤¤ñž$Þ/0LßÍÐ[3¶î·xѪÿÚMË7-õO¥7â ±IÔRÍi¹uã¥É;?Ú‘~žSËÈb@Æž‰ ™Z½a×ÃB¶ÏÏh÷Οñ\ƶið®ö‚a+6eY÷ŒŠí¶gúæ±Ñ™{"!c /&ãªÆqã ¥ÿý¿vŽa¸[ëhŠãÇ‚Z×0ü0 }‹¥m j†¯]{–…a¤=¿eÑžBº$Í>•½Pí¶Þ}à4¥s2¯|=ѧÕéQ*t±e躣KŠ.@ >rd ’¥’d$S3gH|$%!z÷p'û†aÒå€Ü!Éx‹¢àD–"¹2{Šä9„·ì ©Oè¹€¸Sìp­ çHs»wnL8…tr™­I"þŽ!öyö3Ⱥ2GY¹v÷‚¬à>i<2‡˜ Ø<l’4!»M»{ín•Vˆ™™Ù ôé ùäš#fÂdYþä"’5’‰¨>¬{}FCÀåNS˜Æ#ZOâq€Ï£H·INQÍ2(RÔ8éô˦ÉSÄ<Ùi’Ëÿ PK AäfC˜§£8org/gradle/cli/CommandLineParser$OptionParserState.class•’ßJAÆ¿³Y³º¦ÿ4Õ¶Ö¨£×JoJ¤P¥… …H.¼›$Ã:²™•Ù‰ø }¯/ú}¨Ò3›€ˆ…4»ß™³ßùÎœýýçá€#ÔB°ÂÇF€ÍUBñXie? õ½Áo¦}IXl)-O‡ƒ®4碛pf¹•öDÒF¹ó8éÛK•–ή­Jõa2iÚVXþTú®µ4ÍDd™dËÇVjâ(6¢ŸÈ¨—¨¨™B÷]ŸQ]í¤AXH5‡ÆžÊ[ûÅĶóOúÖ÷&£ŸBÃT3k8ÚNê­+q#¢Dè8j[£tܘš¸KûMdT¾Ì‹¼W^'ÒÊÛ„Ýúdð‡†[ƒw{H¨ý›»´Ó¡éɯÊm¤òÌsàÆ+aÅ;„£é÷@(?^ÑY÷JöxÂ÷Ó\a{ò(„ê$“_åÿׇ{ŠðÜL |ŠX‰ufÿÞfs'é'æ8. ñðygXÊu+¹®âe®—/;çÚþ‰ÕÃéßðÊÈ0‚çÑ:^çeorÿ[nÎø}‡y?Ä"k™õ•³—gÿPK A¢Æ÷E«¶3org/gradle/cli/CommandLineParser$OptionString.class•TÿNAþözåÊq”ZDQ‹´GËQÄŸ kLŒ&(ÿ[®—rx½kî£âø/$‰&>€ï¤qv[l“B“ÎîÌÎ|óÍÌîýúóý'€9<éE?LÄ´Ž4ŠB-¥0£ã, ³:4…( 1—Âmá;¯á®†{ Ö²ËÛü#·<î׬µ8týÚCOЈÝÀ§Í¢ë»ñÃT¾Ý¯ÝRXgP+AÕaXv}ge§¾é„oø¦çˆLͽuºBoÕxËŒU™° Cê ßwŠǣȡSk9kV-äUϱlϵ*A½ÎýªHñš‡‘æNÆSéš?s£†Ç?¯ð:幘/t*´-æö‡W¼!éh¸ÏŠƒæ±† /ÏTww~eÙåÓ¬e!ærg‰cèã¶íDQ®ä¹ŽÀOE„–;McBÒ»…ÛÉ-Ü!¹%Œá.ÕÌ"‡{ä©äN'Möë¬zz‹ÆÇY%¼B65[ümŽ~çèkÿE“T‡BZÆ“q‘5²<”]/h¦¸äŸÀ}LѾ‚>‡‡‘ÆM²c”ïGÃäMHxº¦) ˆ±ïPK A`M~U¸2org/gradle/cli/CommandLineParser$ParserState.class•SßoÒPþN) s€ÛÔ97Õ½Œ&MLÈf‚ÙÃÞ.а.åÖÜvFÿ'_|ÑÄÿÿ(ã¹-›Ý Aš´çG¿óïœÛþþóó€´mdQ³‘C-Ç6êxbaÇBƒ{áI/zIÈ4šÇ³Œ\ÂjÏ“îáùdàªbàs¦Ò †Â?ÊÓñ4iF§^H(¼*tU?'‹ï¤tU×aèòËv/Pcg¬ÄÈw¡ï9Ý`2r¤;$uõTy‡Pšˆ/—#}Œ¼@Ö½3ñI8¾c§)OŽ;ÍBÞ / ¡ÆZå Ž°È›…&¡œøWtŸÌi2§íâqf¸YC!‡¼ûzÞPÚ•h&ß—ûP2£»e²»gÆv¡nÓ‚$Ù$T@|„*>AŸÑ%¾ W|Å):ËT Ð3€¿â‚Â_qIÅ_q3!ŠžÅ¹ t–¯^= xÎc @椚ÙCäÍ!ð÷:°Z_ eªàYòÊqà>8YM¨ÝHÅEÿF‚Ÿw@³@9\"žÙ!µvÚC”œzÀ¨1‹ø‰vñ«®¥x••&Òƒá€k$}ËŒfÇö!¶uõÁÇÏTsj]Åp9Ð9†+Î1Œø:ó*…4ñ*4fEù!Š´“æ¿Ëœ¦./1YœŸÍ ®‡µ?PK A£=l)&org/gradle/cli/CommandLineParser.classYi`\Å‘þJš™7zz¶eÙ²=`láë–1¶°åS>K6–±‘ÌXz’Fψ™¶8B¸ÂŽŽ``‡‚¹d ÙM¸ÂÈîØͲaÙƒ=€ !lÇÇ~ýÞ›ÑÌè‰üPwOwUuUuÕ×ÕO¯{ö€YòT:ñ±jþW5¿×±Ÿhøƒ/>Ññ)þ¨sú3 ÿ§áOùø >סã yøRÃa#ñç|ÁÑ|ìÇ1ÕׄW‹ø%GÇÉÕÄ£c¼xýâS¿5ÕøEžŽ]¢û%_ͪ¡fFúeu‘¿ŒÖ¤PÇt|ÂeŒ&cu”࿱—qª¯8&¨& œ¤äž¬š‰JO‹ï”|7#ñP"t‰™M$(°¹ÓùÎL8?²=ݱ×cq3Ö”&LMÖsÇsO°¶A0ÚeúAQC(çÖöj]¬ÝZ¢-um 3fÏÆ5iŒµfÎ Å≦îmÔkG0ÒJKͶhÌÌš×dcÊu;ƒ13cßM‚üŒ‰ÍÜ0Ý[‚1«×¬«_ݸµ±®aÅÖ5uëÖ­XÛ(¬ê ^¬îN„ÂÕ1³ÝÜU½&˜ V‘ù‚QQ[Ù¥=I£Ò¨‚]¤Ék µG‚‰î-\‘¹ºÀþFÚ«móWEcíÕí±`kجn ‡ªÛV…"¦­ìüE”9:Gw6„v™­Ž»Êú1Ö|ÆyqeÌ41ë×òP<¸-lÒ‰¾¡H(±H[RÊsô,‹¶šJîÔؽc›[§…«¢-Áðú`,¤~;“žDGˆ’§|…º¶³©¬·Kg–lloi¶‹­5M%ä· ü¤9.bˆI+vµ˜ÉÐÙ"˜[’FUÏóRŠo;ÃRØñ¬`öFNç”â3#­ŒmL=ƒ šŒ4åPõ%$Ðl¢ÓÉuöÎ * cÝLate+ïr"n꣓uUC›—iظ̀èéJ…›Ç]B\ð kÙΰX5¹P°jØìÃ:ÄÉ)Bˆp(^H˜i%ƒ¹…¯n ZÍükn »‰Ý’É_>N¶§¢‚ Ïœ&3A†32g R4ìÑd«Š Z”8?lçyÒO¤®«‹m'áˆf@çØh¬ÕŒ%sÆžUÊuÅÌ6ë’3iÊ­ Å•¾¹ÛÍ¢Ä%Áp77õš‘DLý^a÷E™9ÍšV\Ñî„ŠEW ™p¼ vX8)â¬ä4iFf(Må¼aú„}îŽà.ÁÔl?ºFò´,ƒN@6ßÍ 7üwåž3ô½á§ÉEš5ÙF¼îŒ†p JÒ-‹†Ãf‹n1íR^¢¾:ít[½­“BÞY‹ñÔ™dïÁ3‰›©R÷­»­M΄A-µVÔvmê‚ϼ.(SžYìn‘Z¦Q_;¥S™©[ZÌx|Úœ™3ÓK†FR^Ñ9»fpÎUœg ‡sPY‘1O‰ð/ ›}›ëMÑîX k#…ÈãIªRr ÜŠ[ Ü€ ܬFßÁíD¨-Î Æ;¸&-†´Šià{¸OP<ì’Á´1¤MÚ¹ƒt¨†·\Í×ku§¸;5ÙnHXv‘¨!]r1%ûð ‰ Ã0§²Ò„t *‡Ü1½ðT]BØ­¬ÜtáÂ-å†ì”¸!»¤ÇKå2C.—+%‹ã¥Ū2C¾!W*¢or•\Mx´ÖÕ²ZÅm¸…UŒ3W¹¥ªŒqŸ\ÉêlE,rRzüà´…[UÆíºV®3ä[r½!7(GÜ(Wr“|Û›åjCnÁí†Ü*·ò%*ûÜŲ!·ËwYX¹À¤Š2Îu]Ì4y®‚Ó‡Y <'”kïP͆Ü%w't°3²ÝluY9LáÙC¾'÷d˜R‹{23$*Š ¼ƒ0d·\/€!{ä^C¾/÷hrŸ7å†ÜŸÅžkCPá晟Ɉ: ù¡\lȃò÷™nÑEñâbÅ`ÈÃ*Åƹc&{ý>Vi%±¬=f Ù½ƒwbª¼eic›^ÏRĉ^ÒÉw÷w¶`Ö× „OðFŸ3<,ôdn>g?Ü_çy2°Ï|ô—Ÿ˜Þ%õ €Áz¢Xç>"£Nd1ìV“fY72³pLbÊh1s}Á¸½6=£JqŠ®ÒÁÅ´Ï*£É9¡¤ôDuXàU ªëÇ»?›¹²}eÊг¡›§[»Ö‚eN(åóqæ%ÏB=—:‚ñFsWÂú®Áz˱~Œ-)u+Z v{¶©—p,‘|”•¸”ƒÕ{þâî`8žE< ÔrÐ_n¾ÆÛ·¥Cc^¼{[܉բ’z×v„ ç46º˜ð—<[]¿kŒt6SN¶¾oÌÆ;:ë‚Š´š»ÔƒÚC“êÕqÖ»›¦[àc¥¡`©ÛÑ|ݽóÛ(~®zvú‚V†7\eŸ £"šzü–¸ª>²ÝL°žP_·k¡°©pÊ6#í‰+Lé€üh¤1I`E™4c…Ò/·]AËin±çع¼™<í±hw׆ڧ0=ëÕ—g3†Nj'"³@#yëYk>nV²0=tziÎH_û»…ò×r3Þ %?~u©'þ\“‡éßv³ÇBä‘‹ Aå ¯Š7ºÝo}m°hüÜ~½ý ÂÇ¡öW„‡sú Èé_&º%î@,yÛÂÝñŽäÅ‘å<ހà MçÙ<ïkéš³®àÇÖ­²0nGRZÕžñA<[1ëQ; hK½&§i13|d³7ØLó]$7$åJ“¦þÙAÈh5㡘ٚz=©ïæ‚ÖÂè´ž¿_‘Ó.Ÿóq*:±€'©ª—£õF†à&kümþñ¹loU}Áõ²ãï¤ášíwùkr9ârÙxÊúám>ß3ÈyÂ⼃­Î˜æâNŽ ›wánöWñ¹})”¬…ìm^YùAh½ðïO ñYL+,ãl"G€íÆ®ß˱‡ý÷ùÇ7<£ÐÜ7hb>Åxú‘×ܽ¹ìiäô!_pÆŒhèÇÈæ² 9€Qå}(à Âðôa´`·¼®F…‚¿Â˜ZoeÀÛ‹±»å±€·°¨ãv£ ã›ë„Æ}r§½8i7N"eÀKâ“{1±Öðõâ\N‚IAUÀ[°°“k|6e)Š­Ðüå¹Èâ=•Lg“iŠÅtªEëñ:¤ðúRt“ŸÄÔ=("õ4RïA~?¦ó(N{,$ªõ)³¾>ÌÈ¡»Æ)Y>gGK;¼åÈ®Õ,JÍ¡¼ª²%TZXÖ‹rE\Þ‹ ÕO¬õü½¨Ü€?i.UÁMjºªÑ[“W”§\Vý æÒ*þRv×ê™"uG¤žYÕxmžì;þâ>,¦.’®®³¾Ó‡ÒKéÖ‘ÍlÜwlfe/N¯ØoEˆŠ§'QÁöÛõb¶ãô Wb#Ó`cm3Æ< ñ×ØŠ_ã"¼KÊ÷° Ÿ£ÇÑ*#`Êx´É)h—btH):åLl—&„evH'¢Ò….¹ËMˆÉ^ÄåQþ~;å9ôÈ˸TÞÄ7äC\)À5ò®“?ãz9†sr˜–*öÅhêåÃp?Û»0à‡=ŒQÖœFÍ {•ºØtw›‚ñt‰c1~DŽÌÎÁ†k½ŒûßUôaŽ ±Ò!Œ¯t0¨F!SE/ÎÜwüƒ²XžÂSýá'æMâ©Íd_ø8ç¼ç¾‘g¦ôMÍ'¡Ð9Íóø×K ô(=SXº-,õ3úð,-Nž¡=ÓÏu†Sá9ÎPôièÔðœ†çÙ Ýñ¦Q³ûc"™áÛ%¹Ïp;°üªs›Ë`q·–x<¿™ð¹à6V¦€¹‹è‹~,¦ï–Ôz*-wÔü‡¼®FŽG|¶˜:%f)ÅXJ¨X–²œBV4[J^ Ï‘²^l×úT{À”€ß œúp…íÃäå¢ÁËÇ÷ü…gÄ9Ü…*Ô+±/#ß’½ZáJNxy½çæ*ú™ŒuìR6+í|*,í&©‘£VäUÀV} 5^ƇbiÌÒ•bY­¼Ð‡5»µùÉ…çyžÇÚæ\µÐ$hêÅ:4¯"iÏù4¥ˆh¹¾pƒm”7ƒ¼ÙãH´ßÌ8¼à‰T ^ÊÈRè”Çx 0ÓK%³°k˜ŸAæg„鵓r7sä~ÆÝ!ÆÙo_ÿŒçðžÇÇœ9Ì`9†Ÿ‹Ž_K_”¼$³ñ²,Á+² ¯J;~);ñšÜ†×å%¼!¯âMyxw§•Ø#){9í%ÊqÇGˆÒÏ2wR»ŸãŒÞ0 /r5{‚—,º5¤ÙËðqÃBH»\ˆ—‰ƒš Öd^pôK¼ÆPΓñ7xY§ñ+òçb–Ü‹7X:y¨ñóx“Yçµ²F园ɯSšü-1ÍÞáï8gËèOÉø{zSe× yµNv½¥a®•`¿aZx¼úà 5Öøm‹èCãd"æQL´ðtLîq:ɛŠeÍc%,3w„…Çä]}sÚêê²Sž}ÆÞÇ~e?š2<‹Ê_¯p媲>lJ¯›0Ý©›j½§ìA^Ãió† uoQ£ÜEûŽ¿Ãø¹pê8Ð~?ÞâžoSÑw/¿å-ýOijw‰g¿ÃÞ¶Kñ/´ÿýžU°üGÒy•^¤}×B±•Œ«‡,ÌZJ¾÷,;–ó–ô;É¢Ÿ½òøxŽb´†f9Ír¶öKêaß2ÿJ|ß‹sð=ijSž8TÞPqhQn§ÈsʃØYQä™Uëµ@Ýë”O~lm.¼ÈI=oÓA`‹2/-ÉõÖìõ'a*oµõ¢}CÓ‘Ms­‡wÅý¨iVÕò„*,ØK¿:&U¦@Äcéå©HbÏ{V5”ky¿†E=ð!Æâ#Þ&³Pÿ==÷ k Oц?âr®]?1Ë>gŽAäù’y{8u cÑaÝ*^®Ž°òHÝ*‡R·Ê!çV¹•g©ò-y‡hÇà·.Ž#¨f€N>Œ©_À{EV43$§øñïøçf®f¯N¹8÷Ѭ·Áœ´;ÙËlçÎdþOü— sNöÃÂù¿]w–aìÌÈûŸÔi‰µ ;{±g<¹Oajaø v<sð[©€Gò¸%.ÇX"œüÐ"ùQ kGOa©XÇg\Ÿp³±ŸÏ>Î>Á¾›â.a¿“ý.ö=¼¸Œ¿Ç³¿œýì¿AÉ#Ù_Éþ›ì¯òäð´;q é¯eéV)^ñåý?PK A‹å>É&org/gradle/cli/ParsedCommandLine.class•Wiwg~FÛÈòÄ‹ê%v“TMc[–å’ñR·Ž›8¶SâÆÆ)-L¬‰¬TÖ(£‘·”.PhÙ¡liÙ7 ’`rX¾Áá;ßøÆŸ œœ˜ç}g$KÖ¸1GçÌÜ÷Î}Ÿ÷Þç.3úǽ?þÀü.‚v˜*òø`Ö!‰‹*¬‚΢ .¶ŠbuŽf¹¸T“¸,.+*žWñBM0#hÄ'ëñ".©øT=^ÂËa¼¢âÕ·}:‚|FÅkt ã³âþ¹0^÷7„ÅçÅÎ/Ô㋸$–__Vñ•0¾A¾V¯ãMaó qù¦¸¼©â[ ͼ1s…#+3¶•É¥©™¼ /ëE;“˜Òóà êf2éœn-CÁÉê§#Î2«çÒÀð¤i¥Ò–žÊ ÙÌÀ“ºU0RãæÒ’žKMfrÆ)yâð(‘ò–Q0r¶£*T>cØ4y¤Zãq ²Œ%sÙH•ŒË¶¥Yéâñ©hªÀ™Ìô¾Mª-°C#™\ÆUЯ08a–~.k ÷Î*Œ›)CxÏð¦‹Kç ë)ñLAtÒ\г³º•kWYçpÎ#„AÍ™ ´¼äÌ FA|»”ÒWÓݳwó/뀽˜)xØÖàÓV5KÔ¶x±  ­:Ô•|)ÜÃö#÷wOP¿cÆÖžcI(ßVñÃ^yØ¢ÈUØ6K¥Þïõ¤ÿbÑ´±\jÂÌú½Óîµ3Tp‘UG(ˆŒí|ÑVÐQ³áH1“M– 7S8–± ´RΊ|{…çY›#Û¶õô·nQ/”ª¬5^kÑKošu·O;=F‚¸m,·RÚÙ¯h¤q3›5$ßbwcÖLOËF¶Ü™mÞÆ ž¶¼ßûLïÐÏn"ªÝöûª9mØG7M”h©z*gJwr‹vè©”DœÕ³Ec úY®ÁeçyíK„?ëa{ÿòÿ?ÂÕœqZ:¯«fy Ó×ÈŒY´ŒcÑöm5ðû…Óã Ý é¸^Xd‹kèÇþšùÞဂ6žŽY–¾"Öð|PÃ[x[Ãwñ= ßÇÄîç1sµ=>4ü?Rñc¶ÂfÖUüDÃOñ3Ýñ8ë*$cÕ/GWý†º*ÀSç.°„5œÂ“~ŽU¾n¶˜ |ɘ†_à—=¦0­a ç4ü WU\Ó0³~ßp´WLöHZÏ–¼:zyÁpyØéøëé*ôÄr¦Kç}j¿Ècü­†ë¸ªážÑð®Ö’[û£v.•”2}Ri›ŒÆ—c9SV´UõPÉPŒIÎir+÷°©9¹¨ã‘´Ž°gËS§¹ Óù´ØQ¥¨Z³yˆœÛ‡ãµàµOBçMkI'Æ GÃ>ýÞ ï=Ÿ7r©‘W=¶~©„Ìœ­gDô­1[¼f(O :º½6y…ÙP=𸟳J8žJe³œÒÇÃü2mç‡sQÑëP0À•ïãš-^^äúЦ5[¼¼þêy?ŒAÊC€2?TjÞH܆’¸ßümøo"@1H1tꆦXG1rõ}kÐL%×°CÁœ¤Ð à¯hœ¾ƒ&Ú4úo!º† ;‚®]LHÒ°e(”ø=¡ŽÀZý˜[]ÿ×êú;7dÃò?‚Æk'W­ü¾o£ÔÎÏñ ùAþØ…ì†=xá5Äð:IáŽCüa£b!ZÀcxœ(DÃÌp1Ž')Å1ÒóaÊïŽæ8¥”÷!°NÎü*’*&TþïÀ=t«hTÑÄÕÐý_éP;É=œ'¼’XœáÙ­/ÚúÚçý F«ÞÆΙù€ë¥bXˆ@Çu #Bw¶vÉp§ú\‡}bÈ9¹Ã»¼‡x?}düÁ©À¨“•¡€àTò}HH.ßÁÝo!’Œîº…ÝsÉèyëV¬ü£«ëOÞÂC×ËIØ/ë¥a$¡qÖa’xA1c¬¾ã¤x‚š)R_J@{ñ& (ü+“}š?Av˜ö3xŠþG¸û f™”«97­ðßCTE§Bºï"¦¢å]t¸Œ”Fœ×.ã'¨ññޜ軅؜ ›t<ìõ2¯i Êâ1éi›³¡ì_3ã%œ‚§ß6ì ;AØ“÷ýžq“÷6ïA-ÁöV4Rg©‘Z¦l G® ¸¶ºþoÿµrNÚ$«gسdyŽE:ú+ŽŽ‘ÉN:$ôËÌ•œèųøxU¡ Í'\ž5øïB%Ç»6 Zç3¾]^ᜈ¢kéô>lšJþ ;ï k>ÚeÞ'*ù6zþ’Eä—Ge¤)ö¤Aù<],;[í¢ÃS;\ô¬Oº†r=l8>Y ŠÃ߀äŠ^ÚÜ9ÙŠÎ ºðNL¯ç‘vczÂÍ­&@S܇¹›Òšg\¬H«VvWc£òŒ .¸ˆ97­{ªXšŘ”ã°—GôoøÛ )ãªÈ‘¶,ÏI8åsöÈQ¦HI 0­›$AbïsŒÖ9ûŠ{ö`_ið–«*^QUt¥ Õ ¢š¹èó‰ñûÏåŒ9%ö<'ì tçE¾B^âKãårÖvs?ê–Ø`ÙÑAé^EAEXP QP –dȹÿPK AyßtÚE,org/gradle/cli/ParsedCommandLineOption.classS]OÔ@=ݯîGeùPa„eQª¨ø"ˆhHV1YƒÁ·awR»í¦íá§ðl⋘¨IÔg”ñN[`Y$ñ¡Ó™Û{Ï=çÜéï?ߘ“4²(ª˜H#‚b ¸ž¦å†ŠÉ$ô4¸™Á-L%q[¾ï¨¸+ßÓr¹§â¾Š [ÌlpWA¶´É¶˜Þð„©—„ëÍ(H•…a1¯áp#-Ÿgƒ³É,C/{Ž°Œ™9*IÌ Kxs ¢…ñU±E»JÅ%añ—Ú:w^³u“"¹’]aæ*s„<‡Á˜·!ˆI¡d;†n8¬jr½b ýs\^]´k5fU%ÔJݶEí’÷V¥Ý…ñ³”´•=Vy÷‚Õé£ j”;*i=z&xŽÔ «V£Qã–§ §p6K:dÇ)¹ñKn07T@–½U.Û §ÂŸ Évàé“ICzt°]p¶-)kèDNÃ(Æ t]6Mn0“,ñøÒû ÷±(#ÍWmîæ-ÛËo°-žgÖvÞ¿“²Ñ°Š‡f0« ?L'æùZÃôDÝäA¦K©@Ó϶*Õðó$¡Ñÿï)”•õM^!ÛO†îŒ+vï–i¥áÊQ,7_… ”¬ŽÒÀZ~“¾«Â]ªÕ½m\¡(K? LºHï.:EÐ8íÉrZ/PdQÚÙâ>”â!"kûˆ~E쳟}‘Vù_‚*bTÓG;-ÈÇ%ôûø¸bí„XÓÅoˆï¢í‰µœºäÏâÄ"¡Âpú(=@&‚_Ðö¨2êwì%Ž ^*õè$üAêPÀPS÷é°û =1D:¥š!䉩ä¡ÓIfÅ%þÞ±„n‚‰‡05W(v•¾bžRD ×$ÈÄÚ"xÓjÊ2D¬Ï§ìç†xr7‚k> º½!âóV.p£]Á.ÔØG²àÓ±ô€ãDÇ\“Ô8"Ùy Rð‰ŒÿPK A\vÆB| :org/gradle/cli/ProjectPropertiesCommandLineConverter.class’KOÂ@…ÏD|?PâìÀšuã#QŒ+¢$÷C;–1m‡  ÿJW&.üþ(ãª1ØDã,îéœ9ßôv¦oï/¯ö±[@yl汕G)‡ívÙ }FHWkw„LSºœ°Ü!¿]®nY×7ÎZK:Ì¿cJDóØÌ螎ZRy¶§˜ësÛñ…ÝVò;ÚHŸ+-ø )ƒ€…n´kS†#cruLXõøgh|Ó×B†„j­õÀFÌöYèÙ­Dè™èÎè%×LøÜ%”ÖŽñŽ…Ž*‡_‰¨å½?õÖˆ:("‡<Ú„bJÕö ®­ØŠtòfë^*K÷¸Õ ßµ¦ XUÞðV½Œ£Üi01Èk ÂÁp8ƒwZ±ß8T0gî?Pôa¦Î›™m”ŒÎí=ƒžÌC S³s ¦§£‹| Ë1\áôZêq-}CÓ_èJšžEˉèjš™E+ ¨ùw'©õPK A Ï8=|ü9org/gradle/cli/SystemPropertiesCommandLineConverter.class’ËJÃ@†ÏØ«mµ¶ÖjÕEÜ5BPÄ…R/Pé~šÓ‘$&ÓBÞJW‚ À‡'i©AÄYœ3óÏÿÍœ¹¼¼¾Àl— "l¡Y„Íl E Ê<&Ï dÚú@¶ËÇH ÚgÞLÝŠ{:r”Rïs‹:C*X4NĬœ°€ÀQŸ Û´;hZ3a ѽÜG!]îºÔG‹v¹7S"Š5eb o}ɸG ÑÖûtFM‡z¶9‚y¶²¶~X{()spL`7e.°KV, øTXxÉ¢Šõ¿”fDT E¤G ÄPÇWãJm®h~²­Æ49Aíjx­µÑ° ­ÓsÃhöÌ gÔ™¢n8üÇ5©Û] .FÔ’¿s°9õàQˉ΢ⲙ*•sû/@žUg J*æc±e+sƒÊ+1¾ Õî$p¦¾ô´€6¿¡™/t-Í,¢;©h-Í.¢Z ª>kìZÿPK AýØ?¢gradle-cli-classpath.properties+(ÊÏJM.)¶å**Í+ÉÌMµåPK A%gradle-cli-parameter-names.propertiesPK A íAMETA-INF/PK Am±>=@?¤)META-INF/MANIFEST.MFPK AíA›org/PK A íA¿org/gradle/PK AíAêorg/gradle/wrapper/PK A•%Ó¦¹/¤org/gradle/wrapper/BootstrapMainStarter$1.classPK Ai,«$ -¤#org/gradle/wrapper/BootstrapMainStarter.classPK AhQþ}¢Ò#¤org/gradle/wrapper/Download$1.classPK A¥"I;ØA¤p org/gradle/wrapper/Download$DefaultDownloadProgressListener.classPK AѺNì,À4¤ org/gradle/wrapper/Download$ProxyAuthenticator.classPK A$É~ãX !¤ˆorg/gradle/wrapper/Download.classPK AyL¢¡Ê1¤ª!org/gradle/wrapper/DownloadProgressListener.classPK A!9|¶„ 3¤š"org/gradle/wrapper/ExclusiveFileAccessManager.classPK Aì„,y†-¤¡)org/gradle/wrapper/GradleUserHomeLookup.classPK A™c67§ *¤e,org/gradle/wrapper/GradleWrapperMain.classPK AúâæªÛ"¤T6org/gradle/wrapper/IDownload.classPK A9lâV†"¤>7org/gradle/wrapper/Install$1.classPK AØ ’$|-¤Ô?org/gradle/wrapper/Install$InstallCheck.classPK Aävp£.- ¤›Borg/gradle/wrapper/Install.classPK Að¿:öo4¤|Worg/gradle/wrapper/Logger.classPK AJJ¯'ï8¤(Zorg/gradle/wrapper/PathAssembler$LocalDistribution.classPK A´çtx7‘&¤ \org/gradle/wrapper/PathAssembler.classPK A„ÍëÂ| 0¤†corg/gradle/wrapper/SystemPropertiesHandler.classPK Aª=©°?-¤–horg/gradle/wrapper/WrapperConfiguration.classPK AGü¨ (¤‘korg/gradle/wrapper/WrapperExecutor.classPK AÔe‹ #¤ìtgradle-wrapper-classpath.propertiesPK A)¤Lugradle-wrapper-parameter-names.propertiesPK AíA•uorg/gradle/cli/PK AÕÜ?®<S1¤Äuorg/gradle/cli/AbstractCommandLineConverter.classPK A׃µ³Xì ;¤Oxorg/gradle/cli/AbstractPropertiesCommandLineConverter.classPK A}­ÎyGK1¤}org/gradle/cli/CommandLineArgumentException.classPK A³ßâúg)¤–~org/gradle/cli/CommandLineConverter.classPK ASf Õg&¤öorg/gradle/cli/CommandLineOption.classPK Aü튯¥å(¤<†org/gradle/cli/CommandLineParser$1.classPK A$f{K¿ ;¤'‡org/gradle/cli/CommandLineParser$AfterFirstSubCommand.classPK A¥D£¢&3¤ËŠorg/gradle/cli/CommandLineParser$AfterOptions.classPK AŒ‹Müu <¤¾org/gradle/cli/CommandLineParser$BeforeFirstSubCommand.classPK A´*«ZMïF¤’org/gradle/cli/CommandLineParser$CaseInsensitiveStringComparator.classPK A|ìRÎÐ&=¤Å”org/gradle/cli/CommandLineParser$KnownOptionParserState.classPK A$ľ¢¥ô<¤ð›org/gradle/cli/CommandLineParser$MissingOptionArgState.classPK ATK>ªÄ=¤ïžorg/gradle/cli/CommandLineParser$OptionAwareParserState.classPK A˜%àÌ»ª7¤ô¡org/gradle/cli/CommandLineParser$OptionComparator.classPK AäfC˜§£8¤¥org/gradle/cli/CommandLineParser$OptionParserState.classPK A¢Æ÷E«¶3¤§org/gradle/cli/CommandLineParser$OptionString.classPK AgAq²”x=¤ý©org/gradle/cli/CommandLineParser$OptionStringComparator.classPK A`M~U¸2¤ì¬org/gradle/cli/CommandLineParser$ParserState.classPK ApÍX Ýk?¤@¯org/gradle/cli/CommandLineParser$UnknownOptionParserState.classPK A£=l)&¤z²org/gradle/cli/CommandLineParser.classPK A‹å>É&¤ÔÄorg/gradle/cli/ParsedCommandLine.classPK AyßtÚE,¤áÌorg/gradle/cli/ParsedCommandLineOption.classPK A\vÆB| :¤Ðorg/gradle/cli/ProjectPropertiesCommandLineConverter.classPK A Ï8=|ü9¤ÙÑorg/gradle/cli/SystemPropertiesCommandLineConverter.classPK AýØ?¢¤¬Ógradle-cli-classpath.propertiesPK A%¤þÓgradle-cli-parameter-names.propertiesPK66êCÔOnJava8-Examples-1.0/gradle/wrapper/gradle-wrapper.properties000066400000000000000000000003101374004044700243410ustar00rootroot00000000000000distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists distributionUrl=https\://services.gradle.org/distributions/gradle-6.6-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists OnJava8-Examples-1.0/gradlew000077500000000000000000000132061374004044700157540ustar00rootroot00000000000000#!/usr/bin/env sh # # Copyright 2015 the original author or authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ############################################################################## ## ## Gradle start up script for UN*X ## ############################################################################## # Attempt to set APP_HOME # Resolve links: $0 may be a link PRG="$0" # Need this for relative symlinks. while [ -h "$PRG" ] ; do ls=`ls -ld "$PRG"` link=`expr "$ls" : '.*-> \(.*\)$'` if expr "$link" : '/.*' > /dev/null; then PRG="$link" else PRG=`dirname "$PRG"`"/$link" fi done SAVED="`pwd`" cd "`dirname \"$PRG\"`/" >/dev/null APP_HOME="`pwd -P`" cd "$SAVED" >/dev/null APP_NAME="Gradle" APP_BASE_NAME=`basename "$0"` # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' # Use the maximum available, or set MAX_FD != -1 to use that value. MAX_FD="maximum" warn () { echo "$*" } die () { echo echo "$*" echo exit 1 } # OS specific support (must be 'true' or 'false'). cygwin=false msys=false darwin=false nonstop=false case "`uname`" in CYGWIN* ) cygwin=true ;; Darwin* ) darwin=true ;; MINGW* ) msys=true ;; NONSTOP* ) nonstop=true ;; esac CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar # Determine the Java command to use to start the JVM. if [ -n "$JAVA_HOME" ] ; then if [ -x "$JAVA_HOME/jre/sh/java" ] ; then # IBM's JDK on AIX uses strange locations for the executables JAVACMD="$JAVA_HOME/jre/sh/java" else JAVACMD="$JAVA_HOME/bin/java" fi if [ ! -x "$JAVACMD" ] ; then die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi else JAVACMD="java" which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. Please set the JAVA_HOME variable in your environment to match the location of your Java installation." fi # Increase the maximum file descriptors if we can. if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then MAX_FD_LIMIT=`ulimit -H -n` if [ $? -eq 0 ] ; then if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then MAX_FD="$MAX_FD_LIMIT" fi ulimit -n $MAX_FD if [ $? -ne 0 ] ; then warn "Could not set maximum file descriptor limit: $MAX_FD" fi else warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" fi fi # For Darwin, add options to specify how the application appears in the dock if $darwin; then GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" fi # For Cygwin or MSYS, switch paths to Windows format before running java if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then APP_HOME=`cygpath --path --mixed "$APP_HOME"` CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` JAVACMD=`cygpath --unix "$JAVACMD"` # We build the pattern for arguments to be converted via cygpath ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` SEP="" for dir in $ROOTDIRSRAW ; do ROOTDIRS="$ROOTDIRS$SEP$dir" SEP="|" done OURCYGPATTERN="(^($ROOTDIRS))" # Add a user-defined pattern to the cygpath arguments if [ "$GRADLE_CYGPATTERN" != "" ] ; then OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" fi # Now convert the arguments - kludge to limit ourselves to /bin/sh i=0 for arg in "$@" ; do CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` else eval `echo args$i`="\"$arg\"" fi i=`expr $i + 1` done case $i in 0) set -- ;; 1) set -- "$args0" ;; 2) set -- "$args0" "$args1" ;; 3) set -- "$args0" "$args1" "$args2" ;; 4) set -- "$args0" "$args1" "$args2" "$args3" ;; 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; esac fi # Escape application args save () { for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done echo " " } APP_ARGS=`save "$@"` # Collect all arguments for the java command, following the shell quoting and substitution rules eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" exec "$JAVACMD" "$@" OnJava8-Examples-1.0/gradlew.bat000066400000000000000000000051621374004044700165200ustar00rootroot00000000000000@rem @rem Copyright 2015 the original author or authors. @rem @rem Licensed under the Apache License, Version 2.0 (the "License"); @rem you may not use this file except in compliance with the License. @rem You may obtain a copy of the License at @rem @rem https://www.apache.org/licenses/LICENSE-2.0 @rem @rem Unless required by applicable law or agreed to in writing, software @rem distributed under the License is distributed on an "AS IS" BASIS, @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @rem See the License for the specific language governing permissions and @rem limitations under the License. @rem @if "%DEBUG%" == "" @echo off @rem ########################################################################## @rem @rem Gradle startup script for Windows @rem @rem ########################################################################## @rem Set local scope for the variables with windows NT shell if "%OS%"=="Windows_NT" setlocal set DIRNAME=%~dp0 if "%DIRNAME%" == "" set DIRNAME=. set APP_BASE_NAME=%~n0 set APP_HOME=%DIRNAME% @rem Resolve any "." and ".." in APP_HOME to make it shorter. for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" @rem Find java.exe if defined JAVA_HOME goto findJavaFromJavaHome set JAVA_EXE=java.exe %JAVA_EXE% -version >NUL 2>&1 if "%ERRORLEVEL%" == "0" goto execute echo. echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :findJavaFromJavaHome set JAVA_HOME=%JAVA_HOME:"=% set JAVA_EXE=%JAVA_HOME%/bin/java.exe if exist "%JAVA_EXE%" goto execute echo. echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% echo. echo Please set the JAVA_HOME variable in your environment to match the echo location of your Java installation. goto fail :execute @rem Setup the command line set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar @rem Execute Gradle "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* :end @rem End local scope for the variables with windows NT shell if "%ERRORLEVEL%"=="0" goto mainEnd :fail rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of rem the _cmd.exe /c_ return code! if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 exit /b 1 :mainEnd if "%OS%"=="Windows_NT" endlocal :omega OnJava8-Examples-1.0/hiding/000077500000000000000000000000001374004044700156415ustar00rootroot00000000000000OnJava8-Examples-1.0/hiding/Cake.java000066400000000000000000000005401374004044700173460ustar00rootroot00000000000000// hiding/Cake.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Accesses a class in a separate compilation unit class Cake { public static void main(String[] args) { Pie x = new Pie(); x.f(); } } /* Output: Pie.f() */ OnJava8-Examples-1.0/hiding/ChocolateChip.java000066400000000000000000000011701374004044700212100ustar00rootroot00000000000000// hiding/ChocolateChip.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Can't use package-access member from another package import hiding.dessert.*; public class ChocolateChip extends Cookie { public ChocolateChip() { System.out.println("ChocolateChip constructor"); } public void chomp() { //- bite(); // Can't access bite } public static void main(String[] args) { ChocolateChip x = new ChocolateChip(); x.chomp(); } } /* Output: Cookie constructor ChocolateChip constructor */ OnJava8-Examples-1.0/hiding/ChocolateChip2.java000066400000000000000000000011001374004044700212630ustar00rootroot00000000000000// hiding/ChocolateChip2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import hiding.cookie2.*; public class ChocolateChip2 extends Cookie { public ChocolateChip2() { System.out.println("ChocolateChip2 constructor"); } public void chomp() { bite(); } // Protected method public static void main(String[] args) { ChocolateChip2 x = new ChocolateChip2(); x.chomp(); } } /* Output: Cookie constructor ChocolateChip2 constructor bite */ OnJava8-Examples-1.0/hiding/CreatePackageAccessObject.java000066400000000000000000000005661374004044700234430ustar00rootroot00000000000000// hiding/CreatePackageAccessObject.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} import hiding.packageaccess.*; public class CreatePackageAccessObject { public static void main(String[] args) { new PublicConstructor(); } } OnJava8-Examples-1.0/hiding/Dinner.java000066400000000000000000000006151374004044700177250ustar00rootroot00000000000000// hiding/Dinner.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Uses the library import hiding.dessert.*; public class Dinner { public static void main(String[] args) { Cookie x = new Cookie(); //- x.bite(); // Can't access } } /* Output: Cookie constructor */ OnJava8-Examples-1.0/hiding/FullQualification.java000066400000000000000000000005261374004044700221220ustar00rootroot00000000000000// hiding/FullQualification.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class FullQualification { public static void main(String[] args) { java.util.ArrayList list = new java.util.ArrayList(); } } OnJava8-Examples-1.0/hiding/IceCream.java000066400000000000000000000007211374004044700201540ustar00rootroot00000000000000// hiding/IceCream.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates "private" keyword class Sundae { private Sundae() {} static Sundae makeASundae() { return new Sundae(); } } public class IceCream { public static void main(String[] args) { //- Sundae x = new Sundae(); Sundae x = Sundae.makeASundae(); } } OnJava8-Examples-1.0/hiding/ImportedMyClass.java000066400000000000000000000005141374004044700215630ustar00rootroot00000000000000// hiding/ImportedMyClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import hiding.mypackage.*; public class ImportedMyClass { public static void main(String[] args) { MyClass m = new MyClass(); } } OnJava8-Examples-1.0/hiding/LibTest.java000066400000000000000000000006651374004044700200610ustar00rootroot00000000000000// hiding/LibTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Uses the library import com.mindviewinc.simple.*; public class LibTest { public static void main(String[] args) { Vector v = new Vector(); List l = new List(); } } /* Output: com.mindviewinc.simple.Vector com.mindviewinc.simple.List */ OnJava8-Examples-1.0/hiding/Lunch.java000066400000000000000000000015111374004044700175530ustar00rootroot00000000000000// hiding/Lunch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates class access specifiers. Make a class // effectively private with private constructors: class Soup1 { private Soup1() {} public static Soup1 makeSoup() { // [1] return new Soup1(); } } class Soup2 { private Soup2() {} private static Soup2 ps1 = new Soup2(); // [2] public static Soup2 access() { return ps1; } public void f() {} } // Only one public class allowed per file: public class Lunch { void testPrivate() { // Can't do this! Private constructor: //- Soup1 soup = new Soup1(); } void testStatic() { Soup1 soup = Soup1.makeSoup(); } void testSingleton() { Soup2.access().f(); } } OnJava8-Examples-1.0/hiding/OrganizedByAccess.java000066400000000000000000000007311374004044700220440ustar00rootroot00000000000000// hiding/OrganizedByAccess.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class OrganizedByAccess { public void pub1() { /* ... */ } public void pub2() { /* ... */ } public void pub3() { /* ... */ } private void priv1() { /* ... */ } private void priv2() { /* ... */ } private void priv3() { /* ... */ } private int i; // ... } OnJava8-Examples-1.0/hiding/Pie.java000066400000000000000000000004051374004044700172200ustar00rootroot00000000000000// hiding/Pie.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The other class class Pie { void f() { System.out.println("Pie.f()"); } } OnJava8-Examples-1.0/hiding/QualifiedMyClass.java000066400000000000000000000005331374004044700217040ustar00rootroot00000000000000// hiding/QualifiedMyClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class QualifiedMyClass { public static void main(String[] args) { hiding.mypackage.MyClass m = new hiding.mypackage.MyClass(); } } OnJava8-Examples-1.0/hiding/SingleImport.java000066400000000000000000000005161374004044700211220ustar00rootroot00000000000000// hiding/SingleImport.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.ArrayList; public class SingleImport { public static void main(String[] args) { ArrayList list = new ArrayList(); } } OnJava8-Examples-1.0/hiding/cookie2/000077500000000000000000000000001374004044700171745ustar00rootroot00000000000000OnJava8-Examples-1.0/hiding/cookie2/Cookie.java000066400000000000000000000005651374004044700212560ustar00rootroot00000000000000// hiding/cookie2/Cookie.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package hiding.cookie2; public class Cookie { public Cookie() { System.out.println("Cookie constructor"); } protected void bite() { System.out.println("bite"); } } OnJava8-Examples-1.0/hiding/dessert/000077500000000000000000000000001374004044700173125ustar00rootroot00000000000000OnJava8-Examples-1.0/hiding/dessert/Cookie.java000066400000000000000000000005711374004044700213710ustar00rootroot00000000000000// hiding/dessert/Cookie.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creates a library package hiding.dessert; public class Cookie { public Cookie() { System.out.println("Cookie constructor"); } void bite() { System.out.println("bite"); } } OnJava8-Examples-1.0/hiding/mypackage/000077500000000000000000000000001374004044700176025ustar00rootroot00000000000000OnJava8-Examples-1.0/hiding/mypackage/MyClass.java000066400000000000000000000004001374004044700220120ustar00rootroot00000000000000// hiding/mypackage/MyClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package hiding.mypackage; public class MyClass { // ... } OnJava8-Examples-1.0/hiding/packageaccess/000077500000000000000000000000001374004044700204165ustar00rootroot00000000000000OnJava8-Examples-1.0/hiding/packageaccess/PublicConstructor.java000066400000000000000000000004541374004044700247500ustar00rootroot00000000000000// hiding/packageaccess/PublicConstructor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package hiding.packageaccess; class PublicConstructor { public PublicConstructor() {} } OnJava8-Examples-1.0/housekeeping/000077500000000000000000000000001374004044700170655ustar00rootroot00000000000000OnJava8-Examples-1.0/housekeeping/Apricot.java000066400000000000000000000004271374004044700213340ustar00rootroot00000000000000// housekeeping/Apricot.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Apricot { void pick() { /* ... */ } void pit() { pick(); /* ... */ } } OnJava8-Examples-1.0/housekeeping/ArrayClassObj.java000066400000000000000000000013221374004044700224250ustar00rootroot00000000000000// housekeeping/ArrayClassObj.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating an array of nonprimitive objects import java.util.*; public class ArrayClassObj { public static void main(String[] args) { Random rand = new Random(47); Integer[] a = new Integer[rand.nextInt(20)]; System.out.println("length of a = " + a.length); for(int i = 0; i < a.length; i++) a[i] = rand.nextInt(500); // Autoboxing System.out.println(Arrays.toString(a)); } } /* Output: length of a = 18 [55, 193, 361, 461, 429, 368, 200, 22, 207, 288, 128, 51, 89, 309, 278, 498, 361, 20] */ OnJava8-Examples-1.0/housekeeping/ArrayInit.java000066400000000000000000000010731374004044700216330ustar00rootroot00000000000000// housekeeping/ArrayInit.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Array initialization import java.util.*; public class ArrayInit { public static void main(String[] args) { Integer[] a = { 1, 2, 3, // Autoboxing }; Integer[] b = new Integer[]{ 1, 2, 3, // Autoboxing }; System.out.println(Arrays.toString(a)); System.out.println(Arrays.toString(b)); } } /* Output: [1, 2, 3] [1, 2, 3] */ OnJava8-Examples-1.0/housekeeping/ArrayNew.java000066400000000000000000000011031374004044700214530ustar00rootroot00000000000000// housekeeping/ArrayNew.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating arrays with new import java.util.*; public class ArrayNew { public static void main(String[] args) { int[] a; Random rand = new Random(47); a = new int[rand.nextInt(20)]; System.out.println("length of a = " + a.length); System.out.println(Arrays.toString(a)); } } /* Output: length of a = 18 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] */ OnJava8-Examples-1.0/housekeeping/ArraysOfPrimitives.java000066400000000000000000000010611374004044700235300ustar00rootroot00000000000000// housekeeping/ArraysOfPrimitives.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ArraysOfPrimitives { public static void main(String[] args) { int[] a1 = { 1, 2, 3, 4, 5 }; int[] a2; a2 = a1; for(int i = 0; i < a2.length; i++) a2[i] += 1; for(int i = 0; i < a1.length; i++) System.out.println("a1[" + i + "] = " + a1[i]); } } /* Output: a1[0] = 2 a1[1] = 3 a1[2] = 4 a1[3] = 5 a1[4] = 6 */ OnJava8-Examples-1.0/housekeeping/AutoboxingVarargs.java000066400000000000000000000007771374004044700234100ustar00rootroot00000000000000// housekeeping/AutoboxingVarargs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class AutoboxingVarargs { public static void f(Integer... args) { for(Integer i : args) System.out.print(i + " "); System.out.println(); } public static void main(String[] args) { f(1, 2); f(4, 5, 6, 7, 8, 9); f(10, 11, 12); } } /* Output: 1 2 4 5 6 7 8 9 10 11 12 */ OnJava8-Examples-1.0/housekeeping/BananaPeel.java000066400000000000000000000006271374004044700217230ustar00rootroot00000000000000// housekeeping/BananaPeel.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Banana { void peel(int i) { /* ... */ } } public class BananaPeel { public static void main(String[] args) { Banana a = new Banana(), b = new Banana(); a.peel(1); b.peel(2); } } OnJava8-Examples-1.0/housekeeping/Burrito.java000066400000000000000000000020741374004044700213610ustar00rootroot00000000000000// housekeeping/Burrito.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Burrito { Spiciness degree; public Burrito(Spiciness degree) { this.degree = degree; } public void describe() { System.out.print("This burrito is "); switch(degree) { case NOT: System.out.println( "not spicy at all."); break; case MILD: case MEDIUM: System.out.println("a little hot."); break; case HOT: case FLAMING: default: System.out.println("maybe too hot."); } } public static void main(String[] args) { Burrito plain = new Burrito(Spiciness.NOT), greenChile = new Burrito(Spiciness.MEDIUM), jalapeno = new Burrito(Spiciness.HOT); plain.describe(); greenChile.describe(); jalapeno.describe(); } } /* Output: This burrito is not spicy at all. This burrito is a little hot. This burrito is maybe too hot. */ OnJava8-Examples-1.0/housekeeping/Counter.java000066400000000000000000000004011374004044700213420ustar00rootroot00000000000000// housekeeping/Counter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Counter { int i; Counter() { i = 7; } // ... } OnJava8-Examples-1.0/housekeeping/DefaultConstructor.java000066400000000000000000000005221374004044700235610ustar00rootroot00000000000000// housekeeping/DefaultConstructor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Bird {} public class DefaultConstructor { public static void main(String[] args) { Bird b = new Bird(); // Default! } } OnJava8-Examples-1.0/housekeeping/Demotion.java000066400000000000000000000020131374004044700215020ustar00rootroot00000000000000// housekeeping/Demotion.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demotion of primitives public class Demotion { void f1(double x) { System.out.println("f1(double)"); } void f2(float x) { System.out.println("f2(float)"); } void f3(long x) { System.out.println("f3(long)"); } void f4(int x) { System.out.println("f4(int)"); } void f5(short x) { System.out.println("f5(short)"); } void f6(byte x) { System.out.println("f6(byte)"); } void f7(char x) { System.out.println("f7(char)"); } void testDouble() { double x = 0; System.out.println("double argument:"); f1(x); f2((float)x); f3((long)x); f4((int)x); f5((short)x); f6((byte)x); f7((char)x); } public static void main(String[] args) { Demotion p = new Demotion(); p.testDouble(); } } /* Output: double argument: f1(double) f2(float) f3(long) f4(int) f5(short) f6(byte) f7(char) */ OnJava8-Examples-1.0/housekeeping/DynamicArray.java000066400000000000000000000007671374004044700223250ustar00rootroot00000000000000// housekeeping/DynamicArray.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Array initialization public class DynamicArray { public static void main(String[] args) { Other.main(new String[]{ "fiddle", "de", "dum" }); } } class Other { public static void main(String[] args) { for(String s : args) System.out.print(s + " "); } } /* Output: fiddle de dum */ OnJava8-Examples-1.0/housekeeping/EnumOrder.java000066400000000000000000000007321374004044700216320ustar00rootroot00000000000000// housekeeping/EnumOrder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class EnumOrder { public static void main(String[] args) { for(Spiciness s : Spiciness.values()) System.out.println( s + ", ordinal " + s.ordinal()); } } /* Output: NOT, ordinal 0 MILD, ordinal 1 MEDIUM, ordinal 2 HOT, ordinal 3 FLAMING, ordinal 4 */ OnJava8-Examples-1.0/housekeeping/ExplicitStatic.java000066400000000000000000000015371374004044700226670ustar00rootroot00000000000000// housekeeping/ExplicitStatic.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Explicit static initialization with "static" clause class Cup { Cup(int marker) { System.out.println("Cup(" + marker + ")"); } void f(int marker) { System.out.println("f(" + marker + ")"); } } class Cups { static Cup cup1; static Cup cup2; static { cup1 = new Cup(1); cup2 = new Cup(2); } Cups() { System.out.println("Cups()"); } } public class ExplicitStatic { public static void main(String[] args) { System.out.println("Inside main()"); Cups.cup1.f(99); // [1] } // static Cups cups1 = new Cups(); // [2] // static Cups cups2 = new Cups(); // [2] } /* Output: Inside main() Cup(1) Cup(2) f(99) */ OnJava8-Examples-1.0/housekeeping/Flower.java000066400000000000000000000022551374004044700211720ustar00rootroot00000000000000// housekeeping/Flower.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Calling constructors with "this" public class Flower { int petalCount = 0; String s = "initial value"; Flower(int petals) { petalCount = petals; System.out.println( "Constructor w/ int arg only, petalCount= " + petalCount); } Flower(String ss) { System.out.println( "Constructor w/ String arg only, s = " + ss); s = ss; } Flower(String s, int petals) { this(petals); //- this(s); // Can't call two! this.s = s; // Another use of "this" System.out.println("String & int args"); } Flower() { this("hi", 47); System.out.println("no-arg constructor"); } void printPetalCount() { //- this(11); // Not inside non-constructor! System.out.println( "petalCount = " + petalCount + " s = "+ s); } public static void main(String[] args) { Flower x = new Flower(); x.printPetalCount(); } } /* Output: Constructor w/ int arg only, petalCount= 47 String & int args no-arg constructor petalCount = 47 s = hi */ OnJava8-Examples-1.0/housekeeping/InitialValues.java000066400000000000000000000021721374004044700225030ustar00rootroot00000000000000// housekeeping/InitialValues.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Shows default initial values public class InitialValues { boolean t; char c; byte b; short s; int i; long l; float f; double d; InitialValues reference; void printInitialValues() { System.out.println("Data type Initial value"); System.out.println("boolean " + t); System.out.println("char [" + c + "]"); System.out.println("byte " + b); System.out.println("short " + s); System.out.println("int " + i); System.out.println("long " + l); System.out.println("float " + f); System.out.println("double " + d); System.out.println("reference " + reference); } public static void main(String[] args) { new InitialValues().printInitialValues(); } } /* Output: Data type Initial value boolean false char [NUL] byte 0 short 0 int 0 long 0 float 0.0 double 0.0 reference null */ OnJava8-Examples-1.0/housekeeping/InitialValues2.java000066400000000000000000000006351374004044700225670ustar00rootroot00000000000000// housekeeping/InitialValues2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Providing explicit initial values public class InitialValues2 { boolean bool = true; char ch = 'x'; byte b = 47; short s = 0xff; int i = 999; long lng = 1; float f = 3.14f; double d = 3.14159; } OnJava8-Examples-1.0/housekeeping/Leaf.java000066400000000000000000000007771374004044700206120ustar00rootroot00000000000000// housekeeping/Leaf.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple use of the "this" keyword public class Leaf { int i = 0; Leaf increment() { i++; return this; } void print() { System.out.println("i = " + i); } public static void main(String[] args) { Leaf x = new Leaf(); x.increment().increment().increment().print(); } } /* Output: i = 3 */ OnJava8-Examples-1.0/housekeeping/Measurement.java000066400000000000000000000004221374004044700222130ustar00rootroot00000000000000// housekeeping/Measurement.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Depth {} public class Measurement { Depth d = new Depth(); // ... } OnJava8-Examples-1.0/housekeeping/MethodInit.java000066400000000000000000000004061374004044700217740ustar00rootroot00000000000000// housekeeping/MethodInit.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class MethodInit { int i = f(); int f() { return 11; } } OnJava8-Examples-1.0/housekeeping/MethodInit2.java000066400000000000000000000004721374004044700220610ustar00rootroot00000000000000// housekeeping/MethodInit2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class MethodInit2 { int i = f(); int j = g(i); int f() { return 11; } int g(int n) { return n * 10; } } OnJava8-Examples-1.0/housekeeping/MethodInit3.java000066400000000000000000000005331374004044700220600ustar00rootroot00000000000000// housekeeping/MethodInit3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class MethodInit3 { //- int j = g(i); // Illegal forward reference int i = f(); int f() { return 11; } int g(int n) { return n * 10; } } OnJava8-Examples-1.0/housekeeping/Mugs.java000066400000000000000000000016641374004044700206520ustar00rootroot00000000000000// housekeeping/Mugs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Instance initialization class Mug { Mug(int marker) { System.out.println("Mug(" + marker + ")"); } } public class Mugs { Mug mug1; Mug mug2; { // [1] mug1 = new Mug(1); mug2 = new Mug(2); System.out.println("mug1 & mug2 initialized"); } Mugs() { System.out.println("Mugs()"); } Mugs(int i) { System.out.println("Mugs(int)"); } public static void main(String[] args) { System.out.println("Inside main()"); new Mugs(); System.out.println("new Mugs() completed"); new Mugs(1); System.out.println("new Mugs(1) completed"); } } /* Output: Inside main() Mug(1) Mug(2) mug1 & mug2 initialized Mugs() new Mugs() completed Mug(1) Mug(2) mug1 & mug2 initialized Mugs(int) new Mugs(1) completed */ OnJava8-Examples-1.0/housekeeping/NewVarArgs.java000066400000000000000000000015411374004044700217500ustar00rootroot00000000000000// housekeeping/NewVarArgs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using array syntax to create variable argument lists public class NewVarArgs { static void printArray(Object... args) { for(Object obj : args) System.out.print(obj + " "); System.out.println(); } public static void main(String[] args) { // Can take individual elements: printArray(47, (float) 3.14, 11.11); printArray(47, 3.14F, 11.11); printArray("one", "two", "three"); printArray(new A(), new A(), new A()); // Or an array: printArray((Object[])new Integer[]{ 1, 2, 3, 4 }); printArray(); // Empty list is OK } } /* Output: 47 3.14 11.11 47 3.14 11.11 one two three A@15db9742 A@6d06d69c A@7852e922 1 2 3 4 */ OnJava8-Examples-1.0/housekeeping/NoSynthesis.java000066400000000000000000000006611374004044700222210ustar00rootroot00000000000000// housekeeping/NoSynthesis.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Bird2 { Bird2(int i) {} Bird2(double d) {} } public class NoSynthesis { public static void main(String[] args) { //- Bird2 b = new Bird2(); // No default Bird2 b2 = new Bird2(1); Bird2 b3 = new Bird2(1.0); } } OnJava8-Examples-1.0/housekeeping/OptionalTrailingArguments.java000066400000000000000000000011461374004044700250770ustar00rootroot00000000000000// housekeeping/OptionalTrailingArguments.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class OptionalTrailingArguments { static void f(int required, String... trailing) { System.out.print("required: " + required + " "); for(String s : trailing) System.out.print(s + " "); System.out.println(); } public static void main(String[] args) { f(1, "one"); f(2, "two", "three"); f(0); } } /* Output: required: 1 one required: 2 two three required: 0 */ OnJava8-Examples-1.0/housekeeping/OrderOfInitialization.java000066400000000000000000000017331374004044700242040ustar00rootroot00000000000000// housekeeping/OrderOfInitialization.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates initialization order // When the constructor is called to create a // Window object, you'll see a message: class Window { Window(int marker) { System.out.println("Window(" + marker + ")"); } } class House { Window w1 = new Window(1); // Before constructor House() { // Show that we're in the constructor: System.out.println("House()"); w3 = new Window(33); // Reinitialize w3 } Window w2 = new Window(2); // After constructor void f() { System.out.println("f()"); } Window w3 = new Window(3); // At end } public class OrderOfInitialization { public static void main(String[] args) { House h = new House(); h.f(); // Shows that construction is done } } /* Output: Window(1) Window(2) Window(3) House() Window(33) f() */ OnJava8-Examples-1.0/housekeeping/Overloading.java000066400000000000000000000026501374004044700222040ustar00rootroot00000000000000// housekeeping/Overloading.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Both constructor and ordinary method overloading class Tree { int height; Tree() { System.out.println("Planting a seedling"); height = 0; } Tree(int initialHeight) { height = initialHeight; System.out.println("Creating new Tree that is " + height + " feet tall"); } void info() { System.out.println( "Tree is " + height + " feet tall"); } void info(String s) { System.out.println( s + ": Tree is " + height + " feet tall"); } } public class Overloading { public static void main(String[] args) { for(int i = 0; i < 5; i++) { Tree t = new Tree(i); t.info(); t.info("overloaded method"); } // Overloaded constructor: new Tree(); } } /* Output: Creating new Tree that is 0 feet tall Tree is 0 feet tall overloaded method: Tree is 0 feet tall Creating new Tree that is 1 feet tall Tree is 1 feet tall overloaded method: Tree is 1 feet tall Creating new Tree that is 2 feet tall Tree is 2 feet tall overloaded method: Tree is 2 feet tall Creating new Tree that is 3 feet tall Tree is 3 feet tall overloaded method: Tree is 3 feet tall Creating new Tree that is 4 feet tall Tree is 4 feet tall overloaded method: Tree is 4 feet tall Planting a seedling */ OnJava8-Examples-1.0/housekeeping/OverloadingOrder.java000066400000000000000000000012051374004044700231730ustar00rootroot00000000000000// housekeeping/OverloadingOrder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Overloading based on the order of the arguments public class OverloadingOrder { static void f(String s, int i) { System.out.println("String: " + s + ", int: " + i); } static void f(int i, String s) { System.out.println("int: " + i + ", String: " + s); } public static void main(String[] args) { f("String first", 11); f(99, "Int first"); } } /* Output: String: String first, int: 11 int: 99, String: Int first */ OnJava8-Examples-1.0/housekeeping/OverloadingVarargs.java000066400000000000000000000015101374004044700235240ustar00rootroot00000000000000// housekeeping/OverloadingVarargs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class OverloadingVarargs { static void f(Character... args) { System.out.print("first"); for(Character c : args) System.out.print(" " + c); System.out.println(); } static void f(Integer... args) { System.out.print("second"); for(Integer i : args) System.out.print(" " + i); System.out.println(); } static void f(Long... args) { System.out.println("third"); } public static void main(String[] args) { f('a', 'b', 'c'); f(1); f(2, 1); f(0); f(0L); //- f(); // Won't compile -- ambiguous } } /* Output: first a b c second 1 second 2 1 second 0 third */ OnJava8-Examples-1.0/housekeeping/OverloadingVarargs2.java000066400000000000000000000007601374004044700236140ustar00rootroot00000000000000// housekeeping/OverloadingVarargs2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} public class OverloadingVarargs2 { static void f(float i, Character... args) { System.out.println("first"); } static void f(Character... args) { System.out.print("second"); } public static void main(String[] args) { f(1, 'a'); f('a', 'b'); } } OnJava8-Examples-1.0/housekeeping/OverloadingVarargs3.java000066400000000000000000000010011374004044700236020ustar00rootroot00000000000000// housekeeping/OverloadingVarargs3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class OverloadingVarargs3 { static void f(float i, Character... args) { System.out.println("first"); } static void f(char c, Character... args) { System.out.println("second"); } public static void main(String[] args) { f(1, 'a'); f('a', 'b'); } } /* Output: first second */ OnJava8-Examples-1.0/housekeeping/PassingThis.java000066400000000000000000000011641374004044700221660ustar00rootroot00000000000000// housekeeping/PassingThis.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Person { public void eat(Apple apple) { Apple peeled = apple.getPeeled(); System.out.println("Yummy"); } } class Peeler { static Apple peel(Apple apple) { // ... remove peel return apple; // Peeled } } class Apple { Apple getPeeled() { return Peeler.peel(this); } } public class PassingThis { public static void main(String[] args) { new Person().eat(new Apple()); } } /* Output: Yummy */ OnJava8-Examples-1.0/housekeeping/PrimitiveOverloading.java000066400000000000000000000073651374004044700241050ustar00rootroot00000000000000// housekeeping/PrimitiveOverloading.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Promotion of primitives and overloading public class PrimitiveOverloading { void f1(char x) { System.out.print("f1(char) "); } void f1(byte x) { System.out.print("f1(byte) "); } void f1(short x) { System.out.print("f1(short) "); } void f1(int x) { System.out.print("f1(int) "); } void f1(long x) { System.out.print("f1(long) "); } void f1(float x) { System.out.print("f1(float) "); } void f1(double x) { System.out.print("f1(double) "); } void f2(byte x) { System.out.print("f2(byte) "); } void f2(short x) { System.out.print("f2(short) "); } void f2(int x) { System.out.print("f2(int) "); } void f2(long x) { System.out.print("f2(long) "); } void f2(float x) { System.out.print("f2(float) "); } void f2(double x) { System.out.print("f2(double) "); } void f3(short x) { System.out.print("f3(short) "); } void f3(int x) { System.out.print("f3(int) "); } void f3(long x) { System.out.print("f3(long) "); } void f3(float x) { System.out.print("f3(float) "); } void f3(double x) { System.out.print("f3(double) "); } void f4(int x) { System.out.print("f4(int) "); } void f4(long x) { System.out.print("f4(long) "); } void f4(float x) { System.out.print("f4(float) "); } void f4(double x) { System.out.print("f4(double) "); } void f5(long x) { System.out.print("f5(long) "); } void f5(float x) { System.out.print("f5(float) "); } void f5(double x) { System.out.print("f5(double) "); } void f6(float x) { System.out.print("f6(float) "); } void f6(double x) { System.out.print("f6(double) "); } void f7(double x) { System.out.print("f7(double) "); } void testConstVal() { System.out.print("5: "); f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5); System.out.println(); } void testChar() { char x = 'x'; System.out.print("char: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } void testByte() { byte x = 0; System.out.print("byte: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } void testShort() { short x = 0; System.out.print("short: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } void testInt() { int x = 0; System.out.print("int: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } void testLong() { long x = 0; System.out.print("long: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } void testFloat() { float x = 0; System.out.print("float: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } void testDouble() { double x = 0; System.out.print("double: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x); System.out.println(); } public static void main(String[] args) { PrimitiveOverloading p = new PrimitiveOverloading(); p.testConstVal(); p.testChar(); p.testByte(); p.testShort(); p.testInt(); p.testLong(); p.testFloat(); p.testDouble(); } } /* Output: 5: f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) char: f1(char) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) byte: f1(byte) f2(byte) f3(short) f4(int) f5(long) f6(float) f7(double) short: f1(short) f2(short) f3(short) f4(int) f5(long) f6(float) f7(double) int: f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) long: f1(long) f2(long) f3(long) f4(long) f5(long) f6(float) f7(double) float: f1(float) f2(float) f3(float) f4(float) f5(float) f6(float) f7(double) double: f1(double) f2(double) f3(double) f4(double) f5(double) f6(double) f7(double) */ OnJava8-Examples-1.0/housekeeping/SimpleConstructor.java000066400000000000000000000010201374004044700234200ustar00rootroot00000000000000// housekeeping/SimpleConstructor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of a simple constructor class Rock { Rock() { // This is the constructor System.out.print("Rock "); } } public class SimpleConstructor { public static void main(String[] args) { for(int i = 0; i < 10; i++) new Rock(); } } /* Output: Rock Rock Rock Rock Rock Rock Rock Rock Rock Rock */ OnJava8-Examples-1.0/housekeeping/SimpleConstructor2.java000066400000000000000000000010111374004044700235020ustar00rootroot00000000000000// housekeeping/SimpleConstructor2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Constructors can have arguments class Rock2 { Rock2(int i) { System.out.print("Rock " + i + " "); } } public class SimpleConstructor2 { public static void main(String[] args) { for(int i = 0; i < 8; i++) new Rock2(i); } } /* Output: Rock 0 Rock 1 Rock 2 Rock 3 Rock 4 Rock 5 Rock 6 Rock 7 */ OnJava8-Examples-1.0/housekeeping/SimpleEnumUse.java000066400000000000000000000005621374004044700224660ustar00rootroot00000000000000// housekeeping/SimpleEnumUse.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SimpleEnumUse { public static void main(String[] args) { Spiciness howHot = Spiciness.MEDIUM; System.out.println(howHot); } } /* Output: MEDIUM */ OnJava8-Examples-1.0/housekeeping/Spiciness.java000066400000000000000000000003761374004044700216760ustar00rootroot00000000000000// housekeeping/Spiciness.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public enum Spiciness { NOT, MILD, MEDIUM, HOT, FLAMING } OnJava8-Examples-1.0/housekeeping/Spoon.java000066400000000000000000000003771374004044700210350ustar00rootroot00000000000000// housekeeping/Spoon.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Spoon { static int i; static { i = 47; } } OnJava8-Examples-1.0/housekeeping/StaticInitialization.java000066400000000000000000000027021374004044700240700ustar00rootroot00000000000000// housekeeping/StaticInitialization.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Specifying initial values in a class definition class Bowl { Bowl(int marker) { System.out.println("Bowl(" + marker + ")"); } void f1(int marker) { System.out.println("f1(" + marker + ")"); } } class Table { static Bowl bowl1 = new Bowl(1); Table() { System.out.println("Table()"); bowl2.f1(1); } void f2(int marker) { System.out.println("f2(" + marker + ")"); } static Bowl bowl2 = new Bowl(2); } class Cupboard { Bowl bowl3 = new Bowl(3); static Bowl bowl4 = new Bowl(4); Cupboard() { System.out.println("Cupboard()"); bowl4.f1(2); } void f3(int marker) { System.out.println("f3(" + marker + ")"); } static Bowl bowl5 = new Bowl(5); } public class StaticInitialization { public static void main(String[] args) { System.out.println("main creating new Cupboard()"); new Cupboard(); System.out.println("main creating new Cupboard()"); new Cupboard(); table.f2(1); cupboard.f3(1); } static Table table = new Table(); static Cupboard cupboard = new Cupboard(); } /* Output: Bowl(1) Bowl(2) Table() f1(1) Bowl(4) Bowl(5) Bowl(3) Cupboard() f1(2) main creating new Cupboard() Bowl(3) Cupboard() f1(2) main creating new Cupboard() Bowl(3) Cupboard() f1(2) f2(1) f3(1) */ OnJava8-Examples-1.0/housekeeping/TerminationCondition.java000066400000000000000000000020371374004044700240720ustar00rootroot00000000000000// housekeeping/TerminationCondition.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using finalize() to detect an object that // hasn't been properly cleaned up import onjava.*; class Book { boolean checkedOut = false; Book(boolean checkOut) { checkedOut = checkOut; } void checkIn() { checkedOut = false; } @SuppressWarnings("deprecation") @Override public void finalize() { if(checkedOut) System.out.println("Error: checked out"); // Normally, you'll also do this: // super.finalize(); // Call the base-class version } } public class TerminationCondition { public static void main(String[] args) { Book novel = new Book(true); // Proper cleanup: novel.checkIn(); // Drop the reference, forget to clean up: new Book(true); // Force garbage collection & finalization: System.gc(); new Nap(1); // One second delay } } /* Output: Error: checked out */ OnJava8-Examples-1.0/housekeeping/VarArgs.java000066400000000000000000000013121374004044700212720ustar00rootroot00000000000000// housekeeping/VarArgs.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using array syntax to create variable argument lists class A {} public class VarArgs { static void printArray(Object[] args) { for(Object obj : args) System.out.print(obj + " "); System.out.println(); } public static void main(String[] args) { printArray(new Object[]{ 47, (float) 3.14, 11.11}); printArray(new Object[]{"one", "two", "three" }); printArray(new Object[]{new A(), new A(), new A()}); } } /* Output: 47 3.14 11.11 one two three A@15db9742 A@6d06d69c A@7852e922 */ OnJava8-Examples-1.0/housekeeping/VarargType.java000066400000000000000000000014031374004044700220120ustar00rootroot00000000000000// housekeeping/VarargType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class VarargType { static void f(Character... args) { System.out.print(args.getClass()); System.out.println(" length " + args.length); } static void g(int... args) { System.out.print(args.getClass()); System.out.println(" length " + args.length); } public static void main(String[] args) { f('a'); f(); g(1); g(); System.out.println("int[]: " + new int[0].getClass()); } } /* Output: class [Ljava.lang.Character; length 1 class [Ljava.lang.Character; length 0 class [I length 1 class [I length 0 int[]: class [I */ OnJava8-Examples-1.0/innerclasses/000077500000000000000000000000001374004044700170705ustar00rootroot00000000000000OnJava8-Examples-1.0/innerclasses/AnonymousConstructor.java000066400000000000000000000015071374004044700241740ustar00rootroot00000000000000// innerclasses/AnonymousConstructor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating a constructor for an anonymous inner class abstract class Base { Base(int i) { System.out.println("Base constructor, i = " + i); } public abstract void f(); } public class AnonymousConstructor { public static Base getBase(int i) { return new Base(i) { { System.out.println( "Inside instance initializer"); } @Override public void f() { System.out.println("In anonymous f()"); } }; } public static void main(String[] args) { Base base = getBase(47); base.f(); } } /* Output: Base constructor, i = 47 Inside instance initializer In anonymous f() */ OnJava8-Examples-1.0/innerclasses/BigEgg.java000066400000000000000000000012421374004044700210560ustar00rootroot00000000000000// innerclasses/BigEgg.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An inner class cannot be overridden like a method class Egg { private Yolk y; protected class Yolk { public Yolk() { System.out.println("Egg.Yolk()"); } } Egg() { System.out.println("New Egg()"); y = new Yolk(); } } public class BigEgg extends Egg { public class Yolk { public Yolk() { System.out.println("BigEgg.Yolk()"); } } public static void main(String[] args) { new BigEgg(); } } /* Output: New Egg() Egg.Yolk() */ OnJava8-Examples-1.0/innerclasses/BigEgg2.java000066400000000000000000000020001374004044700211310ustar00rootroot00000000000000// innerclasses/BigEgg2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Proper inheritance of an inner class class Egg2 { protected class Yolk { public Yolk() { System.out.println("Egg2.Yolk()"); } public void f() { System.out.println("Egg2.Yolk.f()"); } } private Yolk y = new Yolk(); Egg2() { System.out.println("New Egg2()"); } public void insertYolk(Yolk yy) { y = yy; } public void g() { y.f(); } } public class BigEgg2 extends Egg2 { public class Yolk extends Egg2.Yolk { public Yolk() { System.out.println("BigEgg2.Yolk()"); } @Override public void f() { System.out.println("BigEgg2.Yolk.f()"); } } public BigEgg2() { insertYolk(new Yolk()); } public static void main(String[] args) { Egg2 e2 = new BigEgg2(); e2.g(); } } /* Output: Egg2.Yolk() New Egg2() Egg2.Yolk() BigEgg2.Yolk() BigEgg2.Yolk.f() */ OnJava8-Examples-1.0/innerclasses/Callbacks.java000066400000000000000000000034251374004044700216160ustar00rootroot00000000000000// innerclasses/Callbacks.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using inner classes for callbacks // {java innerclasses.Callbacks} package innerclasses; interface Incrementable { void increment(); } // Very simple to just implement the interface: class Callee1 implements Incrementable { private int i = 0; @Override public void increment() { i++; System.out.println(i); } } class MyIncrement { public void increment() { System.out.println("Other operation"); } static void f(MyIncrement mi) { mi.increment(); } } // If your class must implement increment() in // some other way, you must use an inner class: class Callee2 extends MyIncrement { private int i = 0; @Override public void increment() { super.increment(); i++; System.out.println(i); } private class Closure implements Incrementable { @Override public void increment() { // Specify outer-class method, otherwise // you'll get an infinite recursion: Callee2.this.increment(); } } Incrementable getCallbackReference() { return new Closure(); } } class Caller { private Incrementable callbackReference; Caller(Incrementable cbh) { callbackReference = cbh; } void go() { callbackReference.increment(); } } public class Callbacks { public static void main(String[] args) { Callee1 c1 = new Callee1(); Callee2 c2 = new Callee2(); MyIncrement.f(c2); Caller caller1 = new Caller(c1); Caller caller2 = new Caller(c2.getCallbackReference()); caller1.go(); caller1.go(); caller2.go(); caller2.go(); } } /* Output: Other operation 1 1 2 Other operation 2 Other operation 3 */ OnJava8-Examples-1.0/innerclasses/ClassInInterface.java000066400000000000000000000010021374004044700231010ustar00rootroot00000000000000// innerclasses/ClassInInterface.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java ClassInInterface$Test} public interface ClassInInterface { void howdy(); class Test implements ClassInInterface { @Override public void howdy() { System.out.println("Howdy!"); } public static void main(String[] args) { new Test().howdy(); } } } /* Output: Howdy! */ OnJava8-Examples-1.0/innerclasses/Contents.java000066400000000000000000000003551374004044700215330ustar00rootroot00000000000000// innerclasses/Contents.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public interface Contents { int value(); } OnJava8-Examples-1.0/innerclasses/Destination.java000066400000000000000000000003721374004044700222160ustar00rootroot00000000000000// innerclasses/Destination.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public interface Destination { String readLabel(); } OnJava8-Examples-1.0/innerclasses/DotNew.java000066400000000000000000000006311374004044700211330ustar00rootroot00000000000000// innerclasses/DotNew.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating an inner class directly using .new syntax public class DotNew { public class Inner {} public static void main(String[] args) { DotNew dn = new DotNew(); DotNew.Inner dni = dn.new Inner(); } } OnJava8-Examples-1.0/innerclasses/DotThis.java000066400000000000000000000012111374004044700213040ustar00rootroot00000000000000// innerclasses/DotThis.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Accessing the outer-class object public class DotThis { void f() { System.out.println("DotThis.f()"); } public class Inner { public DotThis outer() { return DotThis.this; // A plain "this" would be Inner's "this" } } public Inner inner() { return new Inner(); } public static void main(String[] args) { DotThis dt = new DotThis(); DotThis.Inner dti = dt.inner(); dti.outer().f(); } } /* Output: DotThis.f() */ OnJava8-Examples-1.0/innerclasses/GreenhouseController.java000066400000000000000000000024721374004044700241100ustar00rootroot00000000000000// innerclasses/GreenhouseController.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Configure and execute the greenhouse system import innerclasses.controller.*; public class GreenhouseController { public static void main(String[] args) { GreenhouseControls gc = new GreenhouseControls(); // Instead of using code, you could parse // configuration information from a text file: gc.addEvent(gc.new Bell(900)); Event[] eventList = { gc.new ThermostatNight(0), gc.new LightOn(200), gc.new LightOff(400), gc.new WaterOn(600), gc.new WaterOff(800), gc.new ThermostatDay(1400) }; gc.addEvent(gc.new Restart(2000, eventList)); gc.addEvent( new GreenhouseControls.Terminate(5000)); gc.run(); } } /* Output: Thermostat on night setting Light is on Light is off Greenhouse water is on Greenhouse water is off Bing! Thermostat on day setting Bing! Restarting system Thermostat on night setting Light is on Light is off Greenhouse water is on Bing! Greenhouse water is off Thermostat on day setting Bing! Restarting system Thermostat on night setting Light is on Light is off Bing! Greenhouse water is on Greenhouse water is off Terminating */ OnJava8-Examples-1.0/innerclasses/GreenhouseControls.java000066400000000000000000000071711374004044700235710ustar00rootroot00000000000000// innerclasses/GreenhouseControls.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // This produces a specific application of the // control system, all in a single class. Inner // classes allow you to encapsulate different // functionality for each type of event. import innerclasses.controller.*; public class GreenhouseControls extends Controller { private boolean light = false; public class LightOn extends Event { public LightOn(long delayTime) { super(delayTime); } @Override public void action() { // Put hardware control code here to // physically turn on the light. light = true; } @Override public String toString() { return "Light is on"; } } public class LightOff extends Event { public LightOff(long delayTime) { super(delayTime); } @Override public void action() { // Put hardware control code here to // physically turn off the light. light = false; } @Override public String toString() { return "Light is off"; } } private boolean water = false; public class WaterOn extends Event { public WaterOn(long delayTime) { super(delayTime); } @Override public void action() { // Put hardware control code here. water = true; } @Override public String toString() { return "Greenhouse water is on"; } } public class WaterOff extends Event { public WaterOff(long delayTime) { super(delayTime); } @Override public void action() { // Put hardware control code here. water = false; } @Override public String toString() { return "Greenhouse water is off"; } } private String thermostat = "Day"; public class ThermostatNight extends Event { public ThermostatNight(long delayTime) { super(delayTime); } @Override public void action() { // Put hardware control code here. thermostat = "Night"; } @Override public String toString() { return "Thermostat on night setting"; } } public class ThermostatDay extends Event { public ThermostatDay(long delayTime) { super(delayTime); } @Override public void action() { // Put hardware control code here. thermostat = "Day"; } @Override public String toString() { return "Thermostat on day setting"; } } // An example of an action() that inserts a // new one of itself into the event list: public class Bell extends Event { public Bell(long delayTime) { super(delayTime); } @Override public void action() { addEvent(new Bell(delayTime.toMillis())); } @Override public String toString() { return "Bing!"; } } public class Restart extends Event { private Event[] eventList; public Restart(long delayTime, Event[] eventList) { super(delayTime); this.eventList = eventList; for(Event e : eventList) addEvent(e); } @Override public void action() { for(Event e : eventList) { e.start(); // Rerun each event addEvent(e); } start(); // Rerun this Event addEvent(this); } @Override public String toString() { return "Restarting system"; } } public static class Terminate extends Event { public Terminate(long delayTime) { super(delayTime); } @Override public void action() { System.exit(0); } @Override public String toString() { return "Terminating"; } } } OnJava8-Examples-1.0/innerclasses/InheritInner.java000066400000000000000000000010311374004044700223240ustar00rootroot00000000000000// innerclasses/InheritInner.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Inheriting an inner class class WithInner { class Inner {} } public class InheritInner extends WithInner.Inner { //- InheritInner() {} // Won't compile InheritInner(WithInner wi) { wi.super(); } public static void main(String[] args) { WithInner wi = new WithInner(); InheritInner ii = new InheritInner(wi); } } OnJava8-Examples-1.0/innerclasses/LocalInnerClass.java000066400000000000000000000032311374004044700227460ustar00rootroot00000000000000// innerclasses/LocalInnerClass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Holds a sequence of Objects interface Counter { int next(); } public class LocalInnerClass { private int count = 0; Counter getCounter(final String name) { // A local inner class: class LocalCounter implements Counter { LocalCounter() { // Local inner class can have a constructor System.out.println("LocalCounter()"); } @Override public int next() { System.out.print(name); // Access local final return count++; } } return new LocalCounter(); } // Repeat, but with an anonymous inner class: Counter getCounter2(final String name) { return new Counter() { // Anonymous inner class cannot have a named // constructor, only an instance initializer: { System.out.println("Counter()"); } @Override public int next() { System.out.print(name); // Access local final return count++; } }; } public static void main(String[] args) { LocalInnerClass lic = new LocalInnerClass(); Counter c1 = lic.getCounter("Local inner "), c2 = lic.getCounter2("Anonymous inner "); for(int i = 0; i < 5; i++) System.out.println(c1.next()); for(int i = 0; i < 5; i++) System.out.println(c2.next()); } } /* Output: LocalCounter() Counter() Local inner 0 Local inner 1 Local inner 2 Local inner 3 Local inner 4 Anonymous inner 5 Anonymous inner 6 Anonymous inner 7 Anonymous inner 8 Anonymous inner 9 */ OnJava8-Examples-1.0/innerclasses/MultiImplementation.java000066400000000000000000000012221374004044700237300ustar00rootroot00000000000000// innerclasses/MultiImplementation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // For concrete or abstract classes, inner classes // produce "multiple implementation inheritance" // {java innerclasses.MultiImplementation} package innerclasses; class D {} abstract class E {} class Z extends D { E makeE() { return new E() {}; } } public class MultiImplementation { static void takesD(D d) {} static void takesE(E e) {} public static void main(String[] args) { Z z = new Z(); takesD(z); takesE(z.makeE()); } } OnJava8-Examples-1.0/innerclasses/MultiNestingAccess.java000066400000000000000000000012011374004044700234710ustar00rootroot00000000000000// innerclasses/MultiNestingAccess.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Nested classes can access all members of all // levels of the classes they are nested within class MNA { private void f() {} class A { private void g() {} public class B { void h() { g(); f(); } } } } public class MultiNestingAccess { public static void main(String[] args) { MNA mna = new MNA(); MNA.A mnaa = mna.new A(); MNA.A.B mnaab = mnaa.new B(); mnaab.h(); } } OnJava8-Examples-1.0/innerclasses/Parcel1.java000066400000000000000000000015161374004044700212250ustar00rootroot00000000000000// innerclasses/Parcel1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating inner classes public class Parcel1 { class Contents { private int i = 11; public int value() { return i; } } class Destination { private String label; Destination(String whereTo) { label = whereTo; } String readLabel() { return label; } } // Using inner classes looks just like // using any other class, within Parcel1: public void ship(String dest) { Contents c = new Contents(); Destination d = new Destination(dest); System.out.println(d.readLabel()); } public static void main(String[] args) { Parcel1 p = new Parcel1(); p.ship("Tasmania"); } } /* Output: Tasmania */ OnJava8-Examples-1.0/innerclasses/Parcel10.java000066400000000000000000000015641374004044700213100ustar00rootroot00000000000000// innerclasses/Parcel10.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using "instance initialization" to perform // construction on an anonymous inner class public class Parcel10 { public Destination destination(final String dest, final float price) { return new Destination() { private int cost; // Instance initialization for each object: { cost = Math.round(price); if(cost > 100) System.out.println("Over budget!"); } private String label = dest; @Override public String readLabel() { return label; } }; } public static void main(String[] args) { Parcel10 p = new Parcel10(); Destination d = p.destination("Tasmania", 101.395F); } } /* Output: Over budget! */ OnJava8-Examples-1.0/innerclasses/Parcel11.java000066400000000000000000000021641374004044700213060ustar00rootroot00000000000000// innerclasses/Parcel11.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Nested classes (static inner classes) public class Parcel11 { private static class ParcelContents implements Contents { private int i = 11; @Override public int value() { return i; } } protected static final class ParcelDestination implements Destination { private String label; private ParcelDestination(String whereTo) { label = whereTo; } @Override public String readLabel() { return label; } // Nested classes can contain other static elements: public static void f() {} static int x = 10; static class AnotherLevel { public static void f() {} static int x = 10; } } public static Destination destination(String s) { return new ParcelDestination(s); } public static Contents contents() { return new ParcelContents(); } public static void main(String[] args) { Contents c = contents(); Destination d = destination("Tasmania"); } } OnJava8-Examples-1.0/innerclasses/Parcel2.java000066400000000000000000000020351374004044700212230ustar00rootroot00000000000000// innerclasses/Parcel2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Returning a reference to an inner class public class Parcel2 { class Contents { private int i = 11; public int value() { return i; } } class Destination { private String label; Destination(String whereTo) { label = whereTo; } String readLabel() { return label; } } public Destination to(String s) { return new Destination(s); } public Contents contents() { return new Contents(); } public void ship(String dest) { Contents c = contents(); Destination d = to(dest); System.out.println(d.readLabel()); } public static void main(String[] args) { Parcel2 p = new Parcel2(); p.ship("Tasmania"); Parcel2 q = new Parcel2(); // Defining references to inner classes: Parcel2.Contents c = q.contents(); Parcel2.Destination d = q.to("Borneo"); } } /* Output: Tasmania */ OnJava8-Examples-1.0/innerclasses/Parcel3.java000066400000000000000000000014051374004044700212240ustar00rootroot00000000000000// innerclasses/Parcel3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using .new to create instances of inner classes public class Parcel3 { class Contents { private int i = 11; public int value() { return i; } } class Destination { private String label; Destination(String whereTo) { label = whereTo; } String readLabel() { return label; } } public static void main(String[] args) { Parcel3 p = new Parcel3(); // Must use instance of outer class // to create an instance of the inner class: Parcel3.Contents c = p.new Contents(); Parcel3.Destination d = p.new Destination("Tasmania"); } } OnJava8-Examples-1.0/innerclasses/Parcel5.java000066400000000000000000000012621374004044700212270ustar00rootroot00000000000000// innerclasses/Parcel5.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Nesting a class within a method public class Parcel5 { public Destination destination(String s) { final class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; } @Override public String readLabel() { return label; } } return new PDestination(s); } public static void main(String[] args) { Parcel5 p = new Parcel5(); Destination d = p.destination("Tasmania"); } } OnJava8-Examples-1.0/innerclasses/Parcel6.java000066400000000000000000000014321374004044700212270ustar00rootroot00000000000000// innerclasses/Parcel6.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Nesting a class within a scope public class Parcel6 { private void internalTracking(boolean b) { if(b) { class TrackingSlip { private String id; TrackingSlip(String s) { id = s; } String getSlip() { return id; } } TrackingSlip ts = new TrackingSlip("slip"); String s = ts.getSlip(); } // Can't use it here! Out of scope: //- TrackingSlip ts = new TrackingSlip("x"); } public void track() { internalTracking(true); } public static void main(String[] args) { Parcel6 p = new Parcel6(); p.track(); } } OnJava8-Examples-1.0/innerclasses/Parcel7.java000066400000000000000000000011031374004044700212230ustar00rootroot00000000000000// innerclasses/Parcel7.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Returning an instance of an anonymous inner class public class Parcel7 { public Contents contents() { return new Contents() { // Insert class definition private int i = 11; @Override public int value() { return i; } }; // Semicolon required } public static void main(String[] args) { Parcel7 p = new Parcel7(); Contents c = p.contents(); } } OnJava8-Examples-1.0/innerclasses/Parcel7b.java000066400000000000000000000010461374004044700213730ustar00rootroot00000000000000// innerclasses/Parcel7b.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Expanded version of Parcel7.java public class Parcel7b { class MyContents implements Contents { private int i = 11; @Override public int value() { return i; } } public Contents contents() { return new MyContents(); } public static void main(String[] args) { Parcel7b p = new Parcel7b(); Contents c = p.contents(); } } OnJava8-Examples-1.0/innerclasses/Parcel8.java000066400000000000000000000010741374004044700212330ustar00rootroot00000000000000// innerclasses/Parcel8.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Calling the base-class constructor public class Parcel8 { public Wrapping wrapping(int x) { // Base constructor call: return new Wrapping(x) { // [1] @Override public int value() { return super.value() * 47; } }; // [2] } public static void main(String[] args) { Parcel8 p = new Parcel8(); Wrapping w = p.wrapping(10); } } OnJava8-Examples-1.0/innerclasses/Parcel9.java000066400000000000000000000011741374004044700212350ustar00rootroot00000000000000// innerclasses/Parcel9.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Parcel9 { // Argument must be final or "effectively final" // to use within the anonymous inner class: public Destination destination(final String dest) { return new Destination() { private String label = dest; @Override public String readLabel() { return label; } }; } public static void main(String[] args) { Parcel9 p = new Parcel9(); Destination d = p.destination("Tasmania"); } } OnJava8-Examples-1.0/innerclasses/Sequence.java000066400000000000000000000023131374004044700215020ustar00rootroot00000000000000// innerclasses/Sequence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Holds a sequence of Objects interface Selector { boolean end(); Object current(); void next(); } public class Sequence { private Object[] items; private int next = 0; public Sequence(int size) { items = new Object[size]; } public void add(Object x) { if(next < items.length) items[next++] = x; } private class SequenceSelector implements Selector { private int i = 0; @Override public boolean end() { return i == items.length; } @Override public Object current() { return items[i]; } @Override public void next() { if(i < items.length) i++; } } public Selector selector() { return new SequenceSelector(); } public static void main(String[] args) { Sequence sequence = new Sequence(10); for(int i = 0; i < 10; i++) sequence.add(Integer.toString(i)); Selector selector = sequence.selector(); while(!selector.end()) { System.out.print(selector.current() + " "); selector.next(); } } } /* Output: 0 1 2 3 4 5 6 7 8 9 */ OnJava8-Examples-1.0/innerclasses/TestBed.java000066400000000000000000000007401374004044700212660ustar00rootroot00000000000000// innerclasses/TestBed.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Putting test code in a nested class // {java TestBed$Tester} public class TestBed { public void f() { System.out.println("f()"); } public static class Tester { public static void main(String[] args) { TestBed t = new TestBed(); t.f(); } } } /* Output: f() */ OnJava8-Examples-1.0/innerclasses/TestParcel.java000066400000000000000000000017411374004044700220040ustar00rootroot00000000000000// innerclasses/TestParcel.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Parcel4 { private class PContents implements Contents { private int i = 11; @Override public int value() { return i; } } protected final class PDestination implements Destination { private String label; private PDestination(String whereTo) { label = whereTo; } @Override public String readLabel() { return label; } } public Destination destination(String s) { return new PDestination(s); } public Contents contents() { return new PContents(); } } public class TestParcel { public static void main(String[] args) { Parcel4 p = new Parcel4(); Contents c = p.contents(); Destination d = p.destination("Tasmania"); // Illegal -- can't access private class: //- Parcel4.PContents pc = p.new PContents(); } } OnJava8-Examples-1.0/innerclasses/Wrapping.java000066400000000000000000000004621374004044700215240ustar00rootroot00000000000000// innerclasses/Wrapping.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Wrapping { private int i; public Wrapping(int x) { i = x; } public int value() { return i; } } OnJava8-Examples-1.0/innerclasses/controller/000077500000000000000000000000001374004044700212535ustar00rootroot00000000000000OnJava8-Examples-1.0/innerclasses/controller/Controller.java000066400000000000000000000014671374004044700242510ustar00rootroot00000000000000// innerclasses/controller/Controller.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The reusable framework for control systems package innerclasses.controller; import java.util.*; public class Controller { // A class from java.util to hold Event objects: private List eventList = new ArrayList<>(); public void addEvent(Event c) { eventList.add(c); } public void run() { while(eventList.size() > 0) // Make a copy so you're not modifying the list // while you're selecting the elements in it: for(Event e : new ArrayList<>(eventList)) if(e.ready()) { System.out.println(e); e.action(); eventList.remove(e); } } } OnJava8-Examples-1.0/innerclasses/controller/Event.java000066400000000000000000000013371374004044700232030ustar00rootroot00000000000000// innerclasses/controller/Event.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The common methods for any control event package innerclasses.controller; import java.time.*; // Java 8 time classes public abstract class Event { private Instant eventTime; protected final Duration delayTime; public Event(long millisecondDelay) { delayTime = Duration.ofMillis(millisecondDelay); start(); } public void start() { // Allows restarting eventTime = Instant.now().plus(delayTime); } public boolean ready() { return Instant.now().isAfter(eventTime); } public abstract void action(); } OnJava8-Examples-1.0/innerclasses/mui/000077500000000000000000000000001374004044700176625ustar00rootroot00000000000000OnJava8-Examples-1.0/innerclasses/mui/MultiInterfaces.java000066400000000000000000000013271374004044700236260ustar00rootroot00000000000000// innerclasses/mui/MultiInterfaces.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Two ways a class can implement multiple interfaces // {java innerclasses.mui.MultiInterfaces} package innerclasses.mui; interface A {} interface B {} class X implements A, B {} class Y implements A { B makeB() { // Anonymous inner class: return new B() {}; } } public class MultiInterfaces { static void takesA(A a) {} static void takesB(B b) {} public static void main(String[] args) { X x = new X(); Y y = new Y(); takesA(x); takesA(y); takesB(x); takesB(y.makeB()); } } OnJava8-Examples-1.0/interfaces/000077500000000000000000000000001374004044700165225ustar00rootroot00000000000000OnJava8-Examples-1.0/interfaces/AbstractAccess.java000066400000000000000000000006771374004044700222640ustar00rootroot00000000000000// interfaces/AbstractAccess.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. abstract class AbstractAccess { private void m1() {} // private abstract void m1a(); // illegal protected void m2() {} protected abstract void m2a(); void m3() {} abstract void m3a(); public void m4() {} public abstract void m4a(); } OnJava8-Examples-1.0/interfaces/AbstractWithoutAbstracts.java000066400000000000000000000006351374004044700243670ustar00rootroot00000000000000// interfaces/AbstractWithoutAbstracts.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. abstract class Basic3 { int f() { return 111; } // No abstract methods } public class AbstractWithoutAbstracts { // Basic3 b3 = new Basic3(); // error: Basic3 is abstract; cannot be instantiated } OnJava8-Examples-1.0/interfaces/AdaptedRandomDoubles.java000066400000000000000000000017151374004044700234120ustar00rootroot00000000000000// interfaces/AdaptedRandomDoubles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating an adapter with inheritance import java.nio.*; import java.util.*; public class AdaptedRandomDoubles implements RandomDoubles, Readable { private int count; public AdaptedRandomDoubles(int count) { this.count = count; } @Override public int read(CharBuffer cb) { if(count-- == 0) return -1; String result = Double.toString(next()) + " "; cb.append(result); return result.length(); } public static void main(String[] args) { Scanner s = new Scanner(new AdaptedRandomDoubles(7)); while(s.hasNextDouble()) System.out.print(s.nextDouble() + " "); } } /* Output: 0.7271157860730044 0.5309454508634242 0.16020656493302599 0.18847866977771732 0.5166020801268457 0.2678662084200585 0.2613610344283964 */ OnJava8-Examples-1.0/interfaces/Adventure.java000066400000000000000000000016761374004044700213340ustar00rootroot00000000000000// interfaces/Adventure.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Multiple interfaces interface CanFight { void fight(); } interface CanSwim { void swim(); } interface CanFly { void fly(); } class ActionCharacter { public void fight() {} } class Hero extends ActionCharacter implements CanFight, CanSwim, CanFly { public void swim() {} public void fly() {} } public class Adventure { public static void t(CanFight x) { x.fight(); } public static void u(CanSwim x) { x.swim(); } public static void v(CanFly x) { x.fly(); } public static void w(ActionCharacter x) { x.fight(); } public static void main(String[] args) { Hero h = new Hero(); t(h); // Treat it as a CanFight u(h); // Treat it as a CanSwim v(h); // Treat it as a CanFly w(h); // Treat it as an ActionCharacter } } OnJava8-Examples-1.0/interfaces/AnImplementation.java000066400000000000000000000011011374004044700226220ustar00rootroot00000000000000// interfaces/AnImplementation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class AnImplementation implements AnInterface { public void firstMethod() { System.out.println("firstMethod"); } public void secondMethod() { System.out.println("secondMethod"); } public static void main(String[] args) { AnInterface i = new AnImplementation(); i.firstMethod(); i.secondMethod(); } } /* Output: firstMethod secondMethod */ OnJava8-Examples-1.0/interfaces/AnInterface.java000066400000000000000000000004111374004044700215400ustar00rootroot00000000000000// interfaces/AnInterface.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface AnInterface { void firstMethod(); void secondMethod(); } OnJava8-Examples-1.0/interfaces/Applicator.java000066400000000000000000000026431374004044700214700ustar00rootroot00000000000000// interfaces/Applicator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class Processor { public String name() { return getClass().getSimpleName(); } public Object process(Object input) { return input; } } class Upcase extends Processor { @Override // Covariant return: public String process(Object input) { return ((String)input).toUpperCase(); } } class Downcase extends Processor { @Override public String process(Object input) { return ((String)input).toLowerCase(); } } class Splitter extends Processor { @Override public String process(Object input) { // split() divides a String into pieces: return Arrays.toString(((String)input).split(" ")); } } public class Applicator { public static void apply(Processor p, Object s) { System.out.println("Using Processor " + p.name()); System.out.println(p.process(s)); } public static void main(String[] args) { String s = "We are such stuff as dreams are made on"; apply(new Upcase(), s); apply(new Downcase(), s); apply(new Splitter(), s); } } /* Output: Using Processor Upcase WE ARE SUCH STUFF AS DREAMS ARE MADE ON Using Processor Downcase we are such stuff as dreams are made on Using Processor Splitter [We, are, such, stuff, as, dreams, are, made, on] */ OnJava8-Examples-1.0/interfaces/AttemptToUseBasic.java000066400000000000000000000005161374004044700227270ustar00rootroot00000000000000// interfaces/AttemptToUseBasic.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} public class AttemptToUseBasic { Basic b = new Basic(); // error: Basic is abstract; cannot be instantiated } OnJava8-Examples-1.0/interfaces/Basic.java000066400000000000000000000003661374004044700204130ustar00rootroot00000000000000// interfaces/Basic.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. abstract class Basic { abstract void unimplemented(); } OnJava8-Examples-1.0/interfaces/Basic2.java000066400000000000000000000004771374004044700205000ustar00rootroot00000000000000// interfaces/Basic2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. abstract class Basic2 extends Basic { int f() { return 111; } abstract void g(); // unimplemented() still not implemented } OnJava8-Examples-1.0/interfaces/Factories.java000066400000000000000000000026261374004044700213120ustar00rootroot00000000000000// interfaces/Factories.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface Service { void method1(); void method2(); } interface ServiceFactory { Service getService(); } class Service1 implements Service { Service1() {} // Package access public void method1() { System.out.println("Service1 method1"); } public void method2() { System.out.println("Service1 method2"); } } class Service1Factory implements ServiceFactory { @Override public Service getService() { return new Service1(); } } class Service2 implements Service { Service2() {} // Package access public void method1() { System.out.println("Service2 method1"); } public void method2() { System.out.println("Service2 method2"); } } class Service2Factory implements ServiceFactory { @Override public Service getService() { return new Service2(); } } public class Factories { public static void serviceConsumer(ServiceFactory fact) { Service s = fact.getService(); s.method1(); s.method2(); } public static void main(String[] args) { serviceConsumer(new Service1Factory()); // Services are completely interchangeable: serviceConsumer(new Service2Factory()); } } /* Output: Service1 method1 Service1 method2 Service2 method1 Service2 method2 */ OnJava8-Examples-1.0/interfaces/Games.java000066400000000000000000000024661374004044700204310ustar00rootroot00000000000000// interfaces/Games.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A Game framework using Factory Methods interface Game { boolean move(); } interface GameFactory { Game getGame(); } class Checkers implements Game { private int moves = 0; private static final int MOVES = 3; @Override public boolean move() { System.out.println("Checkers move " + moves); return ++moves != MOVES; } } class CheckersFactory implements GameFactory { @Override public Game getGame() { return new Checkers(); } } class Chess implements Game { private int moves = 0; private static final int MOVES = 4; @Override public boolean move() { System.out.println("Chess move " + moves); return ++moves != MOVES; } } class ChessFactory implements GameFactory { @Override public Game getGame() { return new Chess(); } } public class Games { public static void playGame(GameFactory factory) { Game s = factory.getGame(); while(s.move()) ; } public static void main(String[] args) { playGame(new CheckersFactory()); playGame(new ChessFactory()); } } /* Output: Checkers move 0 Checkers move 1 Checkers move 2 Chess move 0 Chess move 1 Chess move 2 Chess move 3 */ OnJava8-Examples-1.0/interfaces/HorrorShow.java000066400000000000000000000022301374004044700214760ustar00rootroot00000000000000// interfaces/HorrorShow.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Extending an interface with inheritance interface Monster { void menace(); } interface DangerousMonster extends Monster { void destroy(); } interface Lethal { void kill(); } class DragonZilla implements DangerousMonster { @Override public void menace() {} @Override public void destroy() {} } interface Vampire extends DangerousMonster, Lethal { void drinkBlood(); } class VeryBadVampire implements Vampire { @Override public void menace() {} @Override public void destroy() {} @Override public void kill() {} @Override public void drinkBlood() {} } public class HorrorShow { static void u(Monster b) { b.menace(); } static void v(DangerousMonster d) { d.menace(); d.destroy(); } static void w(Lethal l) { l.kill(); } public static void main(String[] args) { DangerousMonster barney = new DragonZilla(); u(barney); v(barney); Vampire vlad = new VeryBadVampire(); u(vlad); v(vlad); w(vlad); } } OnJava8-Examples-1.0/interfaces/Implementation2.java000066400000000000000000000011631374004044700224350ustar00rootroot00000000000000// interfaces/Implementation2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Implementation2 implements InterfaceWithDefault { public void firstMethod() { System.out.println("firstMethod"); } public void secondMethod() { System.out.println("secondMethod"); } public static void main(String[] args) { InterfaceWithDefault i = new Implementation2(); i.firstMethod(); i.secondMethod(); i.newMethod(); } } /* Output: firstMethod secondMethod newMethod */ OnJava8-Examples-1.0/interfaces/ImplementingAnInterface.java000066400000000000000000000006611374004044700241200ustar00rootroot00000000000000// interfaces/ImplementingAnInterface.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface Concept { // Package access void idea1(); void idea2(); } class Implementation implements Concept { public void idea1() { System.out.println("idea1"); } public void idea2() { System.out.println("idea2"); } } OnJava8-Examples-1.0/interfaces/Instantiable.java000066400000000000000000000007721374004044700220100ustar00rootroot00000000000000// interfaces/Instantiable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. abstract class Uninstantiable { abstract void f(); abstract int g(); } public class Instantiable extends Uninstantiable { @Override void f() { System.out.println("f()"); } @Override int g() { return 22; } public static void main(String[] args) { Uninstantiable ui = new Instantiable(); } } OnJava8-Examples-1.0/interfaces/InterfaceCollision.java000066400000000000000000000014111374004044700231360ustar00rootroot00000000000000// interfaces/InterfaceCollision.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface I1 { void f(); } interface I2 { int f(int i); } interface I3 { int f(); } class C { public int f() { return 1; } } class C2 implements I1, I2 { @Override public void f() {} @Override public int f(int i) { return 1; } // overloaded } class C3 extends C implements I2 { @Override public int f(int i) { return 1; } // overloaded } class C4 extends C implements I3 { // Identical, no problem: @Override public int f() { return 1; } } // Methods differ only by return type: //- class C5 extends C implements I1 {} //- interface I4 extends I1, I3 {} OnJava8-Examples-1.0/interfaces/InterfaceWithDefault.java000066400000000000000000000005411374004044700234260ustar00rootroot00000000000000// interfaces/InterfaceWithDefault.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface InterfaceWithDefault { void firstMethod(); void secondMethod(); default void newMethod() { System.out.println("newMethod"); } } OnJava8-Examples-1.0/interfaces/Jim.java000066400000000000000000000010631374004044700201040ustar00rootroot00000000000000// interfaces/Jim.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface Jim1 { default void jim() { System.out.println("Jim1::jim"); } } interface Jim2 { default void jim() { System.out.println("Jim2::jim"); } } public class Jim implements Jim1, Jim2 { @Override public void jim() { Jim2.super.jim(); } public static void main(String[] args) { new Jim().jim(); } } /* Output: Jim2::jim */ OnJava8-Examples-1.0/interfaces/MICollision.java000066400000000000000000000022021374004044700215420ustar00rootroot00000000000000// interfaces/MICollision.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface Bob1 { default void bob() { System.out.println("Bob1::bob"); } } interface Bob2 { default void bob() { System.out.println("Bob2::bob"); } } // class Bob implements Bob1, Bob2 {} /* Produces: error: class Bob inherits unrelated defaults for bob() from types Bob1 and Bob2 class Bob implements Bob1, Bob2 {} ^ 1 error */ interface Sam1 { default void sam() { System.out.println("Sam1::sam"); } } interface Sam2 { default void sam(int i) { System.out.println(i * 2); } } // This works because the argument lists are distinct: class Sam implements Sam1, Sam2 {} interface Max1 { default void max() { System.out.println("Max1::max"); } } interface Max2 { default int max() { return 47; } } // class Max implements Max1, Max2 {} /* Produces: error: types Max2 and Max1 are incompatible; both define max(), but with unrelated return types class Max implements Max1, Max2 {} ^ 1 error */ OnJava8-Examples-1.0/interfaces/Machine.java000066400000000000000000000012761374004044700207370ustar00rootroot00000000000000// interfaces/Machine.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.Operations; class Bing implements Operations { public void execute() { Operations.show("Bing"); } } class Crack implements Operations { public void execute() { Operations.show("Crack"); } } class Twist implements Operations { public void execute() { Operations.show("Twist"); } } public class Machine { public static void main(String[] args) { Operations.runOps( new Bing(), new Crack(), new Twist()); } } /* Output: Bing Crack Twist */ OnJava8-Examples-1.0/interfaces/Months.java000066400000000000000000000006661374004044700206450ustar00rootroot00000000000000// interfaces/Months.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using interfaces to create groups of constants public interface Months { int JANUARY = 1, FEBRUARY = 2, MARCH = 3, APRIL = 4, MAY = 5, JUNE = 6, JULY = 7, AUGUST = 8, SEPTEMBER = 9, OCTOBER = 10, NOVEMBER = 11, DECEMBER = 12; } OnJava8-Examples-1.0/interfaces/MultipleInheritance.java000066400000000000000000000012551374004044700233350ustar00rootroot00000000000000// interfaces/MultipleInheritance.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; interface One { default void first() { System.out.println("first"); } } interface Two { default void second() { System.out.println("second"); } } interface Three { default void third() { System.out.println("third"); } } class MI implements One, Two, Three {} public class MultipleInheritance { public static void main(String[] args) { MI mi = new MI(); mi.first(); mi.second(); mi.third(); } } /* Output: first second third */ OnJava8-Examples-1.0/interfaces/PureInterface.java000066400000000000000000000005001374004044700221140ustar00rootroot00000000000000// interfaces/PureInterface.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Interface only looked like this before Java 8 public interface PureInterface { int m1(); void m2(); double m3(); } OnJava8-Examples-1.0/interfaces/RandVals.java000066400000000000000000000010021374004044700210700ustar00rootroot00000000000000// interfaces/RandVals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Initializing interface fields with // non-constant initializers import java.util.*; public interface RandVals { Random RAND = new Random(47); int RANDOM_INT = RAND.nextInt(10); long RANDOM_LONG = RAND.nextLong() * 10; float RANDOM_FLOAT = RAND.nextLong() * 10; double RANDOM_DOUBLE = RAND.nextDouble() * 10; } OnJava8-Examples-1.0/interfaces/RandomDoubles.java000066400000000000000000000012061374004044700221220ustar00rootroot00000000000000// interfaces/RandomDoubles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public interface RandomDoubles { Random RAND = new Random(47); default double next() { return RAND.nextDouble(); } static void main(String[] args) { RandomDoubles rd = new RandomDoubles() {}; for(int i = 0; i < 7; i ++) System.out.print(rd.next() + " "); } } /* Output: 0.7271157860730044 0.5309454508634242 0.16020656493302599 0.18847866977771732 0.5166020801268457 0.2678662084200585 0.2613610344283964 */ OnJava8-Examples-1.0/interfaces/RandomStrings.java000066400000000000000000000025321374004044700221610ustar00rootroot00000000000000// interfaces/RandomStrings.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Implementing an interface to conform to a method import java.nio.*; import java.util.*; public class RandomStrings implements Readable { private static Random rand = new Random(47); private static final char[] CAPITALS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray(); private static final char[] LOWERS = "abcdefghijklmnopqrstuvwxyz".toCharArray(); private static final char[] VOWELS = "aeiou".toCharArray(); private int count; public RandomStrings(int count) { this.count = count; } @Override public int read(CharBuffer cb) { if(count-- == 0) return -1; // Indicates end of input cb.append(CAPITALS[rand.nextInt(CAPITALS.length)]); for(int i = 0; i < 4; i++) { cb.append(VOWELS[rand.nextInt(VOWELS.length)]); cb.append(LOWERS[rand.nextInt(LOWERS.length)]); } cb.append(" "); return 10; // Number of characters appended } public static void main(String[] args) { Scanner s = new Scanner(new RandomStrings(10)); while(s.hasNext()) System.out.println(s.next()); } } /* Output: Yazeruyac Fowenucor Goeazimom Raeuuacio Nuoadesiw Hageaikux Ruqicibui Numasetih Kuuuuozog Waqizeyoy */ OnJava8-Examples-1.0/interfaces/TestRandVals.java000066400000000000000000000010151374004044700217340ustar00rootroot00000000000000// interfaces/TestRandVals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class TestRandVals { public static void main(String[] args) { System.out.println(RandVals.RANDOM_INT); System.out.println(RandVals.RANDOM_LONG); System.out.println(RandVals.RANDOM_FLOAT); System.out.println(RandVals.RANDOM_DOUBLE); } } /* Output: 8 -32032247016559954 -8.5939291E18 5.779976127815049 */ OnJava8-Examples-1.0/interfaces/filters/000077500000000000000000000000001374004044700201725ustar00rootroot00000000000000OnJava8-Examples-1.0/interfaces/filters/BandPass.java000066400000000000000000000007431374004044700225340ustar00rootroot00000000000000// interfaces/filters/BandPass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.filters; public class BandPass extends Filter { double lowCutoff, highCutoff; public BandPass(double lowCut, double highCut) { lowCutoff = lowCut; highCutoff = highCut; } @Override public Waveform process(Waveform input) { return input; } } OnJava8-Examples-1.0/interfaces/filters/Filter.java000066400000000000000000000005771374004044700222730ustar00rootroot00000000000000// interfaces/filters/Filter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.filters; public class Filter { public String name() { return getClass().getSimpleName(); } public Waveform process(Waveform input) { return input; } } OnJava8-Examples-1.0/interfaces/filters/HighPass.java000066400000000000000000000006541374004044700225500ustar00rootroot00000000000000// interfaces/filters/HighPass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.filters; public class HighPass extends Filter { double cutoff; public HighPass(double cutoff) { this.cutoff = cutoff; } @Override public Waveform process(Waveform input) { return input; } } OnJava8-Examples-1.0/interfaces/filters/LowPass.java000066400000000000000000000006751374004044700224350ustar00rootroot00000000000000// interfaces/filters/LowPass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.filters; public class LowPass extends Filter { double cutoff; public LowPass(double cutoff) { this.cutoff = cutoff; } @Override public Waveform process(Waveform input) { return input; // Dummy processing } } OnJava8-Examples-1.0/interfaces/filters/Waveform.java000066400000000000000000000006131374004044700226230ustar00rootroot00000000000000// interfaces/filters/Waveform.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.filters; public class Waveform { private static long counter; private final long id = counter++; @Override public String toString() { return "Waveform " + id; } } OnJava8-Examples-1.0/interfaces/interfaceprocessor/000077500000000000000000000000001374004044700224225ustar00rootroot00000000000000OnJava8-Examples-1.0/interfaces/interfaceprocessor/Applicator.java000066400000000000000000000006541374004044700253700ustar00rootroot00000000000000// interfaces/interfaceprocessor/Applicator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.interfaceprocessor; public class Applicator { public static void apply(Processor p, Object s) { System.out.println("Using Processor " + p.name()); System.out.println(p.process(s)); } } OnJava8-Examples-1.0/interfaces/interfaceprocessor/FilterProcessor.java000066400000000000000000000020661374004044700264160ustar00rootroot00000000000000// interfaces/interfaceprocessor/FilterProcessor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java interfaces.interfaceprocessor.FilterProcessor} package interfaces.interfaceprocessor; import interfaces.filters.*; class FilterAdapter implements Processor { Filter filter; FilterAdapter(Filter filter) { this.filter = filter; } @Override public String name() { return filter.name(); } @Override public Waveform process(Object input) { return filter.process((Waveform)input); } } public class FilterProcessor { public static void main(String[] args) { Waveform w = new Waveform(); Applicator.apply( new FilterAdapter(new LowPass(1.0)), w); Applicator.apply( new FilterAdapter(new HighPass(2.0)), w); Applicator.apply( new FilterAdapter(new BandPass(3.0, 4.0)), w); } } /* Output: Using Processor LowPass Waveform 0 Using Processor HighPass Waveform 0 Using Processor BandPass Waveform 0 */ OnJava8-Examples-1.0/interfaces/interfaceprocessor/Processor.java000066400000000000000000000005761374004044700252540ustar00rootroot00000000000000// interfaces/interfaceprocessor/Processor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package interfaces.interfaceprocessor; public interface Processor { default String name() { return getClass().getSimpleName(); } Object process(Object input); } OnJava8-Examples-1.0/interfaces/interfaceprocessor/StringProcessor.java000066400000000000000000000026041374004044700264350ustar00rootroot00000000000000// interfaces/interfaceprocessor/StringProcessor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java interfaces.interfaceprocessor.StringProcessor} package interfaces.interfaceprocessor; import java.util.*; interface StringProcessor extends Processor { @Override String process(Object input); // [1] String S = // [2] "If she weighs the same as a duck, " + "she's made of wood"; static void main(String[] args) { // [3] Applicator.apply(new Upcase(), S); Applicator.apply(new Downcase(), S); Applicator.apply(new Splitter(), S); } } class Upcase implements StringProcessor { @Override // Covariant return: public String process(Object input) { return ((String)input).toUpperCase(); } } class Downcase implements StringProcessor { @Override public String process(Object input) { return ((String)input).toLowerCase(); } } class Splitter implements StringProcessor { @Override public String process(Object input) { return Arrays.toString(((String)input).split(" ")); } } /* Output: Using Processor Upcase IF SHE WEIGHS THE SAME AS A DUCK, SHE'S MADE OF WOOD Using Processor Downcase if she weighs the same as a duck, she's made of wood Using Processor Splitter [If, she, weighs, the, same, as, a, duck,, she's, made, of, wood] */ OnJava8-Examples-1.0/interfaces/music4/000077500000000000000000000000001374004044700177265ustar00rootroot00000000000000OnJava8-Examples-1.0/interfaces/music4/Music4.java000066400000000000000000000045331374004044700217420ustar00rootroot00000000000000// interfaces/music4/Music4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Abstract classes and methods // {java interfaces.music4.Music4} package interfaces.music4; import polymorphism.music.Note; abstract class Instrument { private int i; // Storage allocated for each public abstract void play(Note n); public String what() { return "Instrument"; } public abstract void adjust(); } class Wind extends Instrument { @Override public void play(Note n) { System.out.println("Wind.play() " + n); } @Override public String what() { return "Wind"; } @Override public void adjust() { System.out.println("Adjusting Wind"); } } class Percussion extends Instrument { @Override public void play(Note n) { System.out.println("Percussion.play() " + n); } @Override public String what() { return "Percussion"; } @Override public void adjust() { System.out.println("Adjusting Percussion"); } } class Stringed extends Instrument { @Override public void play(Note n) { System.out.println("Stringed.play() " + n); } @Override public String what() { return "Stringed"; } @Override public void adjust() { System.out.println("Adjusting Stringed"); } } class Brass extends Wind { @Override public void play(Note n) { System.out.println("Brass.play() " + n); } @Override public void adjust() { System.out.println("Adjusting Brass"); } } class Woodwind extends Wind { @Override public void play(Note n) { System.out.println("Woodwind.play() " + n); } @Override public String what() { return "Woodwind"; } } public class Music4 { // Doesn't care about type, so new types // added to the system still work right: static void tune(Instrument i) { // ... i.play(Note.MIDDLE_C); } static void tuneAll(Instrument[] e) { for(Instrument i : e) tune(i); } public static void main(String[] args) { // Upcasting during addition to the array: Instrument[] orchestra = { new Wind(), new Percussion(), new Stringed(), new Brass(), new Woodwind() }; tuneAll(orchestra); } } /* Output: Wind.play() MIDDLE_C Percussion.play() MIDDLE_C Stringed.play() MIDDLE_C Brass.play() MIDDLE_C Woodwind.play() MIDDLE_C */ OnJava8-Examples-1.0/interfaces/music5/000077500000000000000000000000001374004044700177275ustar00rootroot00000000000000OnJava8-Examples-1.0/interfaces/music5/Music5.java000066400000000000000000000032661374004044700217460ustar00rootroot00000000000000// interfaces/music5/Music5.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java interfaces.music5.Music5} package interfaces.music5; import polymorphism.music.Note; interface Instrument { // Compile-time constant: int VALUE = 5; // static & final default void play(Note n) { // Automatically public System.out.println(this + ".play() " + n); } default void adjust() { System.out.println("Adjusting " + this); } } class Wind implements Instrument { @Override public String toString() { return "Wind"; } } class Percussion implements Instrument { @Override public String toString() { return "Percussion"; } } class Stringed implements Instrument { @Override public String toString() { return "Stringed"; } } class Brass extends Wind { @Override public String toString() { return "Brass"; } } class Woodwind extends Wind { @Override public String toString() { return "Woodwind"; } } public class Music5 { // Doesn't care about type, so new types // added to the system still work right: static void tune(Instrument i) { // ... i.play(Note.MIDDLE_C); } static void tuneAll(Instrument[] e) { for(Instrument i : e) tune(i); } public static void main(String[] args) { // Upcasting during addition to the array: Instrument[] orchestra = { new Wind(), new Percussion(), new Stringed(), new Brass(), new Woodwind() }; tuneAll(orchestra); } } /* Output: Wind.play() MIDDLE_C Percussion.play() MIDDLE_C Stringed.play() MIDDLE_C Brass.play() MIDDLE_C Woodwind.play() MIDDLE_C */ OnJava8-Examples-1.0/interfaces/nesting/000077500000000000000000000000001374004044700201715ustar00rootroot00000000000000OnJava8-Examples-1.0/interfaces/nesting/NestingInterfaces.java000066400000000000000000000042101374004044700244440ustar00rootroot00000000000000// interfaces/nesting/NestingInterfaces.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java interfaces.nesting.NestingInterfaces} package interfaces.nesting; class A { interface B { void f(); } public class BImp implements B { @Override public void f() {} } private class BImp2 implements B { @Override public void f() {} } public interface C { void f(); } class CImp implements C { @Override public void f() {} } private class CImp2 implements C { @Override public void f() {} } private interface D { void f(); } private class DImp implements D { @Override public void f() {} } public class DImp2 implements D { @Override public void f() {} } public D getD() { return new DImp2(); } private D dRef; public void receiveD(D d) { dRef = d; dRef.f(); } } interface E { interface G { void f(); } // Redundant "public": public interface H { void f(); } void g(); // Cannot be private within an interface: //- private interface I {} } public class NestingInterfaces { public class BImp implements A.B { @Override public void f() {} } class CImp implements A.C { @Override public void f() {} } // Cannot implement a private interface except // within that interface's defining class: //- class DImp implements A.D { //- public void f() {} //- } class EImp implements E { @Override public void g() {} } class EGImp implements E.G { @Override public void f() {} } class EImp2 implements E { @Override public void g() {} class EG implements E.G { @Override public void f() {} } } public static void main(String[] args) { A a = new A(); // Can't access A.D: //- A.D ad = a.getD(); // Doesn't return anything but A.D: //- A.DImp2 di2 = a.getD(); // Cannot access a member of the interface: //- a.getD().f(); // Only another A can do anything with getD(): A a2 = new A(); a2.receiveD(a.getD()); } } OnJava8-Examples-1.0/iostreams/000077500000000000000000000000001374004044700164055ustar00rootroot00000000000000OnJava8-Examples-1.0/iostreams/BasicFileOutput.java000066400000000000000000000014601374004044700223130ustar00rootroot00000000000000// iostreams/BasicFileOutput.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.io.*; public class BasicFileOutput { static String file = "BasicFileOutput.dat"; public static void main(String[] args) { try( BufferedReader in = new BufferedReader( new StringReader( BufferedInputFile.read( "BasicFileOutput.java"))); PrintWriter out = new PrintWriter( new BufferedWriter(new FileWriter(file))) ) { in.lines().forEach(out::println); } catch(IOException e) { throw new RuntimeException(e); } // Show the stored file: System.out.println(BufferedInputFile.read(file)); } } OnJava8-Examples-1.0/iostreams/BufferedInputFile.java000066400000000000000000000012601374004044700226110ustar00rootroot00000000000000// iostreams/BufferedInputFile.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.io.*; import java.util.stream.*; public class BufferedInputFile { public static String read(String filename) { try(BufferedReader in = new BufferedReader( new FileReader(filename))) { return in.lines() .collect(Collectors.joining("\n")); } catch(IOException e) { throw new RuntimeException(e); } } public static void main(String[] args) { System.out.print( read("BufferedInputFile.java")); } } OnJava8-Examples-1.0/iostreams/FileOutputShortcut.java000066400000000000000000000014031374004044700231020ustar00rootroot00000000000000// iostreams/FileOutputShortcut.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.io.*; public class FileOutputShortcut { static String file = "FileOutputShortcut.dat"; public static void main(String[] args) { try( BufferedReader in = new BufferedReader( new StringReader(BufferedInputFile.read( "FileOutputShortcut.java"))); // Here's the shortcut: PrintWriter out = new PrintWriter(file) ) { in.lines().forEach(out::println); } catch(IOException e) { throw new RuntimeException(e); } System.out.println(BufferedInputFile.read(file)); } } OnJava8-Examples-1.0/iostreams/FormattedMemoryInput.java000066400000000000000000000013521374004044700234070ustar00rootroot00000000000000// iostreams/FormattedMemoryInput.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.io.*; public class FormattedMemoryInput { public static void main(String[] args) { try( DataInputStream in = new DataInputStream( new ByteArrayInputStream( BufferedInputFile.read( "FormattedMemoryInput.java") .getBytes())) ) { while(true) System.out.write((char)in.readByte()); } catch(EOFException e) { System.out.println("\nEnd of stream"); } catch(IOException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/iostreams/MemoryInput.java000066400000000000000000000007671374004044700215520ustar00rootroot00000000000000// iostreams/MemoryInput.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {VisuallyInspectOutput} import java.io.*; public class MemoryInput { public static void main(String[] args) throws IOException { StringReader in = new StringReader( BufferedInputFile.read("MemoryInput.java")); int c; while((c = in.read()) != -1) System.out.print((char)c); } } OnJava8-Examples-1.0/iostreams/StoringAndRecoveringData.java000066400000000000000000000022421374004044700241360ustar00rootroot00000000000000// iostreams/StoringAndRecoveringData.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; public class StoringAndRecoveringData { public static void main(String[] args) { try( DataOutputStream out = new DataOutputStream( new BufferedOutputStream( new FileOutputStream("Data.txt"))) ) { out.writeDouble(3.14159); out.writeUTF("That was pi"); out.writeDouble(1.41413); out.writeUTF("Square root of 2"); } catch(IOException e) { throw new RuntimeException(e); } try( DataInputStream in = new DataInputStream( new BufferedInputStream( new FileInputStream("Data.txt"))) ) { System.out.println(in.readDouble()); // Only readUTF() will recover the // Java-UTF String properly: System.out.println(in.readUTF()); System.out.println(in.readDouble()); System.out.println(in.readUTF()); } catch(IOException e) { throw new RuntimeException(e); } } } /* Output: 3.14159 That was pi 1.41413 Square root of 2 */ OnJava8-Examples-1.0/iostreams/TestEOF.java000066400000000000000000000011611374004044700205200ustar00rootroot00000000000000// iostreams/TestEOF.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Testing for end of file // {VisuallyInspectOutput} import java.io.*; public class TestEOF { public static void main(String[] args) { try( DataInputStream in = new DataInputStream( new BufferedInputStream( new FileInputStream("TestEOF.java"))) ) { while(in.available() != 0) System.out.write(in.readByte()); } catch(IOException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/iostreams/UsingRandomAccessFile.java000066400000000000000000000027431374004044700234260ustar00rootroot00000000000000// iostreams/UsingRandomAccessFile.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; public class UsingRandomAccessFile { static String file = "rtest.dat"; public static void display() { try( RandomAccessFile rf = new RandomAccessFile(file, "r") ) { for(int i = 0; i < 7; i++) System.out.println( "Value " + i + ": " + rf.readDouble()); System.out.println(rf.readUTF()); } catch(IOException e) { throw new RuntimeException(e); } } public static void main(String[] args) { try( RandomAccessFile rf = new RandomAccessFile(file, "rw") ) { for(int i = 0; i < 7; i++) rf.writeDouble(i*1.414); rf.writeUTF("The end of the file"); rf.close(); display(); } catch(IOException e) { throw new RuntimeException(e); } try( RandomAccessFile rf = new RandomAccessFile(file, "rw") ) { rf.seek(5*8); rf.writeDouble(47.0001); rf.close(); display(); } catch(IOException e) { throw new RuntimeException(e); } } } /* Output: Value 0: 0.0 Value 1: 1.414 Value 2: 2.828 Value 3: 4.242 Value 4: 5.656 Value 5: 7.069999999999999 Value 6: 8.484 The end of the file Value 0: 0.0 Value 1: 1.414 Value 2: 2.828 Value 3: 4.242 Value 4: 5.656 Value 5: 47.0001 Value 6: 8.484 The end of the file */ OnJava8-Examples-1.0/javadoc/000077500000000000000000000000001374004044700160065ustar00rootroot00000000000000OnJava8-Examples-1.0/javadoc/Documentation1.java000066400000000000000000000005201374004044700215400ustar00rootroot00000000000000// javadoc/Documentation1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. /** A class comment */ public class Documentation1 { /** A field comment */ public int i; /** A method comment */ public void f() {} } OnJava8-Examples-1.0/javadoc/Documentation2.java000066400000000000000000000004331374004044700215440ustar00rootroot00000000000000// javadoc/Documentation2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. /** 

 * System.out.println(new Date());
 *
*/ public class Documentation2 {} OnJava8-Examples-1.0/javadoc/Documentation3.java000066400000000000000000000005231374004044700215450ustar00rootroot00000000000000// javadoc/Documentation3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. /** You can even insert a list: *
    *
  1. Item one *
  2. Item two *
  3. Item three *
*/ public class Documentation3 {} OnJava8-Examples-1.0/javadoc/HelloDateDoc.java000066400000000000000000000013101374004044700211330ustar00rootroot00000000000000// javadoc/HelloDateDoc.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; /** The first On Java 8 example program. * Displays a String and today's date. * @author Bruce Eckel * @author www.MindviewInc.com * @version 5.0 */ public class HelloDateDoc { /** Entry point to class & application. * @param args array of String arguments * @throws exceptions No exceptions thrown */ public static void main(String[] args) { System.out.println("Hello, it's: "); System.out.println(new Date()); } } /* Output: Hello, it's: Tue May 09 06:07:27 MDT 2017 */ OnJava8-Examples-1.0/lowlevel/000077500000000000000000000000001374004044700162305ustar00rootroot00000000000000OnJava8-Examples-1.0/lowlevel/AtomicEvenProducer.java000066400000000000000000000011711374004044700226310ustar00rootroot00000000000000// lowlevel/AtomicEvenProducer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Atomic classes: occasionally useful in regular code import java.util.concurrent.atomic.*; public class AtomicEvenProducer extends IntGenerator { private AtomicInteger currentEvenValue = new AtomicInteger(0); @Override public int next() { return currentEvenValue.addAndGet(2); } public static void main(String[] args) { EvenChecker.test(new AtomicEvenProducer()); } } /* Output: No odd numbers discovered */ OnJava8-Examples-1.0/lowlevel/AtomicIntegerTest.java000066400000000000000000000011631374004044700224660ustar00rootroot00000000000000// lowlevel/AtomicIntegerTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import java.util.concurrent.atomic.*; import java.util.*; import onjava.*; public class AtomicIntegerTest extends IntTestable { private AtomicInteger i = new AtomicInteger(0); public int getAsInt() { return i.get(); } public void evenIncrement() { i.addAndGet(2); } public static void main(String[] args) { Atomicity.test(new AtomicIntegerTest()); } } /* Output: No failures found */ OnJava8-Examples-1.0/lowlevel/AtomicSerialNumbers.java000066400000000000000000000011161374004044700230020ustar00rootroot00000000000000// lowlevel/AtomicSerialNumbers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.*; public class AtomicSerialNumbers extends SerialNumbers { private AtomicInteger serialNumber = new AtomicInteger(); public int nextSerialNumber() { return serialNumber.getAndIncrement(); } public static void main(String[] args) { SerialNumberChecker.test( new AtomicSerialNumbers()); } } /* Output: No duplicates detected */ OnJava8-Examples-1.0/lowlevel/Atomicity.java000066400000000000000000000010651374004044700210370ustar00rootroot00000000000000// lowlevel/Atomicity.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; import onjava.TimedAbort; public class Atomicity { public static void test(IntTestable it) { new TimedAbort(4, "No failures found"); CompletableFuture.runAsync(it); while(true) { int val = it.getAsInt(); if(val % 2 != 0) { System.out.println("failed with: " + val); System.exit(0); } } } } OnJava8-Examples-1.0/lowlevel/AttemptLocking.java000066400000000000000000000031471374004044700220250ustar00rootroot00000000000000// lowlevel/AttemptLocking.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Locks in the concurrent library allow you // to give up on trying to acquire a lock import java.util.concurrent.*; import java.util.concurrent.locks.*; import onjava.Nap; public class AttemptLocking { private ReentrantLock lock = new ReentrantLock(); public void untimed() { boolean captured = lock.tryLock(); try { System.out.println("tryLock(): " + captured); } finally { if(captured) lock.unlock(); } } public void timed() { boolean captured = false; try { captured = lock.tryLock(2, TimeUnit.SECONDS); } catch(InterruptedException e) { throw new RuntimeException(e); } try { System.out.println( "tryLock(2, TimeUnit.SECONDS): " + captured); } finally { if(captured) lock.unlock(); } } public static void main(String[] args) { final AttemptLocking al = new AttemptLocking(); al.untimed(); // True -- lock is available al.timed(); // True -- lock is available // Now create a second task to grab the lock: CompletableFuture.runAsync( () -> { al.lock.lock(); System.out.println("acquired"); }); new Nap(0.1); // Give the second task a chance al.untimed(); // False -- lock grabbed by task al.timed(); // False -- lock grabbed by task } } /* Output: tryLock(): true tryLock(2, TimeUnit.SECONDS): true acquired tryLock(): false tryLock(2, TimeUnit.SECONDS): false */ OnJava8-Examples-1.0/lowlevel/CaptureUncaughtException.java000066400000000000000000000030741374004044700240600ustar00rootroot00000000000000// lowlevel/CaptureUncaughtException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; class ExceptionThread2 implements Runnable { @Override public void run() { Thread t = Thread.currentThread(); System.out.println("run() by " + t.getName()); System.out.println( "eh = " + t.getUncaughtExceptionHandler()); throw new RuntimeException(); } } class MyUncaughtExceptionHandler implements Thread.UncaughtExceptionHandler { @Override public void uncaughtException(Thread t, Throwable e) { System.out.println("caught " + e); } } class HandlerThreadFactory implements ThreadFactory { @Override public Thread newThread(Runnable r) { System.out.println(this + " creating new Thread"); Thread t = new Thread(r); System.out.println("created " + t); t.setUncaughtExceptionHandler( new MyUncaughtExceptionHandler()); System.out.println( "eh = " + t.getUncaughtExceptionHandler()); return t; } } public class CaptureUncaughtException { public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool( new HandlerThreadFactory()); exec.execute(new ExceptionThread2()); exec.shutdown(); } } /* Output: HandlerThreadFactory@4e25154f creating new Thread created Thread[Thread-0,5,main] eh = MyUncaughtExceptionHandler@70dea4e run() by Thread-0 eh = MyUncaughtExceptionHandler@70dea4e caught java.lang.RuntimeException */ OnJava8-Examples-1.0/lowlevel/CircularSet.java000066400000000000000000000014701374004044700213150ustar00rootroot00000000000000// lowlevel/CircularSet.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Reuses storage so we don't run out of memory import java.util.*; public class CircularSet { private int[] array; private int size; private int index = 0; public CircularSet(int size) { this.size = size; array = new int[size]; // Initialize to a value not produced // by SerialNumbers: Arrays.fill(array, -1); } public synchronized void add(int i) { array[index] = i; // Wrap index and write over old elements: index = ++index % size; } public synchronized boolean contains(int val) { for(int i = 0; i < size; i++) if(array[i] == val) return true; return false; } } OnJava8-Examples-1.0/lowlevel/DelayQueueDemo.java000066400000000000000000000047011374004044700217450ustar00rootroot00000000000000// lowlevel/DelayQueueDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import static java.util.concurrent.TimeUnit.*; class DelayedTask implements Runnable, Delayed { private static int counter = 0; private final int id = counter++; private final int delta; private final long trigger; protected static List sequence = new ArrayList<>(); DelayedTask(int delayInMilliseconds) { delta = delayInMilliseconds; trigger = System.nanoTime() + NANOSECONDS.convert(delta, MILLISECONDS); sequence.add(this); } @Override public long getDelay(TimeUnit unit) { return unit.convert( trigger - System.nanoTime(), NANOSECONDS); } @Override public int compareTo(Delayed arg) { DelayedTask that = (DelayedTask)arg; if(trigger < that.trigger) return -1; if(trigger > that.trigger) return 1; return 0; } @Override public void run() { System.out.print(this + " "); } @Override public String toString() { return String.format("[%d] Task %d", delta, id); } public String summary() { return String.format("(%d:%d)", id, delta); } public static class EndTask extends DelayedTask { EndTask(int delay) { super(delay); } @Override public void run() { sequence.forEach(dt -> System.out.println(dt.summary())); } } } public class DelayQueueDemo { public static void main(String[] args) throws Exception { DelayQueue tasks = Stream.concat( // Random delays: new Random(47).ints(20, 0, 4000) .mapToObj(DelayedTask::new), // Add the summarizing task: Stream.of(new DelayedTask.EndTask(4000))) .collect(Collectors .toCollection(DelayQueue::new)); while(tasks.size() > 0) tasks.take().run(); } } /* Output: [128] Task 12 [429] Task 6 [551] Task 13 [555] Task 2 [693] Task 3 [809] Task 15 [961] Task 5 [1258] Task 1 [1258] Task 20 [1520] Task 19 [1861] Task 4 [1998] Task 17 [2200] Task 8 [2207] Task 10 [2288] Task 11 [2522] Task 9 [2589] Task 14 [2861] Task 18 [2868] Task 7 [3278] Task 16 (0:4000) (1:1258) (2:555) (3:693) (4:1861) (5:961) (6:429) (7:2868) (8:2200) (9:2522) (10:2207) (11:2288) (12:128) (13:551) (14:2589) (15:809) (16:3278) (17:1998) (18:2861) (19:1520) (20:1258) */ OnJava8-Examples-1.0/lowlevel/EvenChecker.java000066400000000000000000000023451374004044700212610ustar00rootroot00000000000000// lowlevel/EvenChecker.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import onjava.TimedAbort; public class EvenChecker implements Runnable { private IntGenerator generator; private final int id; public EvenChecker(IntGenerator generator, int id) { this.generator = generator; this.id = id; } @Override public void run() { while(!generator.isCanceled()) { int val = generator.next(); if(val % 2 != 0) { System.out.println(val + " not even!"); generator.cancel(); // Cancels all EvenCheckers } } } // Test any IntGenerator: public static void test(IntGenerator gp, int count) { List> checkers = IntStream.range(0, count) .mapToObj(i -> new EvenChecker(gp, i)) .map(CompletableFuture::runAsync) .collect(Collectors.toList()); checkers.forEach(CompletableFuture::join); } // Default value for count: public static void test(IntGenerator gp) { new TimedAbort(4, "No odd numbers discovered"); test(gp, 10); } } OnJava8-Examples-1.0/lowlevel/EvenProducer.java000066400000000000000000000011621374004044700214740ustar00rootroot00000000000000// lowlevel/EvenProducer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // When threads collide // {VisuallyInspectOutput} public class EvenProducer extends IntGenerator { private int currentEvenValue = 0; @Override public int next() { ++currentEvenValue; // [1] ++currentEvenValue; return currentEvenValue; } public static void main(String[] args) { EvenChecker.test(new EvenProducer()); } } /* Output: 419 not even! 425 not even! 423 not even! 421 not even! 417 not even! */ OnJava8-Examples-1.0/lowlevel/ExceptionThread.java000066400000000000000000000016441374004044700221660ustar00rootroot00000000000000// lowlevel/ExceptionThread.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ThrowsException} import java.util.concurrent.*; public class ExceptionThread implements Runnable { @Override public void run() { throw new RuntimeException(); } public static void main(String[] args) { ExecutorService es = Executors.newCachedThreadPool(); es.execute(new ExceptionThread()); es.shutdown(); } } /* Output: ___[ Error Output ]___ Exception in thread "pool-1-thread-1" java.lang.RuntimeException at ExceptionThread.run(ExceptionThread.java:8) at java.util.concurrent.ThreadPoolExecutor.runW orker(ThreadPoolExecutor.java:1142) at java.util.concurrent.ThreadPoolExecutor$Work er.run(ThreadPoolExecutor.java:617) at java.lang.Thread.run(Thread.java:745) */ OnJava8-Examples-1.0/lowlevel/IntGenerator.java000066400000000000000000000007421374004044700214770ustar00rootroot00000000000000// lowlevel/IntGenerator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.atomic.AtomicBoolean; public abstract class IntGenerator { private AtomicBoolean canceled = new AtomicBoolean(); public abstract int next(); public void cancel() { canceled.set(true); } public boolean isCanceled() { return canceled.get(); } } OnJava8-Examples-1.0/lowlevel/IntTestable.java000066400000000000000000000006221374004044700213110ustar00rootroot00000000000000// lowlevel/IntTestable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public abstract class IntTestable implements Runnable, IntSupplier { abstract void evenIncrement(); @Override public void run() { while(true) evenIncrement(); } } OnJava8-Examples-1.0/lowlevel/MutexEvenProducer.java000066400000000000000000000014341374004044700225210ustar00rootroot00000000000000// lowlevel/MutexEvenProducer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Preventing thread collisions with mutexes import java.util.concurrent.locks.*; import onjava.Nap; public class MutexEvenProducer extends IntGenerator { private int currentEvenValue = 0; private Lock lock = new ReentrantLock(); @Override public int next() { lock.lock(); try { ++currentEvenValue; new Nap(0.01); // Cause failure faster ++currentEvenValue; return currentEvenValue; } finally { lock.unlock(); } } public static void main(String[] args) { EvenChecker.test(new MutexEvenProducer()); } } /* No odd numbers discovered */ OnJava8-Examples-1.0/lowlevel/NaiveExceptionHandling.java000066400000000000000000000017731374004044700234710ustar00rootroot00000000000000// lowlevel/NaiveExceptionHandling.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ThrowsException} import java.util.concurrent.*; public class NaiveExceptionHandling { public static void main(String[] args) { ExecutorService es = Executors.newCachedThreadPool(); try { es.execute(new ExceptionThread()); } catch(RuntimeException ue) { // This statement will NOT execute! System.out.println("Exception was handled!"); } finally { es.shutdown(); } } } /* Output: ___[ Error Output ]___ Exception in thread "pool-1-thread-1" java.lang.RuntimeException at ExceptionThread.run(ExceptionThread.java:8) at java.util.concurrent.ThreadPoolExecutor.runW orker(ThreadPoolExecutor.java:1142) at java.util.concurrent.ThreadPoolExecutor$Work er.run(ThreadPoolExecutor.java:617) at java.lang.Thread.run(Thread.java:745) */ OnJava8-Examples-1.0/lowlevel/NotAtomic.java000066400000000000000000000016451374004044700207760ustar00rootroot00000000000000// lowlevel/NotAtomic.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // javap -c NotAtomic // {ExcludeFromGradle} // {VisuallyInspectOutput} public class NotAtomic { int i; void f1() { i++; } void f2() { i += 3; } } /* Output: Compiled from "NotAtomic.java" public class NotAtomic { int i; public NotAtomic(); Code: 0: aload_0 1: invokespecial #1 // Method java/lang/Object."":()V 4: return void f1(); Code: 0: aload_0 1: dup 2: getfield #2 // Field i:I 5: iconst_1 6: iadd 7: putfield #2 // Field i:I 10: return void f2(); Code: 0: aload_0 1: dup 2: getfield #2 // Field i:I 5: iconst_3 6: iadd 7: putfield #2 // Field i:I 10: return } */ OnJava8-Examples-1.0/lowlevel/NumberOfProcessors.java000066400000000000000000000005651374004044700227010ustar00rootroot00000000000000// lowlevel/NumberOfProcessors.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class NumberOfProcessors { public static void main(String[] args) { System.out.println( Runtime.getRuntime().availableProcessors()); } } /* Output: 8 */ OnJava8-Examples-1.0/lowlevel/PriorityBlockingQueueDemo.java000066400000000000000000000070361374004044700242050ustar00rootroot00000000000000// lowlevel/PriorityBlockingQueueDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import java.util.concurrent.atomic.*; import onjava.Nap; class Prioritized implements Comparable { private static AtomicInteger counter = new AtomicInteger(); private final int id = counter.getAndIncrement(); private final int priority; private static List sequence = new CopyOnWriteArrayList<>(); Prioritized(int priority) { this.priority = priority; sequence.add(this); } @Override public int compareTo(Prioritized arg) { return priority < arg.priority ? 1 : (priority > arg.priority ? -1 : 0); } @Override public String toString() { return String.format( "[%d] Prioritized %d", priority, id); } public void displaySequence() { int count = 0; for(Prioritized pt : sequence) { System.out.printf("(%d:%d)", pt.id, pt.priority); if(++count % 5 == 0) System.out.println(); } } public static class EndSentinel extends Prioritized { EndSentinel() { super(-1); } } } class Producer implements Runnable { private static AtomicInteger seed = new AtomicInteger(47); private SplittableRandom rand = new SplittableRandom(seed.getAndAdd(10)); private Queue queue; Producer(Queue q) { queue = q; } @Override public void run() { rand.ints(10, 0, 20) .mapToObj(Prioritized::new) .peek(p -> new Nap(rand.nextDouble() / 10)) .forEach(p -> queue.add(p)); queue.add(new Prioritized.EndSentinel()); } } class Consumer implements Runnable { private PriorityBlockingQueue q; private SplittableRandom rand = new SplittableRandom(47); Consumer(PriorityBlockingQueue q) { this.q = q; } @Override public void run() { while(true) { try { Prioritized pt = q.take(); System.out.println(pt); if(pt instanceof Prioritized.EndSentinel) { pt.displaySequence(); break; } new Nap(rand.nextDouble() / 10); } catch(InterruptedException e) { throw new RuntimeException(e); } } } } public class PriorityBlockingQueueDemo { public static void main(String[] args) { PriorityBlockingQueue queue = new PriorityBlockingQueue<>(); CompletableFuture.runAsync(new Producer(queue)); CompletableFuture.runAsync(new Producer(queue)); CompletableFuture.runAsync(new Producer(queue)); CompletableFuture.runAsync(new Consumer(queue)) .join(); } } /* Output: [15] Prioritized 2 [17] Prioritized 1 [17] Prioritized 5 [16] Prioritized 6 [14] Prioritized 9 [12] Prioritized 0 [11] Prioritized 4 [11] Prioritized 12 [13] Prioritized 13 [12] Prioritized 16 [14] Prioritized 18 [15] Prioritized 23 [18] Prioritized 26 [16] Prioritized 29 [12] Prioritized 17 [11] Prioritized 30 [11] Prioritized 24 [10] Prioritized 15 [10] Prioritized 22 [8] Prioritized 25 [8] Prioritized 11 [8] Prioritized 10 [6] Prioritized 31 [3] Prioritized 7 [2] Prioritized 20 [1] Prioritized 3 [0] Prioritized 19 [0] Prioritized 8 [0] Prioritized 14 [0] Prioritized 21 [-1] Prioritized 28 (0:12)(2:15)(1:17)(3:1)(4:11) (5:17)(6:16)(7:3)(8:0)(9:14) (10:8)(11:8)(12:11)(13:13)(14:0) (15:10)(16:12)(17:12)(18:14)(19:0) (20:2)(21:0)(22:10)(23:15)(24:11) (25:8)(26:18)(27:-1)(28:-1)(29:16) (30:11)(31:6)(32:-1) */ OnJava8-Examples-1.0/lowlevel/ReOrdering.java000066400000000000000000000007071374004044700211370ustar00rootroot00000000000000// lowlevel/ReOrdering.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ReOrdering implements Runnable { int one, two, three, four, five, six; volatile int volaTile; @Override public void run() { one = 1; two = 2; three = 3; volaTile = 92; int x = four; int y = five; int z = six; } } OnJava8-Examples-1.0/lowlevel/SafeReturn.java000066400000000000000000000010471374004044700211530ustar00rootroot00000000000000// lowlevel/SafeReturn.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; import java.util.concurrent.*; public class SafeReturn extends IntTestable { private int i = 0; public synchronized int getAsInt() { return i; } public synchronized void evenIncrement() { i++; i++; } public static void main(String[] args) { Atomicity.test(new SafeReturn()); } } /* Output: No failures found */ OnJava8-Examples-1.0/lowlevel/SerialNumberChecker.java000066400000000000000000000017501374004044700227530ustar00rootroot00000000000000// lowlevel/SerialNumberChecker.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Test SerialNumbers implementations for thread-safety import java.util.concurrent.*; import onjava.Nap; public class SerialNumberChecker implements Runnable { private CircularSet serials = new CircularSet(1000); private SerialNumbers producer; public SerialNumberChecker(SerialNumbers producer) { this.producer = producer; } @Override public void run() { while(true) { int serial = producer.nextSerialNumber(); if(serials.contains(serial)) { System.out.println("Duplicate: " + serial); System.exit(0); } serials.add(serial); } } static void test(SerialNumbers producer) { for(int i = 0; i < 10; i++) CompletableFuture.runAsync( new SerialNumberChecker(producer)); new Nap(4, "No duplicates detected"); } } OnJava8-Examples-1.0/lowlevel/SerialNumberTest.java000066400000000000000000000005511374004044700223240ustar00rootroot00000000000000// lowlevel/SerialNumberTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SerialNumberTest { public static void main(String[] args) { SerialNumberChecker.test(new SerialNumbers()); } } /* Output: Duplicate: 148044 */ OnJava8-Examples-1.0/lowlevel/SerialNumbers.java000066400000000000000000000005361374004044700216520ustar00rootroot00000000000000// lowlevel/SerialNumbers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SerialNumbers { private volatile int serialNumber = 0; public int nextSerialNumber() { return serialNumber++; // Not thread-safe } } OnJava8-Examples-1.0/lowlevel/SettingDefaultHandler.java000066400000000000000000000011011374004044700233040ustar00rootroot00000000000000// lowlevel/SettingDefaultHandler.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class SettingDefaultHandler { public static void main(String[] args) { Thread.setDefaultUncaughtExceptionHandler( new MyUncaughtExceptionHandler()); ExecutorService es = Executors.newCachedThreadPool(); es.execute(new ExceptionThread()); es.shutdown(); } } /* Output: caught java.lang.RuntimeException */ OnJava8-Examples-1.0/lowlevel/SwallowedException.java000066400000000000000000000007701374004044700227170ustar00rootroot00000000000000// lowlevel/SwallowedException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.concurrent.*; public class SwallowedException { public static void main(String[] args) throws InterruptedException { ExecutorService exec = Executors.newSingleThreadExecutor(); exec.submit(() -> { throw new RuntimeException(); }); exec.shutdown(); } } OnJava8-Examples-1.0/lowlevel/SyncOnObject.java000066400000000000000000000027211374004044700214350ustar00rootroot00000000000000// lowlevel/SyncOnObject.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Synchronizing on another object import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import onjava.Nap; class DualSynch { ConcurrentLinkedQueue trace = new ConcurrentLinkedQueue<>(); public synchronized void f(boolean nap) { for(int i = 0; i < 5; i++) { trace.add(String.format("f() " + i)); if(nap) new Nap(0.01); } } private Object syncObject = new Object(); public void g(boolean nap) { synchronized(syncObject) { for(int i = 0; i < 5; i++) { trace.add(String.format("g() " + i)); if(nap) new Nap(0.01); } } } } public class SyncOnObject { static void test(boolean fNap, boolean gNap) { DualSynch ds = new DualSynch(); List> cfs = Arrays.stream(new Runnable[] { () -> ds.f(fNap), () -> ds.g(gNap) }) .map(CompletableFuture::runAsync) .collect(Collectors.toList()); cfs.forEach(CompletableFuture::join); ds.trace.forEach(System.out::println); } public static void main(String[] args) { test(true, false); System.out.println("****"); test(false, true); } } /* Output: f() 0 g() 0 g() 1 g() 2 g() 3 g() 4 f() 1 f() 2 f() 3 f() 4 **** f() 0 g() 0 f() 1 f() 2 f() 3 f() 4 g() 1 g() 2 g() 3 g() 4 */ OnJava8-Examples-1.0/lowlevel/SynchronizedComparison.java000066400000000000000000000037731374004044700236170ustar00rootroot00000000000000// lowlevel/SynchronizedComparison.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Synchronizing blocks instead of entire methods // speeds up access. import java.util.*; import java.util.stream.*; import java.util.concurrent.*; import java.util.concurrent.atomic.*; import onjava.Nap; abstract class Guarded { AtomicLong callCount = new AtomicLong(); public abstract void method(); @Override public String toString() { return getClass().getSimpleName() + ": " + callCount.get(); } } class SynchronizedMethod extends Guarded { public synchronized void method() { new Nap(0.01); callCount.incrementAndGet(); } } class CriticalSection extends Guarded { public void method() { new Nap(0.01); synchronized(this) { callCount.incrementAndGet(); } } } class Caller implements Runnable { private Guarded g; Caller(Guarded g) { this.g = g; } private AtomicLong successfulCalls = new AtomicLong(); private AtomicBoolean stop = new AtomicBoolean(false); @Override public void run() { new Timer().schedule(new TimerTask() { public void run() { stop.set(true); } }, 2500); while(!stop.get()) { g.method(); successfulCalls.getAndIncrement(); } System.out.println( "-> " + successfulCalls.get()); } } public class SynchronizedComparison { static void test(Guarded g) { List> callers = Stream.of( new Caller(g), new Caller(g), new Caller(g), new Caller(g)) .map(CompletableFuture::runAsync) .collect(Collectors.toList()); callers.forEach(CompletableFuture::join); System.out.println(g); } public static void main(String[] args) { test(new CriticalSection()); test(new SynchronizedMethod()); } } /* Output: -> 243 -> 243 -> 243 -> 243 CriticalSection: 972 -> 69 -> 61 -> 83 -> 36 SynchronizedMethod: 249 */ OnJava8-Examples-1.0/lowlevel/SynchronizedEvenProducer.java000066400000000000000000000012601374004044700240730ustar00rootroot00000000000000// lowlevel/SynchronizedEvenProducer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simplifying mutexes with the synchronized keyword import onjava.Nap; public class SynchronizedEvenProducer extends IntGenerator { private int currentEvenValue = 0; @Override public synchronized int next() { ++currentEvenValue; new Nap(0.01); // Cause failure faster ++currentEvenValue; return currentEvenValue; } public static void main(String[] args) { EvenChecker.test(new SynchronizedEvenProducer()); } } /* Output: No odd numbers discovered */ OnJava8-Examples-1.0/lowlevel/SynchronizedSerialNumbers.java000066400000000000000000000010271374004044700242460ustar00rootroot00000000000000// lowlevel/SynchronizedSerialNumbers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SynchronizedSerialNumbers extends SerialNumbers { private int serialNumber = 0; public synchronized int nextSerialNumber() { return serialNumber++; } public static void main(String[] args) { SerialNumberChecker.test( new SynchronizedSerialNumbers()); } } /* Output: No duplicates detected */ OnJava8-Examples-1.0/lowlevel/TestAbort.java000066400000000000000000000006241374004044700210040ustar00rootroot00000000000000// lowlevel/TestAbort.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; public class TestAbort { public static void main(String[] args) { new TimedAbort(1); System.out.println("Napping for 4"); new Nap(4); } } /* Output: Napping for 4 TimedAbort 1.0 */ OnJava8-Examples-1.0/lowlevel/ThreadSize.java000066400000000000000000000014451374004044700211410ustar00rootroot00000000000000// lowlevel/ThreadSize.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromGradle} Takes a long time or hangs import java.util.concurrent.*; import onjava.Nap; public class ThreadSize { static class Dummy extends Thread { @Override public void run() { new Nap(1); } } public static void main(String[] args) { ExecutorService exec = Executors.newCachedThreadPool(); int count = 0; try { while(true) { exec.execute(new Dummy()); count++; } } catch(Error e) { System.out.println( e.getClass().getSimpleName() + ": " + count); System.exit(0); } finally { exec.shutdown(); } } } OnJava8-Examples-1.0/lowlevel/UnsafeReturn.java000066400000000000000000000010361374004044700215140ustar00rootroot00000000000000// lowlevel/UnsafeReturn.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; import java.util.concurrent.*; public class UnsafeReturn extends IntTestable { private int i = 0; public int getAsInt() { return i; } public synchronized void evenIncrement() { i++; i++; } public static void main(String[] args) { Atomicity.test(new UnsafeReturn()); } } /* Output: failed with: 79 */ OnJava8-Examples-1.0/lowlevel/WorkStealingPool.java000066400000000000000000000020371374004044700223400ustar00rootroot00000000000000// lowlevel/WorkStealingPool.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; import java.util.concurrent.*; class ShowThread implements Runnable { @Override public void run() { System.out.println( Thread.currentThread().getName()); } } public class WorkStealingPool { public static void main(String[] args) throws InterruptedException { System.out.println( Runtime.getRuntime().availableProcessors()); ExecutorService exec = Executors.newWorkStealingPool(); IntStream.range(0, 10) .mapToObj(n -> new ShowThread()) .forEach(exec::execute); exec.awaitTermination(1, TimeUnit.SECONDS); } } /* Output: 8 ForkJoinPool-1-worker-2 ForkJoinPool-1-worker-1 ForkJoinPool-1-worker-2 ForkJoinPool-1-worker-3 ForkJoinPool-1-worker-2 ForkJoinPool-1-worker-1 ForkJoinPool-1-worker-3 ForkJoinPool-1-worker-1 ForkJoinPool-1-worker-4 ForkJoinPool-1-worker-2 */ OnJava8-Examples-1.0/newio/000077500000000000000000000000001374004044700155205ustar00rootroot00000000000000OnJava8-Examples-1.0/newio/AvailableCharSets.java000066400000000000000000000024021374004044700216760ustar00rootroot00000000000000// newio/AvailableCharSets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Displays Charsets and aliases import java.nio.charset.*; import java.util.*; public class AvailableCharSets { public static void main(String[] args) { SortedMap charSets = Charset.availableCharsets(); for(String csName : charSets.keySet()) { System.out.print(csName); Iterator aliases = charSets.get(csName) .aliases().iterator(); if(aliases.hasNext()) System.out.print(": "); while(aliases.hasNext()) { System.out.print(aliases.next()); if(aliases.hasNext()) System.out.print(", "); } System.out.println(); } } } /* Output: (First 7 Lines) Big5: csBig5 Big5-HKSCS: big5-hkscs, big5hk, Big5_HKSCS, big5hkscs CESU-8: CESU8, csCESU-8 EUC-JP: csEUCPkdFmtjapanese, x-euc-jp, eucjis, Extended_UNIX_Code_Packed_Format_for_Japanese, euc_jp, eucjp, x-eucjp EUC-KR: ksc5601-1987, csEUCKR, ksc5601_1987, ksc5601, 5601, euc_kr, ksc_5601, ks_c_5601-1987, euckr GB18030: gb18030-2000 GB2312: gb2312, euc-cn, x-EUC-CN, euccn, EUC_CN, gb2312-80, gb2312-1980 ... */ OnJava8-Examples-1.0/newio/BufferToText.java000066400000000000000000000047161374004044700207540ustar00rootroot00000000000000// newio/BufferToText.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Converting text to and from ByteBuffers import java.nio.*; import java.nio.channels.*; import java.nio.charset.*; import java.io.*; public class BufferToText { private static final int BSIZE = 1024; public static void main(String[] args) { try( FileChannel fc = new FileOutputStream( "data2.txt").getChannel() ) { fc.write(ByteBuffer.wrap("Some text".getBytes())); } catch(IOException e) { throw new RuntimeException(e); } ByteBuffer buff = ByteBuffer.allocate(BSIZE); try( FileChannel fc = new FileInputStream( "data2.txt").getChannel() ) { fc.read(buff); } catch(IOException e) { throw new RuntimeException(e); } buff.flip(); // Doesn't work: System.out.println(buff.asCharBuffer()); // Decode using this system's default Charset: buff.rewind(); String encoding = System.getProperty("file.encoding"); System.out.println("Decoded using " + encoding + ": " + Charset.forName(encoding).decode(buff)); // Encode with something that prints: try( FileChannel fc = new FileOutputStream( "data2.txt").getChannel() ) { fc.write(ByteBuffer.wrap( "Some text".getBytes("UTF-16BE"))); } catch(IOException e) { throw new RuntimeException(e); } // Now try reading again: buff.clear(); try( FileChannel fc = new FileInputStream( "data2.txt").getChannel() ) { fc.read(buff); } catch(IOException e) { throw new RuntimeException(e); } buff.flip(); System.out.println(buff.asCharBuffer()); // Use a CharBuffer to write through: buff = ByteBuffer.allocate(24); buff.asCharBuffer().put("Some text"); try( FileChannel fc = new FileOutputStream( "data2.txt").getChannel() ) { fc.write(buff); } catch(IOException e) { throw new RuntimeException(e); } // Read and display: buff.clear(); try( FileChannel fc = new FileInputStream( "data2.txt").getChannel() ) { fc.read(buff); } catch(IOException e) { throw new RuntimeException(e); } buff.flip(); System.out.println(buff.asCharBuffer()); } } /* Output: ???? Decoded using windows-1252: Some text Some text Some textNULNULNUL */ OnJava8-Examples-1.0/newio/ChannelCopy.java000066400000000000000000000020301374004044700205610ustar00rootroot00000000000000// newio/ChannelCopy.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Copying a file using channels and buffers // {java ChannelCopy ChannelCopy.java test.txt} import java.nio.*; import java.nio.channels.*; import java.io.*; public class ChannelCopy { private static final int BSIZE = 1024; public static void main(String[] args) { if(args.length != 2) { System.out.println( "arguments: sourcefile destfile"); System.exit(1); } try( FileChannel in = new FileInputStream( args[0]).getChannel(); FileChannel out = new FileOutputStream( args[1]).getChannel() ) { ByteBuffer buffer = ByteBuffer.allocate(BSIZE); while(in.read(buffer) != -1) { buffer.flip(); // Prepare for writing out.write(buffer); buffer.clear(); // Prepare for reading } } catch(IOException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/newio/Endians.java000066400000000000000000000016251374004044700177500ustar00rootroot00000000000000// newio/Endians.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Endian differences and data storage import java.nio.*; import java.util.*; public class Endians { public static void main(String[] args) { ByteBuffer bb = ByteBuffer.wrap(new byte[12]); bb.asCharBuffer().put("abcdef"); System.out.println(Arrays.toString(bb.array())); bb.rewind(); bb.order(ByteOrder.BIG_ENDIAN); bb.asCharBuffer().put("abcdef"); System.out.println(Arrays.toString(bb.array())); bb.rewind(); bb.order(ByteOrder.LITTLE_ENDIAN); bb.asCharBuffer().put("abcdef"); System.out.println(Arrays.toString(bb.array())); } } /* Output: [0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102] [0, 97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102] [97, 0, 98, 0, 99, 0, 100, 0, 101, 0, 102, 0] */ OnJava8-Examples-1.0/newio/FileLocking.java000066400000000000000000000014331374004044700205520ustar00rootroot00000000000000// newio/FileLocking.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.channels.*; import java.util.concurrent.*; import java.io.*; public class FileLocking { public static void main(String[] args) { try( FileOutputStream fos = new FileOutputStream("file.txt"); FileLock fl = fos.getChannel().tryLock() ) { if(fl != null) { System.out.println("Locked File"); TimeUnit.MILLISECONDS.sleep(100); fl.release(); System.out.println("Released Lock"); } } catch(IOException | InterruptedException e) { throw new RuntimeException(e); } } } /* Output: Locked File Released Lock */ OnJava8-Examples-1.0/newio/GetChannel.java000066400000000000000000000026061374004044700203770ustar00rootroot00000000000000// newio/GetChannel.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Getting channels from streams import java.nio.*; import java.nio.channels.*; import java.io.*; public class GetChannel { private static String name = "data.txt"; private static final int BSIZE = 1024; public static void main(String[] args) { // Write a file: try( FileChannel fc = new FileOutputStream(name) .getChannel() ) { fc.write(ByteBuffer .wrap("Some text ".getBytes())); } catch(IOException e) { throw new RuntimeException(e); } // Add to the end of the file: try( FileChannel fc = new RandomAccessFile( name, "rw").getChannel() ) { fc.position(fc.size()); // Move to the end fc.write(ByteBuffer .wrap("Some more".getBytes())); } catch(IOException e) { throw new RuntimeException(e); } // Read the file: try( FileChannel fc = new FileInputStream(name) .getChannel() ) { ByteBuffer buff = ByteBuffer.allocate(BSIZE); fc.read(buff); buff.flip(); while(buff.hasRemaining()) System.out.write(buff.get()); } catch(IOException e) { throw new RuntimeException(e); } System.out.flush(); } } /* Output: Some text Some more */ OnJava8-Examples-1.0/newio/GetData.java000066400000000000000000000030021374004044700176670ustar00rootroot00000000000000// newio/GetData.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Getting different representations from a ByteBuffer import java.nio.*; public class GetData { private static final int BSIZE = 1024; public static void main(String[] args) { ByteBuffer bb = ByteBuffer.allocate(BSIZE); // Allocation automatically zeroes the ByteBuffer: int i = 0; while(i++ < bb.limit()) if(bb.get() != 0) System.out.println("nonzero"); System.out.println("i = " + i); bb.rewind(); // Store and read a char array: bb.asCharBuffer().put("Howdy!"); char c; while((c = bb.getChar()) != 0) System.out.print(c + " "); System.out.println(); bb.rewind(); // Store and read a short: bb.asShortBuffer().put((short)471142); System.out.println(bb.getShort()); bb.rewind(); // Store and read an int: bb.asIntBuffer().put(99471142); System.out.println(bb.getInt()); bb.rewind(); // Store and read a long: bb.asLongBuffer().put(99471142); System.out.println(bb.getLong()); bb.rewind(); // Store and read a float: bb.asFloatBuffer().put(99471142); System.out.println(bb.getFloat()); bb.rewind(); // Store and read a double: bb.asDoubleBuffer().put(99471142); System.out.println(bb.getDouble()); bb.rewind(); } } /* Output: i = 1025 H o w d y ! 12390 99471142 99471142 9.9471144E7 9.9471142E7 */ OnJava8-Examples-1.0/newio/IntBufferDemo.java000066400000000000000000000015321374004044700210550ustar00rootroot00000000000000// newio/IntBufferDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Manipulating ints in a ByteBuffer with an IntBuffer import java.nio.*; public class IntBufferDemo { private static final int BSIZE = 1024; public static void main(String[] args) { ByteBuffer bb = ByteBuffer.allocate(BSIZE); IntBuffer ib = bb.asIntBuffer(); // Store an array of int: ib.put(new int[]{ 11, 42, 47, 99, 143, 811, 1016 }); // Absolute location read and write: System.out.println(ib.get(3)); ib.put(3, 1811); // Setting a new limit before rewinding the buffer. ib.flip(); while(ib.hasRemaining()) { int i = ib.get(); System.out.println(i); } } } /* Output: 99 11 42 47 1811 143 811 1016 */ OnJava8-Examples-1.0/newio/LargeMappedFiles.java000066400000000000000000000015771374004044700215410ustar00rootroot00000000000000// newio/LargeMappedFiles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating a very large file using mapping import java.nio.*; import java.nio.channels.*; import java.io.*; public class LargeMappedFiles { static int length = 0x8000000; // 128 MB public static void main(String[] args) throws Exception { try( RandomAccessFile tdat = new RandomAccessFile("test.dat", "rw") ) { MappedByteBuffer out = tdat.getChannel().map( FileChannel.MapMode.READ_WRITE, 0, length); for(int i = 0; i < length; i++) out.put((byte)'x'); System.out.println("Finished writing"); for(int i = length/2; i < length/2 + 6; i++) System.out.print((char)out.get(i)); } } } /* Output: Finished writing xxxxxx */ OnJava8-Examples-1.0/newio/LockingMappedFiles.java000066400000000000000000000033411374004044700220640ustar00rootroot00000000000000// newio/LockingMappedFiles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Locking portions of a mapped file import java.nio.*; import java.nio.channels.*; import java.io.*; public class LockingMappedFiles { static final int LENGTH = 0x8FFFFFF; // 128 MB static FileChannel fc; public static void main(String[] args) throws Exception { fc = new RandomAccessFile("test.dat", "rw") .getChannel(); MappedByteBuffer out = fc.map( FileChannel.MapMode.READ_WRITE, 0, LENGTH); for(int i = 0; i < LENGTH; i++) out.put((byte)'x'); new LockAndModify(out, 0, 0 + LENGTH/3); new LockAndModify( out, LENGTH/2, LENGTH/2 + LENGTH/4); } private static class LockAndModify extends Thread { private ByteBuffer buff; private int start, end; LockAndModify(ByteBuffer mbb, int start, int end) { this.start = start; this.end = end; mbb.limit(end); mbb.position(start); buff = mbb.slice(); start(); } @Override public void run() { try { // Exclusive lock with no overlap: FileLock fl = fc.lock(start, end, false); System.out.println( "Locked: "+ start +" to "+ end); // Perform modification: while(buff.position() < buff.limit() - 1) buff.put((byte)(buff.get() + 1)); fl.release(); System.out.println( "Released: " + start + " to " + end); } catch(IOException e) { throw new RuntimeException(e); } } } } /* Output: Locked: 75497471 to 113246206 Locked: 0 to 50331647 Released: 75497471 to 113246206 Released: 0 to 50331647 */ OnJava8-Examples-1.0/newio/MappedIO.java000066400000000000000000000076031374004044700200270ustar00rootroot00000000000000// newio/MappedIO.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromGradle} Runs too long under WSL2 import java.util.*; import java.nio.*; import java.nio.channels.*; import java.io.*; public class MappedIO { private static int numOfInts = 4_000_000; private static int numOfUbuffInts = 100_000; private abstract static class Tester { private String name; Tester(String name) { this.name = name; } public void runTest() { System.out.print(name + ": "); long start = System.nanoTime(); test(); double duration = System.nanoTime() - start; System.out.format("%.3f%n", duration/1.0e9); } public abstract void test(); } private static Tester[] tests = { new Tester("Stream Write") { @Override public void test() { try( DataOutputStream dos = new DataOutputStream( new BufferedOutputStream( new FileOutputStream( new File("temp.tmp")))) ) { for(int i = 0; i < numOfInts; i++) dos.writeInt(i); } catch(IOException e) { throw new RuntimeException(e); } } }, new Tester("Mapped Write") { @Override public void test() { try( FileChannel fc = new RandomAccessFile("temp.tmp", "rw") .getChannel() ) { IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE, 0, fc.size()).asIntBuffer(); for(int i = 0; i < numOfInts; i++) ib.put(i); } catch(IOException e) { throw new RuntimeException(e); } } }, new Tester("Stream Read") { @Override public void test() { try( DataInputStream dis = new DataInputStream( new BufferedInputStream( new FileInputStream("temp.tmp"))) ) { for(int i = 0; i < numOfInts; i++) dis.readInt(); } catch(IOException e) { throw new RuntimeException(e); } } }, new Tester("Mapped Read") { @Override public void test() { try( FileChannel fc = new FileInputStream( new File("temp.tmp")).getChannel() ) { IntBuffer ib = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size()).asIntBuffer(); while(ib.hasRemaining()) ib.get(); } catch(IOException e) { throw new RuntimeException(e); } } }, new Tester("Stream Read/Write") { @Override public void test() { try( RandomAccessFile raf = new RandomAccessFile( new File("temp.tmp"), "rw") ) { raf.writeInt(1); for(int i = 0; i < numOfUbuffInts; i++) { raf.seek(raf.length() - 4); raf.writeInt(raf.readInt()); } } catch(IOException e) { throw new RuntimeException(e); } } }, new Tester("Mapped Read/Write") { @Override public void test() { try( FileChannel fc = new RandomAccessFile( new File("temp.tmp"), "rw").getChannel() ) { IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE, 0, fc.size()).asIntBuffer(); ib.put(0); for(int i = 1; i < numOfUbuffInts; i++) ib.put(ib.get(i - 1)); } catch(IOException e) { throw new RuntimeException(e); } } } }; public static void main(String[] args) { Arrays.stream(tests).forEach(Tester::runTest); } } /* Output: Stream Write: 0.615 Mapped Write: 0.050 Stream Read: 0.577 Mapped Read: 0.015 Stream Read/Write: 4.069 Mapped Read/Write: 0.013 */ OnJava8-Examples-1.0/newio/TransferTo.java000066400000000000000000000015361374004044700204570ustar00rootroot00000000000000// newio/TransferTo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using transferTo() between channels // {java TransferTo TransferTo.java TransferTo.txt} import java.nio.channels.*; import java.io.*; public class TransferTo { public static void main(String[] args) { if(args.length != 2) { System.out.println( "arguments: sourcefile destfile"); System.exit(1); } try( FileChannel in = new FileInputStream( args[0]).getChannel(); FileChannel out = new FileOutputStream( args[1]).getChannel() ) { in.transferTo(0, in.size(), out); // Or: // out.transferFrom(in, 0, in.size()); } catch(IOException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/newio/UsingBuffers.java000066400000000000000000000016221374004044700207660ustar00rootroot00000000000000// newio/UsingBuffers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.*; public class UsingBuffers { private static void symmetricScramble(CharBuffer buffer) { while(buffer.hasRemaining()) { buffer.mark(); char c1 = buffer.get(); char c2 = buffer.get(); buffer.reset(); buffer.put(c2).put(c1); } } public static void main(String[] args) { char[] data = "UsingBuffers".toCharArray(); ByteBuffer bb = ByteBuffer.allocate(data.length * 2); CharBuffer cb = bb.asCharBuffer(); cb.put(data); System.out.println(cb.rewind()); symmetricScramble(cb); System.out.println(cb.rewind()); symmetricScramble(cb); System.out.println(cb.rewind()); } } /* Output: UsingBuffers sUniBgfuefsr UsingBuffers */ OnJava8-Examples-1.0/newio/ViewBuffers.java000066400000000000000000000043111374004044700206110ustar00rootroot00000000000000// newio/ViewBuffers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.*; public class ViewBuffers { public static void main(String[] args) { ByteBuffer bb = ByteBuffer.wrap( new byte[]{ 0, 0, 0, 0, 0, 0, 0, 'a' }); bb.rewind(); System.out.print("Byte Buffer "); while(bb.hasRemaining()) System.out.print( bb.position()+ " -> " + bb.get() + ", "); System.out.println(); CharBuffer cb = ((ByteBuffer)bb.rewind()).asCharBuffer(); System.out.print("Char Buffer "); while(cb.hasRemaining()) System.out.print( cb.position() + " -> " + cb.get() + ", "); System.out.println(); FloatBuffer fb = ((ByteBuffer)bb.rewind()).asFloatBuffer(); System.out.print("Float Buffer "); while(fb.hasRemaining()) System.out.print( fb.position()+ " -> " + fb.get() + ", "); System.out.println(); IntBuffer ib = ((ByteBuffer)bb.rewind()).asIntBuffer(); System.out.print("Int Buffer "); while(ib.hasRemaining()) System.out.print( ib.position()+ " -> " + ib.get() + ", "); System.out.println(); LongBuffer lb = ((ByteBuffer)bb.rewind()).asLongBuffer(); System.out.print("Long Buffer "); while(lb.hasRemaining()) System.out.print( lb.position()+ " -> " + lb.get() + ", "); System.out.println(); ShortBuffer sb = ((ByteBuffer)bb.rewind()).asShortBuffer(); System.out.print("Short Buffer "); while(sb.hasRemaining()) System.out.print( sb.position()+ " -> " + sb.get() + ", "); System.out.println(); DoubleBuffer db = ((ByteBuffer)bb.rewind()).asDoubleBuffer(); System.out.print("Double Buffer "); while(db.hasRemaining()) System.out.print( db.position()+ " -> " + db.get() + ", "); } } /* Output: Byte Buffer 0 -> 0, 1 -> 0, 2 -> 0, 3 -> 0, 4 -> 0, 5 -> 0, 6 -> 0, 7 -> 97, Char Buffer 0 -> NUL, 1 -> NUL, 2 -> NUL, 3 -> a, Float Buffer 0 -> 0.0, 1 -> 1.36E-43, Int Buffer 0 -> 0, 1 -> 97, Long Buffer 0 -> 97, Short Buffer 0 -> 0, 1 -> 0, 2 -> 0, 3 -> 97, Double Buffer 0 -> 4.8E-322, */ OnJava8-Examples-1.0/objects/000077500000000000000000000000001374004044700160305ustar00rootroot00000000000000OnJava8-Examples-1.0/objects/HelloDate.java000066400000000000000000000005501374004044700205340ustar00rootroot00000000000000// objects/HelloDate.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class HelloDate { public static void main(String[] args) { System.out.println("Hello, it's: "); System.out.println(new Date()); } } OnJava8-Examples-1.0/objects/ShowProperties.java000066400000000000000000000023211374004044700216660ustar00rootroot00000000000000// objects/ShowProperties.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class ShowProperties { public static void main(String[] args) { System.getProperties().list(System.out); System.out.println(System.getProperty("user.name")); System.out.println( System.getProperty("java.library.path")); } } /* Output: (First 20 Lines) -- listing properties -- java.runtime.name=Java(TM) SE Runtime Environment sun.boot.library.path=C:\Program Files\Java\jdk1.8.0_112\jr... java.vm.version=25.112-b15 java.vm.vendor=Oracle Corporation java.vendor.url=http://java.oracle.com/ path.separator=; java.vm.name=Java HotSpot(TM) 64-Bit Server VM file.encoding.pkg=sun.io user.script= user.country=US sun.java.launcher=SUN_STANDARD sun.os.patch.level= java.vm.specification.name=Java Virtual Machine Specification user.dir=C:\Users\Bruce\Documents\GitHub\on-ja... java.runtime.version=1.8.0_112-b15 java.awt.graphicsenv=sun.awt.Win32GraphicsEnvironment java.endorsed.dirs=C:\Program Files\Java\jdk1.8.0_112\jr... os.arch=amd64 java.io.tmpdir=C:\Users\Bruce\AppData\Local\Temp\ ... */ OnJava8-Examples-1.0/onjava/000077500000000000000000000000001374004044700156555ustar00rootroot00000000000000OnJava8-Examples-1.0/onjava/ArrayShow.java000066400000000000000000000035251374004044700204440ustar00rootroot00000000000000// onjava/ArrayShow.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.*; public interface ArrayShow { static void show(Object[] a) { System.out.println(Arrays.toString(a)); } static void show(boolean[] a) { System.out.println(Arrays.toString(a)); } static void show(byte[] a) { System.out.println(Arrays.toString(a)); } static void show(char[] a) { System.out.println(Arrays.toString(a)); } static void show(short[] a) { System.out.println(Arrays.toString(a)); } static void show(int[] a) { System.out.println(Arrays.toString(a)); } static void show(long[] a) { System.out.println(Arrays.toString(a)); } static void show(float[] a) { System.out.println(Arrays.toString(a)); } static void show(double[] a) { System.out.println(Arrays.toString(a)); } // Start with a description: static void show(String info, Object[] a) { System.out.print(info + ": "); show(a); } static void show(String info, boolean[] a) { System.out.print(info + ": "); show(a); } static void show(String info, byte[] a) { System.out.print(info + ": "); show(a); } static void show(String info, char[] a) { System.out.print(info + ": "); show(a); } static void show(String info, short[] a) { System.out.print(info + ": "); show(a); } static void show(String info, int[] a) { System.out.print(info + ": "); show(a); } static void show(String info, long[] a) { System.out.print(info + ": "); show(a); } static void show(String info, float[] a) { System.out.print(info + ": "); show(a); } static void show(String info, double[] a) { System.out.print(info + ": "); show(a); } } OnJava8-Examples-1.0/onjava/BasicSupplier.java000066400000000000000000000017111374004044700212650ustar00rootroot00000000000000// onjava/BasicSupplier.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Supplier from a class with a no-arg constructor package onjava; import java.util.function.*; import java.lang.reflect.InvocationTargetException; public class BasicSupplier implements Supplier { private Class type; public BasicSupplier(Class type) { this.type = type; } @Override public T get() { try { // Assumes type is a public class: return type.getConstructor().newInstance(); } catch(InstantiationException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { throw new RuntimeException(e); } } // Produce a default Supplier from a type token: public static Supplier create(Class type) { return new BasicSupplier<>(type); } } OnJava8-Examples-1.0/onjava/CollectionMethodDifferences.java000066400000000000000000000105651374004044700241210ustar00rootroot00000000000000// onjava/CollectionMethodDifferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.CollectionMethodDifferences} package onjava; import java.lang.reflect.*; import java.util.*; import java.util.stream.*; public class CollectionMethodDifferences { static Set methodSet(Class type) { return Arrays.stream(type.getMethods()) .map(Method::getName) .collect(Collectors.toCollection(TreeSet::new)); } static void interfaces(Class type) { System.out.print("Interfaces in " + type.getSimpleName() + ": "); System.out.println( Arrays.stream(type.getInterfaces()) .map(Class::getSimpleName) .collect(Collectors.toList())); } static Set object = methodSet(Object.class); static { object.add("clone"); } static void difference(Class superset, Class subset) { System.out.print(superset.getSimpleName() + " extends " + subset.getSimpleName() + ", adds: "); Set comp = Sets.difference( methodSet(superset), methodSet(subset)); comp.removeAll(object); // Ignore 'Object' methods System.out.println(comp); interfaces(superset); } public static void main(String[] args) { System.out.println("Collection: " + methodSet(Collection.class)); interfaces(Collection.class); difference(Set.class, Collection.class); difference(HashSet.class, Set.class); difference(LinkedHashSet.class, HashSet.class); difference(TreeSet.class, Set.class); difference(List.class, Collection.class); difference(ArrayList.class, List.class); difference(LinkedList.class, List.class); difference(Queue.class, Collection.class); difference(PriorityQueue.class, Queue.class); System.out.println("Map: " + methodSet(Map.class)); difference(HashMap.class, Map.class); difference(LinkedHashMap.class, HashMap.class); difference(SortedMap.class, Map.class); difference(TreeMap.class, Map.class); } } /* Output: Collection: [add, addAll, clear, contains, containsAll, equals, forEach, hashCode, isEmpty, iterator, parallelStream, remove, removeAll, removeIf, retainAll, size, spliterator, stream, toArray] Interfaces in Collection: [Iterable] Set extends Collection, adds: [] Interfaces in Set: [Collection] HashSet extends Set, adds: [] Interfaces in HashSet: [Set, Cloneable, Serializable] LinkedHashSet extends HashSet, adds: [] Interfaces in LinkedHashSet: [Set, Cloneable, Serializable] TreeSet extends Set, adds: [headSet, descendingIterator, descendingSet, pollLast, subSet, floor, tailSet, ceiling, last, lower, comparator, pollFirst, first, higher] Interfaces in TreeSet: [NavigableSet, Cloneable, Serializable] List extends Collection, adds: [replaceAll, get, indexOf, subList, set, sort, lastIndexOf, listIterator] Interfaces in List: [Collection] ArrayList extends List, adds: [trimToSize, ensureCapacity] Interfaces in ArrayList: [List, RandomAccess, Cloneable, Serializable] LinkedList extends List, adds: [offerFirst, poll, getLast, offer, getFirst, removeFirst, element, removeLastOccurrence, peekFirst, peekLast, push, pollFirst, removeFirstOccurrence, descendingIterator, pollLast, removeLast, pop, addLast, peek, offerLast, addFirst] Interfaces in LinkedList: [List, Deque, Cloneable, Serializable] Queue extends Collection, adds: [poll, peek, offer, element] Interfaces in Queue: [Collection] PriorityQueue extends Queue, adds: [comparator] Interfaces in PriorityQueue: [Serializable] Map: [clear, compute, computeIfAbsent, computeIfPresent, containsKey, containsValue, entrySet, equals, forEach, get, getOrDefault, hashCode, isEmpty, keySet, merge, put, putAll, putIfAbsent, remove, replace, replaceAll, size, values] HashMap extends Map, adds: [] Interfaces in HashMap: [Map, Cloneable, Serializable] LinkedHashMap extends HashMap, adds: [] Interfaces in LinkedHashMap: [Map] SortedMap extends Map, adds: [lastKey, subMap, comparator, firstKey, headMap, tailMap] Interfaces in SortedMap: [Map] TreeMap extends Map, adds: [descendingKeySet, navigableKeySet, higherEntry, higherKey, floorKey, subMap, ceilingKey, pollLastEntry, firstKey, lowerKey, headMap, tailMap, lowerEntry, ceilingEntry, descendingMap, pollFirstEntry, lastKey, firstEntry, floorEntry, comparator, lastEntry] Interfaces in TreeMap: [NavigableMap, Cloneable, Serializable] */ OnJava8-Examples-1.0/onjava/ConvertTo.java000066400000000000000000000057411374004044700204520ustar00rootroot00000000000000// onjava/ConvertTo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public interface ConvertTo { static boolean[] primitive(Boolean[] in) { boolean[] result = new boolean[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; // Autounboxing return result; } static char[] primitive(Character[] in) { char[] result = new char[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static byte[] primitive(Byte[] in) { byte[] result = new byte[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static short[] primitive(Short[] in) { short[] result = new short[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static int[] primitive(Integer[] in) { int[] result = new int[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static long[] primitive(Long[] in) { long[] result = new long[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static float[] primitive(Float[] in) { float[] result = new float[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static double[] primitive(Double[] in) { double[] result = new double[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } // Convert from primitive array to wrapped array: static Boolean[] boxed(boolean[] in) { Boolean[] result = new Boolean[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; // Autoboxing return result; } static Character[] boxed(char[] in) { Character[] result = new Character[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static Byte[] boxed(byte[] in) { Byte[] result = new Byte[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static Short[] boxed(short[] in) { Short[] result = new Short[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static Integer[] boxed(int[] in) { Integer[] result = new Integer[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static Long[] boxed(long[] in) { Long[] result = new Long[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static Float[] boxed(float[] in) { Float[] result = new Float[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } static Double[] boxed(double[] in) { Double[] result = new Double[in.length]; for(int i = 0; i < in.length; i++) result[i] = in[i]; return result; } } OnJava8-Examples-1.0/onjava/Count.java000066400000000000000000000131771374004044700176210ustar00rootroot00000000000000// onjava/Count.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Generate incremental values of different types package onjava; import java.util.*; import java.util.function.*; import static onjava.ConvertTo.*; public interface Count { class Boolean implements Supplier { private boolean b = true; @Override public java.lang.Boolean get() { b = !b; return java.lang.Boolean.valueOf(b); } public java.lang.Boolean get(int n) { return get(); } public java.lang.Boolean[] array(int sz) { java.lang.Boolean[] result = new java.lang.Boolean[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pboolean { private boolean b = true; public boolean get() { b = !b; return b; } public boolean get(int n) { return get(); } public boolean[] array(int sz) { return primitive(new Boolean().array(sz)); } } class Byte implements Supplier { private byte b; @Override public java.lang.Byte get() { return b++; } public java.lang.Byte get(int n) { return get(); } public java.lang.Byte[] array(int sz) { java.lang.Byte[] result = new java.lang.Byte[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pbyte { private byte b; public byte get() { return b++; } public byte get(int n) { return get(); } public byte[] array(int sz) { return primitive(new Byte().array(sz)); } } char[] CHARS = "abcdefghijklmnopqrstuvwxyz".toCharArray(); class Character implements Supplier { private int i; @Override public java.lang.Character get() { i = (i + 1) % CHARS.length; return CHARS[i]; } public java.lang.Character get(int n) { return get(); } public java.lang.Character[] array(int sz) { java.lang.Character[] result = new java.lang.Character[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pchar { private int i; public char get() { i = (i + 1) % CHARS.length; return CHARS[i]; } public char get(int n) { return get(); } public char[] array(int sz) { return primitive(new Character().array(sz)); } } class Short implements Supplier { short s; @Override public java.lang.Short get() { return s++; } public java.lang.Short get(int n) { return get(); } public java.lang.Short[] array(int sz) { java.lang.Short[] result = new java.lang.Short[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pshort { short s; public short get() { return s++; } public short get(int n) { return get(); } public short[] array(int sz) { return primitive(new Short().array(sz)); } } class Integer implements Supplier { int i; @Override public java.lang.Integer get() { return i++; } public java.lang.Integer get(int n) { return get(); } public java.lang.Integer[] array(int sz) { java.lang.Integer[] result = new java.lang.Integer[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pint implements IntSupplier { int i; public int get() { return i++; } public int get(int n) { return get(); } @Override public int getAsInt() { return get(); } public int[] array(int sz) { return primitive(new Integer().array(sz)); } } class Long implements Supplier { private long l; @Override public java.lang.Long get() { return l++; } public java.lang.Long get(int n) { return get(); } public java.lang.Long[] array(int sz) { java.lang.Long[] result = new java.lang.Long[sz]; Arrays.setAll(result, n -> get()); return result; } } class Plong implements LongSupplier { private long l; public long get() { return l++; } public long get(int n) { return get(); } @Override public long getAsLong() { return get(); } public long[] array(int sz) { return primitive(new Long().array(sz)); } } class Float implements Supplier { private int i; @Override public java.lang.Float get() { return java.lang.Float.valueOf(i++); } public java.lang.Float get(int n) { return get(); } public java.lang.Float[] array(int sz) { java.lang.Float[] result = new java.lang.Float[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pfloat { private int i; public float get() { return i++; } public float get(int n) { return get(); } public float[] array(int sz) { return primitive(new Float().array(sz)); } } class Double implements Supplier { private int i; @Override public java.lang.Double get() { return java.lang.Double.valueOf(i++); } public java.lang.Double get(int n) { return get(); } public java.lang.Double[] array(int sz) { java.lang.Double[] result = new java.lang.Double[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pdouble implements DoubleSupplier { private int i; public double get() { return i++; } public double get(int n) { return get(); } @Override public double getAsDouble() { return get(0); } public double[] array(int sz) { return primitive(new Double().array(sz)); } } } OnJava8-Examples-1.0/onjava/CountMap.java000066400000000000000000000046711374004044700202560ustar00rootroot00000000000000// onjava/CountMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Unlimited-length Map containing sample data // {java onjava.CountMap} package onjava; import java.util.*; import java.util.stream.*; public class CountMap extends AbstractMap { private int size; private static char[] chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray(); private static String value(int key) { return chars[key % chars.length] + Integer.toString(key / chars.length); } public CountMap(int size) { this.size = size < 0 ? 0 : size; } @Override public String get(Object key) { return value((Integer)key); } private static class Entry implements Map.Entry { int index; Entry(int index) { this.index = index; } @Override public boolean equals(Object o) { return o instanceof Entry && Objects.equals(index, ((Entry)o).index); } @Override public Integer getKey() { return index; } @Override public String getValue() { return value(index); } @Override public String setValue(String value) { throw new UnsupportedOperationException(); } @Override public int hashCode() { return Objects.hashCode(index); } } @Override public Set> entrySet() { // LinkedHashSet retains initialization order: return IntStream.range(0, size) .mapToObj(Entry::new) .collect(Collectors .toCollection(LinkedHashSet::new)); } public static void main(String[] args) { final int size = 6; CountMap cm = new CountMap(60); System.out.println(cm); System.out.println(cm.get(500)); cm.values().stream() .limit(size) .forEach(System.out::println); System.out.println(); new Random(47).ints(size, 0, 1000) .mapToObj(cm::get) .forEach(System.out::println); } } /* Output: {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0, 10=K0, 11=L0, 12=M0, 13=N0, 14=O0, 15=P0, 16=Q0, 17=R0, 18=S0, 19=T0, 20=U0, 21=V0, 22=W0, 23=X0, 24=Y0, 25=Z0, 26=A1, 27=B1, 28=C1, 29=D1, 30=E1, 31=F1, 32=G1, 33=H1, 34=I1, 35=J1, 36=K1, 37=L1, 38=M1, 39=N1, 40=O1, 41=P1, 42=Q1, 43=R1, 44=S1, 45=T1, 46=U1, 47=V1, 48=W1, 49=X1, 50=Y1, 51=Z1, 52=A2, 53=B2, 54=C2, 55=D2, 56=E2, 57=F2, 58=G2, 59=H2} G19 A0 B0 C0 D0 E0 F0 Y9 J21 R26 D33 Z36 N16 */ OnJava8-Examples-1.0/onjava/CountingIntegerList.java000066400000000000000000000016661374004044700224710ustar00rootroot00000000000000// onjava/CountingIntegerList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // List of any length, containing sample data // {java onjava.CountingIntegerList} package onjava; import java.util.*; public class CountingIntegerList extends AbstractList { private int size; public CountingIntegerList() { size = 0; } public CountingIntegerList(int size) { this.size = size < 0 ? 0 : size; } @Override public Integer get(int index) { return index; } @Override public int size() { return size; } public static void main(String[] args) { List cil = new CountingIntegerList(30); System.out.println(cil); System.out.println(cil.get(500)); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29] 500 */ OnJava8-Examples-1.0/onjava/Countries.java000066400000000000000000000246011374004044700204760ustar00rootroot00000000000000// onjava/Countries.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // "Flyweight" Maps and Lists of sample data // {java onjava.Countries} package onjava; import java.util.*; public class Countries { public static final String[][] DATA = { // Africa {"ALGERIA","Algiers"}, {"ANGOLA","Luanda"}, {"BENIN","Porto-Novo"}, {"BOTSWANA","Gaberone"}, {"BURKINA FASO","Ouagadougou"}, {"BURUNDI","Bujumbura"}, {"CAMEROON","Yaounde"}, {"CAPE VERDE","Praia"}, {"CENTRAL AFRICAN REPUBLIC","Bangui"}, {"CHAD","N'djamena"}, {"COMOROS","Moroni"}, {"CONGO","Brazzaville"}, {"DJIBOUTI","Dijibouti"}, {"EGYPT","Cairo"}, {"EQUATORIAL GUINEA","Malabo"}, {"ERITREA","Asmara"}, {"ETHIOPIA","Addis Ababa"}, {"GABON","Libreville"}, {"THE GAMBIA","Banjul"}, {"GHANA","Accra"}, {"GUINEA","Conakry"}, {"BISSAU","Bissau"}, {"COTE D'IVOIR (IVORY COAST)","Yamoussoukro"}, {"KENYA","Nairobi"}, {"LESOTHO","Maseru"}, {"LIBERIA","Monrovia"}, {"LIBYA","Tripoli"}, {"MADAGASCAR","Antananarivo"}, {"MALAWI","Lilongwe"}, {"MALI","Bamako"}, {"MAURITANIA","Nouakchott"}, {"MAURITIUS","Port Louis"}, {"MOROCCO","Rabat"}, {"MOZAMBIQUE","Maputo"}, {"NAMIBIA","Windhoek"}, {"NIGER","Niamey"}, {"NIGERIA","Abuja"}, {"RWANDA","Kigali"}, {"SAO TOME E PRINCIPE","Sao Tome"}, {"SENEGAL","Dakar"}, {"SEYCHELLES","Victoria"}, {"SIERRA LEONE","Freetown"}, {"SOMALIA","Mogadishu"}, {"SOUTH AFRICA","Pretoria/Cape Town"}, {"SUDAN","Khartoum"}, {"SWAZILAND","Mbabane"}, {"TANZANIA","Dodoma"}, {"TOGO","Lome"}, {"TUNISIA","Tunis"}, {"UGANDA","Kampala"}, {"DEMOCRATIC REPUBLIC OF THE CONGO (ZAIRE)", "Kinshasa"}, {"ZAMBIA","Lusaka"}, {"ZIMBABWE","Harare"}, // Asia {"AFGHANISTAN","Kabul"}, {"BAHRAIN","Manama"}, {"BANGLADESH","Dhaka"}, {"BHUTAN","Thimphu"}, {"BRUNEI","Bandar Seri Begawan"}, {"CAMBODIA","Phnom Penh"}, {"CHINA","Beijing"}, {"CYPRUS","Nicosia"}, {"INDIA","New Delhi"}, {"INDONESIA","Jakarta"}, {"IRAN","Tehran"}, {"IRAQ","Baghdad"}, {"ISRAEL","Jerusalem"}, {"JAPAN","Tokyo"}, {"JORDAN","Amman"}, {"KUWAIT","Kuwait City"}, {"LAOS","Vientiane"}, {"LEBANON","Beirut"}, {"MALAYSIA","Kuala Lumpur"}, {"THE MALDIVES","Male"}, {"MONGOLIA","Ulan Bator"}, {"MYANMAR (BURMA)","Rangoon"}, {"NEPAL","Katmandu"}, {"NORTH KOREA","P'yongyang"}, {"OMAN","Muscat"}, {"PAKISTAN","Islamabad"}, {"PHILIPPINES","Manila"}, {"QATAR","Doha"}, {"SAUDI ARABIA","Riyadh"}, {"SINGAPORE","Singapore"}, {"SOUTH KOREA","Seoul"}, {"SRI LANKA","Colombo"}, {"SYRIA","Damascus"}, {"TAIWAN (REPUBLIC OF CHINA)","Taipei"}, {"THAILAND","Bangkok"}, {"TURKEY","Ankara"}, {"UNITED ARAB EMIRATES","Abu Dhabi"}, {"VIETNAM","Hanoi"}, {"YEMEN","Sana'a"}, // Australia and Oceania {"AUSTRALIA","Canberra"}, {"FIJI","Suva"}, {"KIRIBATI","Bairiki"}, {"MARSHALL ISLANDS","Dalap-Uliga-Darrit"}, {"MICRONESIA","Palikir"}, {"NAURU","Yaren"}, {"NEW ZEALAND","Wellington"}, {"PALAU","Koror"}, {"PAPUA NEW GUINEA","Port Moresby"}, {"SOLOMON ISLANDS","Honaira"}, {"TONGA","Nuku'alofa"}, {"TUVALU","Fongafale"}, {"VANUATU","Port Vila"}, {"WESTERN SAMOA","Apia"}, // Eastern Europe and former USSR {"ARMENIA","Yerevan"}, {"AZERBAIJAN","Baku"}, {"BELARUS (BYELORUSSIA)","Minsk"}, {"BULGARIA","Sofia"}, {"GEORGIA","Tbilisi"}, {"KAZAKSTAN","Almaty"}, {"KYRGYZSTAN","Alma-Ata"}, {"MOLDOVA","Chisinau"}, {"RUSSIA","Moscow"}, {"TAJIKISTAN","Dushanbe"}, {"TURKMENISTAN","Ashkabad"}, {"UKRAINE","Kyiv"}, {"UZBEKISTAN","Tashkent"}, // Europe {"ALBANIA","Tirana"}, {"ANDORRA","Andorra la Vella"}, {"AUSTRIA","Vienna"}, {"BELGIUM","Brussels"}, {"BOSNIA-HERZEGOVINA","Sarajevo"}, {"CROATIA","Zagreb"}, {"CZECH REPUBLIC","Prague"}, {"DENMARK","Copenhagen"}, {"ESTONIA","Tallinn"}, {"FINLAND","Helsinki"}, {"FRANCE","Paris"}, {"GERMANY","Berlin"}, {"GREECE","Athens"}, {"HUNGARY","Budapest"}, {"ICELAND","Reykjavik"}, {"IRELAND","Dublin"}, {"ITALY","Rome"}, {"LATVIA","Riga"}, {"LIECHTENSTEIN","Vaduz"}, {"LITHUANIA","Vilnius"}, {"LUXEMBOURG","Luxembourg"}, {"MACEDONIA","Skopje"}, {"MALTA","Valletta"}, {"MONACO","Monaco"}, {"MONTENEGRO","Podgorica"}, {"THE NETHERLANDS","Amsterdam"}, {"NORWAY","Oslo"}, {"POLAND","Warsaw"}, {"PORTUGAL","Lisbon"}, {"ROMANIA","Bucharest"}, {"SAN MARINO","San Marino"}, {"SERBIA","Belgrade"}, {"SLOVAKIA","Bratislava"}, {"SLOVENIA","Ljuijana"}, {"SPAIN","Madrid"}, {"SWEDEN","Stockholm"}, {"SWITZERLAND","Berne"}, {"UNITED KINGDOM","London"}, {"VATICAN CITY","Vatican City"}, // North and Central America {"ANTIGUA AND BARBUDA","Saint John's"}, {"BAHAMAS","Nassau"}, {"BARBADOS","Bridgetown"}, {"BELIZE","Belmopan"}, {"CANADA","Ottawa"}, {"COSTA RICA","San Jose"}, {"CUBA","Havana"}, {"DOMINICA","Roseau"}, {"DOMINICAN REPUBLIC","Santo Domingo"}, {"EL SALVADOR","San Salvador"}, {"GRENADA","Saint George's"}, {"GUATEMALA","Guatemala City"}, {"HAITI","Port-au-Prince"}, {"HONDURAS","Tegucigalpa"}, {"JAMAICA","Kingston"}, {"MEXICO","Mexico City"}, {"NICARAGUA","Managua"}, {"PANAMA","Panama City"}, {"ST. KITTS AND NEVIS","Basseterre"}, {"ST. LUCIA","Castries"}, {"ST. VINCENT AND THE GRENADINES","Kingstown"}, {"UNITED STATES OF AMERICA","Washington, D.C."}, // South America {"ARGENTINA","Buenos Aires"}, {"BOLIVIA","Sucre (legal)/La Paz(administrative)"}, {"BRAZIL","Brasilia"}, {"CHILE","Santiago"}, {"COLOMBIA","Bogota"}, {"ECUADOR","Quito"}, {"GUYANA","Georgetown"}, {"PARAGUAY","Asuncion"}, {"PERU","Lima"}, {"SURINAME","Paramaribo"}, {"TRINIDAD AND TOBAGO","Port of Spain"}, {"URUGUAY","Montevideo"}, {"VENEZUELA","Caracas"}, }; // Use AbstractMap by implementing entrySet() private static class FlyweightMap extends AbstractMap { private static class Entry implements Map.Entry { int index; Entry(int index) { this.index = index; } @Override public boolean equals(Object o) { return o instanceof FlyweightMap && Objects.equals(DATA[index][0], o); } @Override public int hashCode() { return Objects.hashCode(DATA[index][0]); } @Override public String getKey() { return DATA[index][0]; } @Override public String getValue() { return DATA[index][1]; } @Override public String setValue(String value) { throw new UnsupportedOperationException(); } } // Implement size() & iterator() for AbstractSet: static class EntrySet extends AbstractSet> { private int size; EntrySet(int size) { if(size < 0) this.size = 0; // Can't be any bigger than the array: else if(size > DATA.length) this.size = DATA.length; else this.size = size; } @Override public int size() { return size; } private class Iter implements Iterator> { // Only one Entry object per Iterator: private Entry entry = new Entry(-1); @Override public boolean hasNext() { return entry.index < size - 1; } @Override public Map.Entry next() { entry.index++; return entry; } @Override public void remove() { throw new UnsupportedOperationException(); } } @Override public Iterator> iterator() { return new Iter(); } } private static Set> entries = new EntrySet(DATA.length); @Override public Set> entrySet() { return entries; } } // Create a partial map of 'size' countries: static Map select(final int size) { return new FlyweightMap() { @Override public Set> entrySet() { return new EntrySet(size); } }; } static Map map = new FlyweightMap(); public static Map capitals() { return map; // The entire map } public static Map capitals(int size) { return select(size); // A partial map } static List names = new ArrayList<>(map.keySet()); // All the names: public static List names() { return names; } // A partial list: public static List names(int size) { return new ArrayList<>(select(size).keySet()); } public static void main(String[] args) { System.out.println(capitals(10)); System.out.println(names(10)); System.out.println(new HashMap<>(capitals(3))); System.out.println( new LinkedHashMap<>(capitals(3))); System.out.println(new TreeMap<>(capitals(3))); System.out.println(new Hashtable<>(capitals(3))); System.out.println(new HashSet<>(names(6))); System.out.println(new LinkedHashSet<>(names(6))); System.out.println(new TreeSet<>(names(6))); System.out.println(new ArrayList<>(names(6))); System.out.println(new LinkedList<>(names(6))); System.out.println(capitals().get("BRAZIL")); } } /* Output: {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo, BOTSWANA=Gaberone, BURKINA FASO=Ouagadougou, BURUNDI=Bujumbura, CAMEROON=Yaounde, CAPE VERDE=Praia, CENTRAL AFRICAN REPUBLIC=Bangui, CHAD=N'djamena} [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI, CAMEROON, CAPE VERDE, CENTRAL AFRICAN REPUBLIC, CHAD] {BENIN=Porto-Novo, ANGOLA=Luanda, ALGERIA=Algiers} {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo} {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo} {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo} [BENIN, BOTSWANA, ANGOLA, BURKINA FASO, ALGERIA, BURUNDI] [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI] [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI] [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI] [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO, BURUNDI] Brasilia */ OnJava8-Examples-1.0/onjava/Enums.java000066400000000000000000000007551374004044700176160ustar00rootroot00000000000000// onjava/Enums.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.*; public class Enums { private static Random rand = new Random(47); public static > T random(Class ec) { return random(ec.getEnumConstants()); } public static T random(T[] values) { return values[rand.nextInt(values.length)]; } } OnJava8-Examples-1.0/onjava/FillMap.java000066400000000000000000000022061374004044700200440ustar00rootroot00000000000000// onjava/FillMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.*; import java.util.function.*; import java.util.stream.*; public class FillMap { public static Map basic(Supplier> pairGen, int size) { return Stream.generate(pairGen) .limit(size) .collect(Collectors .toMap(Pair::key, Pair::value)); } public static Map basic(Supplier keyGen, Supplier valueGen, int size) { return Stream.generate( () -> Pair.make(keyGen.get(), valueGen.get())) .limit(size) .collect(Collectors .toMap(Pair::key, Pair::value)); } public static > M create(Supplier keyGen, Supplier valueGen, Supplier mapSupplier, int size) { return Stream.generate( () -> Pair.make(keyGen.get(), valueGen.get())) .limit(size) .collect(Collectors .toMap(Pair::key, Pair::value, (k, v) -> k, mapSupplier)); } } OnJava8-Examples-1.0/onjava/HTMLColors.java000066400000000000000000000156201374004044700204520ustar00rootroot00000000000000// onjava/HTMLColors.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Sample data for collection examples package onjava; import java.util.*; import java.util.stream.*; import java.util.concurrent.*; public class HTMLColors { public static final Object[][] ARRAY = { { 0xF0F8FF, "AliceBlue" }, { 0xFAEBD7, "AntiqueWhite" }, { 0x7FFFD4, "Aquamarine" }, { 0xF0FFFF, "Azure" }, { 0xF5F5DC, "Beige" }, { 0xFFE4C4, "Bisque" }, { 0x000000, "Black" }, { 0xFFEBCD, "BlanchedAlmond" }, { 0x0000FF, "Blue" }, { 0x8A2BE2, "BlueViolet" }, { 0xA52A2A, "Brown" }, { 0xDEB887, "BurlyWood" }, { 0x5F9EA0, "CadetBlue" }, { 0x7FFF00, "Chartreuse" }, { 0xD2691E, "Chocolate" }, { 0xFF7F50, "Coral" }, { 0x6495ED, "CornflowerBlue" }, { 0xFFF8DC, "Cornsilk" }, { 0xDC143C, "Crimson" }, { 0x00FFFF, "Cyan" }, { 0x00008B, "DarkBlue" }, { 0x008B8B, "DarkCyan" }, { 0xB8860B, "DarkGoldenRod" }, { 0xA9A9A9, "DarkGray" }, { 0x006400, "DarkGreen" }, { 0xBDB76B, "DarkKhaki" }, { 0x8B008B, "DarkMagenta" }, { 0x556B2F, "DarkOliveGreen" }, { 0xFF8C00, "DarkOrange" }, { 0x9932CC, "DarkOrchid" }, { 0x8B0000, "DarkRed" }, { 0xE9967A, "DarkSalmon" }, { 0x8FBC8F, "DarkSeaGreen" }, { 0x483D8B, "DarkSlateBlue" }, { 0x2F4F4F, "DarkSlateGray" }, { 0x00CED1, "DarkTurquoise" }, { 0x9400D3, "DarkViolet" }, { 0xFF1493, "DeepPink" }, { 0x00BFFF, "DeepSkyBlue" }, { 0x696969, "DimGray" }, { 0x1E90FF, "DodgerBlue" }, { 0xB22222, "FireBrick" }, { 0xFFFAF0, "FloralWhite" }, { 0x228B22, "ForestGreen" }, { 0xDCDCDC, "Gainsboro" }, { 0xF8F8FF, "GhostWhite" }, { 0xFFD700, "Gold" }, { 0xDAA520, "GoldenRod" }, { 0x808080, "Gray" }, { 0x008000, "Green" }, { 0xADFF2F, "GreenYellow" }, { 0xF0FFF0, "HoneyDew" }, { 0xFF69B4, "HotPink" }, { 0xCD5C5C, "IndianRed" }, { 0x4B0082, "Indigo" }, { 0xFFFFF0, "Ivory" }, { 0xF0E68C, "Khaki" }, { 0xE6E6FA, "Lavender" }, { 0xFFF0F5, "LavenderBlush" }, { 0x7CFC00, "LawnGreen" }, { 0xFFFACD, "LemonChiffon" }, { 0xADD8E6, "LightBlue" }, { 0xF08080, "LightCoral" }, { 0xE0FFFF, "LightCyan" }, { 0xFAFAD2, "LightGoldenRodYellow" }, { 0xD3D3D3, "LightGray" }, { 0x90EE90, "LightGreen" }, { 0xFFB6C1, "LightPink" }, { 0xFFA07A, "LightSalmon" }, { 0x20B2AA, "LightSeaGreen" }, { 0x87CEFA, "LightSkyBlue" }, { 0x778899, "LightSlateGray" }, { 0xB0C4DE, "LightSteelBlue" }, { 0xFFFFE0, "LightYellow" }, { 0x00FF00, "Lime" }, { 0x32CD32, "LimeGreen" }, { 0xFAF0E6, "Linen" }, { 0xFF00FF, "Magenta" }, { 0x800000, "Maroon" }, { 0x66CDAA, "MediumAquaMarine" }, { 0x0000CD, "MediumBlue" }, { 0xBA55D3, "MediumOrchid" }, { 0x9370DB, "MediumPurple" }, { 0x3CB371, "MediumSeaGreen" }, { 0x7B68EE, "MediumSlateBlue" }, { 0x00FA9A, "MediumSpringGreen" }, { 0x48D1CC, "MediumTurquoise" }, { 0xC71585, "MediumVioletRed" }, { 0x191970, "MidnightBlue" }, { 0xF5FFFA, "MintCream" }, { 0xFFE4E1, "MistyRose" }, { 0xFFE4B5, "Moccasin" }, { 0xFFDEAD, "NavajoWhite" }, { 0x000080, "Navy" }, { 0xFDF5E6, "OldLace" }, { 0x808000, "Olive" }, { 0x6B8E23, "OliveDrab" }, { 0xFFA500, "Orange" }, { 0xFF4500, "OrangeRed" }, { 0xDA70D6, "Orchid" }, { 0xEEE8AA, "PaleGoldenRod" }, { 0x98FB98, "PaleGreen" }, { 0xAFEEEE, "PaleTurquoise" }, { 0xDB7093, "PaleVioletRed" }, { 0xFFEFD5, "PapayaWhip" }, { 0xFFDAB9, "PeachPuff" }, { 0xCD853F, "Peru" }, { 0xFFC0CB, "Pink" }, { 0xDDA0DD, "Plum" }, { 0xB0E0E6, "PowderBlue" }, { 0x800080, "Purple" }, { 0xFF0000, "Red" }, { 0xBC8F8F, "RosyBrown" }, { 0x4169E1, "RoyalBlue" }, { 0x8B4513, "SaddleBrown" }, { 0xFA8072, "Salmon" }, { 0xF4A460, "SandyBrown" }, { 0x2E8B57, "SeaGreen" }, { 0xFFF5EE, "SeaShell" }, { 0xA0522D, "Sienna" }, { 0xC0C0C0, "Silver" }, { 0x87CEEB, "SkyBlue" }, { 0x6A5ACD, "SlateBlue" }, { 0x708090, "SlateGray" }, { 0xFFFAFA, "Snow" }, { 0x00FF7F, "SpringGreen" }, { 0x4682B4, "SteelBlue" }, { 0xD2B48C, "Tan" }, { 0x008080, "Teal" }, { 0xD8BFD8, "Thistle" }, { 0xFF6347, "Tomato" }, { 0x40E0D0, "Turquoise" }, { 0xEE82EE, "Violet" }, { 0xF5DEB3, "Wheat" }, { 0xFFFFFF, "White" }, { 0xF5F5F5, "WhiteSmoke" }, { 0xFFFF00, "Yellow" }, { 0x9ACD32, "YellowGreen" }, }; public static final Map MAP = Arrays.stream(ARRAY) .collect(Collectors.toMap( element -> (Integer)element[0], element -> (String)element[1], (v1, v2) -> { // Merge function throw new IllegalStateException(); }, LinkedHashMap::new )); // Inversion only works if values are unique: public static Map invert(Map map) { return map.entrySet().stream() .collect(Collectors.toMap( Map.Entry::getValue, Map.Entry::getKey, (v1, v2) -> { throw new IllegalStateException(); }, LinkedHashMap::new )); } public static final Map INVMAP = invert(MAP); // Look up RGB value given a name: public static Integer rgb(String colorName) { return INVMAP.get(colorName); } public static final List LIST = Arrays.stream(ARRAY) .map(item -> (String)item[1]) .collect(Collectors.toList()); public static final List RGBLIST = Arrays.stream(ARRAY) .map(item -> (Integer)item[0]) .collect(Collectors.toList()); public static void show(Map.Entry e) { System.out.format( "0x%06X: %s%n", e.getKey(), e.getValue()); } public static void show(Map m, int count) { m.entrySet().stream() .limit(count) .forEach(e -> show(e)); } public static void show(Map m) { show(m, m.size()); } public static void show(Collection lst, int count) { lst.stream() .limit(count) .forEach(System.out::println); } public static void show(Collection lst) { show(lst, lst.size()); } public static void showrgb(Collection lst, int count) { lst.stream() .limit(count) .forEach(n -> System.out.format("0x%06X%n", n)); } public static void showrgb(Collection lst) { showrgb(lst, lst.size()); } public static void showInv(Map m, int count) { m.entrySet().stream() .limit(count) .forEach(e -> System.out.format( "%-20s 0x%06X%n", e.getKey(), e.getValue())); } public static void showInv(Map m) { showInv(m, m.size()); } public static void border() { System.out.println( "******************************"); } } OnJava8-Examples-1.0/onjava/MouseClick.java000066400000000000000000000011551374004044700205600ustar00rootroot00000000000000// onjava/MouseClick.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Helper interface to allow lambda expressions package onjava; import java.awt.event.*; // Default everything except mouseClicked(): public interface MouseClick extends MouseListener { @Override default void mouseEntered(MouseEvent e) {} @Override default void mouseExited(MouseEvent e) {} @Override default void mousePressed(MouseEvent e) {} @Override default void mouseReleased(MouseEvent e) {} } OnJava8-Examples-1.0/onjava/Nap.java000066400000000000000000000010041374004044700172310ustar00rootroot00000000000000// onjava/Nap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.concurrent.*; public class Nap { public Nap(double t) { // Seconds try { TimeUnit.MILLISECONDS.sleep((int)(1000 * t)); } catch(InterruptedException e) { throw new RuntimeException(e); } } public Nap(double t, String msg) { this(t); System.out.println(msg); } } OnJava8-Examples-1.0/onjava/Null.java000066400000000000000000000003371374004044700174350ustar00rootroot00000000000000// onjava/Null.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public interface Null {} OnJava8-Examples-1.0/onjava/OSExecute.java000066400000000000000000000020731374004044700203660ustar00rootroot00000000000000// onjava/OSExecute.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Run an operating system command // and send the output to the console package onjava; import java.io.*; public class OSExecute { public static void command(String command) { boolean err = false; try { Process process = new ProcessBuilder( command.split(" ")).start(); try( BufferedReader results = new BufferedReader( new InputStreamReader( process.getInputStream())); BufferedReader errors = new BufferedReader( new InputStreamReader( process.getErrorStream())) ) { results.lines() .forEach(System.out::println); err = errors.lines() .peek(System.err::println) .count() > 0; } } catch(IOException e) { throw new RuntimeException(e); } if(err) throw new OSExecuteException( "Errors executing " + command); } } OnJava8-Examples-1.0/onjava/OSExecuteException.java000066400000000000000000000005201374004044700222400ustar00rootroot00000000000000// onjava/OSExecuteException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public class OSExecuteException extends RuntimeException { public OSExecuteException(String why) { super(why); } } OnJava8-Examples-1.0/onjava/Operations.java000066400000000000000000000006641374004044700206510ustar00rootroot00000000000000// onjava/Operations.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.*; public interface Operations { void execute(); static void runOps(Operations... ops) { for(Operations op : ops) op.execute(); } static void show(String msg) { System.out.println(msg); } } OnJava8-Examples-1.0/onjava/Pair.java000066400000000000000000000007471374004044700174230ustar00rootroot00000000000000// onjava/Pair.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public class Pair { public final K key; public final V value; public Pair(K k, V v) { key = k; value = v; } public K key() { return key; } public V value() { return value; } public static Pair make(K k, V v) { return new Pair(k, v); } } OnJava8-Examples-1.0/onjava/ProcessFiles.java000066400000000000000000000025541374004044700211270ustar00rootroot00000000000000// onjava/ProcessFiles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.io.*; import java.nio.file.*; public class ProcessFiles { public interface Strategy { void process(File file); } private Strategy strategy; private String ext; public ProcessFiles(Strategy strategy, String ext) { this.strategy = strategy; this.ext = ext; } public void start(String[] args) { try { if(args.length == 0) processDirectoryTree(new File(".")); else for(String arg : args) { File fileArg = new File(arg); if(fileArg.isDirectory()) processDirectoryTree(fileArg); else { // Allow user to leave off extension: if(!arg.endsWith("." + ext)) arg += "." + ext; strategy.process( new File(arg).getCanonicalFile()); } } } catch(IOException e) { throw new RuntimeException(e); } } public void processDirectoryTree(File root) throws IOException { PathMatcher matcher = FileSystems.getDefault() .getPathMatcher("glob:**/*.{" + ext + "}"); Files.walk(root.toPath()) .filter(matcher::matches) .forEach(p -> strategy.process(p.toFile())); } } OnJava8-Examples-1.0/onjava/Rand.java000066400000000000000000000147711374004044700174160ustar00rootroot00000000000000// onjava/Rand.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Generate random values of different types package onjava; import java.util.*; import java.util.function.*; import static onjava.ConvertTo.*; public interface Rand { int MOD = 10_000; class Boolean implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Boolean get() { return r.nextBoolean(); } public java.lang.Boolean get(int n) { return get(); } public java.lang.Boolean[] array(int sz) { java.lang.Boolean[] result = new java.lang.Boolean[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pboolean { public boolean[] array(int sz) { return primitive(new Boolean().array(sz)); } } class Byte implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Byte get() { return (byte)r.nextInt(MOD); } public java.lang.Byte get(int n) { return get(); } public java.lang.Byte[] array(int sz) { java.lang.Byte[] result = new java.lang.Byte[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pbyte { public byte[] array(int sz) { return primitive(new Byte().array(sz)); } } class Character implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Character get() { return (char)r.nextInt('a', 'z' + 1); } public java.lang.Character get(int n) { return get(); } public java.lang.Character[] array(int sz) { java.lang.Character[] result = new java.lang.Character[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pchar { public char[] array(int sz) { return primitive(new Character().array(sz)); } } class Short implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Short get() { return (short)r.nextInt(MOD); } public java.lang.Short get(int n) { return get(); } public java.lang.Short[] array(int sz) { java.lang.Short[] result = new java.lang.Short[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pshort { public short[] array(int sz) { return primitive(new Short().array(sz)); } } class Integer implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Integer get() { return r.nextInt(MOD); } public java.lang.Integer get(int n) { return get(); } public java.lang.Integer[] array(int sz) { int[] primitive = new Pint().array(sz); java.lang.Integer[] result = new java.lang.Integer[sz]; for(int i = 0; i < sz; i++) result[i] = primitive[i]; return result; } } class Pint implements IntSupplier { SplittableRandom r = new SplittableRandom(47); @Override public int getAsInt() { return r.nextInt(MOD); } public int get(int n) { return getAsInt(); } public int[] array(int sz) { return r.ints(sz, 0, MOD).toArray(); } } class Long implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Long get() { return r.nextLong(MOD); } public java.lang.Long get(int n) { return get(); } public java.lang.Long[] array(int sz) { long[] primitive = new Plong().array(sz); java.lang.Long[] result = new java.lang.Long[sz]; for(int i = 0; i < sz; i++) result[i] = primitive[i]; return result; } } class Plong implements LongSupplier { SplittableRandom r = new SplittableRandom(47); @Override public long getAsLong() { return r.nextLong(MOD); } public long get(int n) { return getAsLong(); } public long[] array(int sz) { return r.longs(sz, 0, MOD).toArray(); } } class Float implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Float get() { return (float)trim(r.nextDouble()); } public java.lang.Float get(int n) { return get(); } public java.lang.Float[] array(int sz) { java.lang.Float[] result = new java.lang.Float[sz]; Arrays.setAll(result, n -> get()); return result; } } class Pfloat { public float[] array(int sz) { return primitive(new Float().array(sz)); } } static double trim(double d) { return ((double)Math.round(d * 1000.0)) / 100.0; } class Double implements Supplier { SplittableRandom r = new SplittableRandom(47); @Override public java.lang.Double get() { return trim(r.nextDouble()); } public java.lang.Double get(int n) { return get(); } public java.lang.Double[] array(int sz) { double[] primitive = new Rand.Pdouble().array(sz); java.lang.Double[] result = new java.lang.Double[sz]; for(int i = 0; i < sz; i++) result[i] = primitive[i]; return result; } } class Pdouble implements DoubleSupplier { SplittableRandom r = new SplittableRandom(47); @Override public double getAsDouble() { return trim(r.nextDouble()); } public double get(int n) { return getAsDouble(); } public double[] array(int sz) { double[] result = r.doubles(sz).toArray(); Arrays.setAll(result, n -> result[n] = trim(result[n])); return result; } } class String implements Supplier { SplittableRandom r = new SplittableRandom(47); private int strlen = 7; // Default length public String() {} public String(int strLength) { strlen = strLength; } @Override public java.lang.String get() { return r.ints(strlen, 'a', 'z' + 1) .collect(StringBuilder::new, StringBuilder::appendCodePoint, StringBuilder::append).toString(); } public java.lang.String get(int n) { return get(); } public java.lang.String[] array(int sz) { java.lang.String[] result = new java.lang.String[sz]; Arrays.setAll(result, n -> get()); return result; } } } OnJava8-Examples-1.0/onjava/Range.java000066400000000000000000000017361374004044700175630ustar00rootroot00000000000000// onjava/Range.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Array creation methods that can be used without // qualifiers, using static imports: package onjava; public class Range { // Produce a sequence [0..n) public static int[] range(int n) { int[] result = new int[n]; for(int i = 0; i < n; i++) result[i] = i; return result; } // Produce a sequence [start..end) public static int[] range(int start, int end) { int sz = end - start; int[] result = new int[sz]; for(int i = 0; i < sz; i++) result[i] = start + i; return result; } // Produce sequence [start..end) incrementing by step public static int[] range(int start, int end, int step) { int sz = (end - start)/step; int[] result = new int[sz]; for(int i = 0; i < sz; i++) result[i] = start + (i * step); return result; } } OnJava8-Examples-1.0/onjava/Repeat.java000066400000000000000000000005631374004044700177440ustar00rootroot00000000000000// onjava/Repeat.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import static java.util.stream.IntStream.*; public class Repeat { public static void repeat(int n, Runnable action) { range(0, n).forEach(i -> action.run()); } } OnJava8-Examples-1.0/onjava/RmDir.java000066400000000000000000000015441374004044700175410ustar00rootroot00000000000000// onjava/RmDir.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.nio.file.*; import java.nio.file.attribute.BasicFileAttributes; import java.io.IOException; public class RmDir { public static void rmdir(Path dir) throws IOException { Files.walkFileTree(dir, new SimpleFileVisitor() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { Files.delete(file); return FileVisitResult.CONTINUE; } @Override public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException { Files.delete(dir); return FileVisitResult.CONTINUE; } }); } } OnJava8-Examples-1.0/onjava/Sets.java000066400000000000000000000016171374004044700174430ustar00rootroot00000000000000// onjava/Sets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import java.util.*; public class Sets { public static Set union(Set a, Set b) { Set result = new HashSet<>(a); result.addAll(b); return result; } public static Set intersection(Set a, Set b) { Set result = new HashSet<>(a); result.retainAll(b); return result; } // Subtract subset from superset: public static Set difference(Set superset, Set subset) { Set result = new HashSet<>(superset); result.removeAll(subset); return result; } // Reflexive--everything not in the intersection: public static Set complement(Set a, Set b) { return difference(union(a, b), intersection(a, b)); } } OnJava8-Examples-1.0/onjava/Stack.java000066400000000000000000000011741374004044700175700ustar00rootroot00000000000000// onjava/Stack.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A Stack class built with an ArrayDeque package onjava; import java.util.Deque; import java.util.ArrayDeque; public class Stack { private Deque storage = new ArrayDeque<>(); public void push(T v) { storage.push(v); } public T peek() { return storage.peek(); } public T pop() { return storage.pop(); } public boolean isEmpty() { return storage.isEmpty(); } @Override public String toString() { return storage.toString(); } } OnJava8-Examples-1.0/onjava/Suppliers.java000066400000000000000000000020561374004044700205110ustar00rootroot00000000000000// onjava/Suppliers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A utility to use with Suppliers package onjava; import java.util.*; import java.util.function.*; import java.util.stream.*; public class Suppliers { // Create a collection and fill it: public static > C create(Supplier factory, Supplier gen, int n) { return Stream.generate(gen) .limit(n) .collect(factory, C::add, C::addAll); } // Fill an existing collection: public static > C fill(C coll, Supplier gen, int n) { Stream.generate(gen) .limit(n) .forEach(coll::add); return coll; } // Use an unbound method reference to // produce a more general method: public static H fill(H holder, BiConsumer adder, Supplier gen, int n) { Stream.generate(gen) .limit(n) .forEach(a -> adder.accept(holder, a)); return holder; } } OnJava8-Examples-1.0/onjava/TimedAbort.java000066400000000000000000000015041374004044700205520ustar00rootroot00000000000000// onjava/TimedAbort.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Terminate a program after t seconds package onjava; import java.util.concurrent.*; public class TimedAbort { private volatile boolean restart = true; public TimedAbort(double t, String msg) { CompletableFuture.runAsync(() -> { try { while(restart) { restart = false; TimeUnit.MILLISECONDS .sleep((int)(1000 * t)); } } catch(InterruptedException e) { throw new RuntimeException(e); } System.out.println(msg); System.exit(0); }); } public TimedAbort(double t) { this(t, "TimedAbort " + t); } public void restart() { restart = true; } } OnJava8-Examples-1.0/onjava/Timer.java000066400000000000000000000010311374004044700175730ustar00rootroot00000000000000// onjava/Timer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; import static java.util.concurrent.TimeUnit.*; public class Timer { private long start = System.nanoTime(); public long duration() { return NANOSECONDS.toMillis( System.nanoTime() - start); } public static long duration(Runnable test) { Timer timer = new Timer(); test.run(); return timer.duration(); } } OnJava8-Examples-1.0/onjava/Tuple.java000066400000000000000000000013141374004044700176100ustar00rootroot00000000000000// onjava/Tuple.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Tuple library using type argument inference package onjava; public class Tuple { public static Tuple2 tuple(A a, B b) { return new Tuple2<>(a, b); } public static Tuple3 tuple(A a, B b, C c) { return new Tuple3<>(a, b, c); } public static Tuple4 tuple(A a, B b, C c, D d) { return new Tuple4<>(a, b, c, d); } public static Tuple5 tuple(A a, B b, C c, D d, E e) { return new Tuple5<>(a, b, c, d, e); } } OnJava8-Examples-1.0/onjava/Tuple2.java000066400000000000000000000006741374004044700177020ustar00rootroot00000000000000// onjava/Tuple2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public class Tuple2 { public final A a1; public final B a2; public Tuple2(A a, B b) { a1 = a; a2 = b; } public String rep() { return a1 + ", " + a2; } @Override public String toString() { return "(" + rep() + ")"; } } OnJava8-Examples-1.0/onjava/Tuple3.java000066400000000000000000000006421374004044700176760ustar00rootroot00000000000000// onjava/Tuple3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public class Tuple3 extends Tuple2 { public final C a3; public Tuple3(A a, B b, C c) { super(a, b); a3 = c; } @Override public String rep() { return super.rep() + ", " + a3; } } OnJava8-Examples-1.0/onjava/Tuple4.java000066400000000000000000000006621374004044700177010ustar00rootroot00000000000000// onjava/Tuple4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public class Tuple4 extends Tuple3 { public final D a4; public Tuple4(A a, B b, C c, D d) { super(a, b, c); a4 = d; } @Override public String rep() { return super.rep() + ", " + a4; } } OnJava8-Examples-1.0/onjava/Tuple5.java000066400000000000000000000006761374004044700177070ustar00rootroot00000000000000// onjava/Tuple5.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package onjava; public class Tuple5 extends Tuple4 { public final E a5; public Tuple5(A a, B b, C c, D d, E e) { super(a, b, c, d); a5 = e; } @Override public String rep() { return super.rep() + ", " + a5; } } OnJava8-Examples-1.0/onjava/TypeCounter.java000066400000000000000000000023771374004044700210120ustar00rootroot00000000000000// onjava/TypeCounter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Counts instances of a type family package onjava; import java.util.*; import java.util.stream.*; public class TypeCounter extends HashMap, Integer> { private Class baseType; public TypeCounter(Class baseType) { this.baseType = baseType; } public void count(Object obj) { Class type = obj.getClass(); if(!baseType.isAssignableFrom(type)) throw new RuntimeException( obj + " incorrect type: " + type + ", should be type or subtype of " + baseType); countClass(type); } private void countClass(Class type) { Integer quantity = get(type); put(type, quantity == null ? 1 : quantity + 1); Class superClass = type.getSuperclass(); if(superClass != null && baseType.isAssignableFrom(superClass)) countClass(superClass); } @Override public String toString() { String result = entrySet().stream() .map(pair -> String.format("%s=%s", pair.getKey().getSimpleName(), pair.getValue())) .collect(Collectors.joining(", ")); return "{" + result + "}"; } } OnJava8-Examples-1.0/onjava/atunit/000077500000000000000000000000001374004044700171615ustar00rootroot00000000000000OnJava8-Examples-1.0/onjava/atunit/AtUnit.java000066400000000000000000000134311374004044700212320ustar00rootroot00000000000000// onjava/atunit/AtUnit.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An annotation-based unit-test framework // {java onjava.atunit.AtUnit} package onjava.atunit; import java.lang.reflect.*; import java.io.*; import java.util.*; import java.nio.file.*; import java.util.stream.*; import onjava.*; public class AtUnit implements ProcessFiles.Strategy { static Class testClass; static List failedTests= new ArrayList<>(); static long testsRun = 0; static long failures = 0; public static void main(String[] args) throws Exception { ClassLoader.getSystemClassLoader() .setDefaultAssertionStatus(true); // Enable assert new ProcessFiles(new AtUnit(), "class").start(args); if(failures == 0) System.out.println("OK (" + testsRun + " tests)"); else { System.out.println("(" + testsRun + " tests)"); System.out.println( "\n>>> " + failures + " FAILURE" + (failures > 1 ? "S" : "") + " <<<"); for(String failed : failedTests) System.out.println(" " + failed); } } @Override public void process(File cFile) { try { String cName = ClassNameFinder.thisClass( Files.readAllBytes(cFile.toPath())); if(!cName.startsWith("public:")) return; cName = cName.split(":")[1]; if(!cName.contains(".")) return; // Ignore unpackaged classes testClass = Class.forName(cName); } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } TestMethods testMethods = new TestMethods(); Method creator = null; Method cleanup = null; for(Method m : testClass.getDeclaredMethods()) { testMethods.addIfTestMethod(m); if(creator == null) creator = checkForCreatorMethod(m); if(cleanup == null) cleanup = checkForCleanupMethod(m); } if(testMethods.size() > 0) { if(creator == null) try { if(!Modifier.isPublic(testClass .getDeclaredConstructor() .getModifiers())) { System.out.println("Error: " + testClass + " no-arg constructor must be public"); System.exit(1); } } catch(NoSuchMethodException e) { // Synthesized no-arg constructor; OK } System.out.println(testClass.getName()); } for(Method m : testMethods) { System.out.print(" . " + m.getName() + " "); try { Object testObject = createTestObject(creator); boolean success = false; try { if(m.getReturnType().equals(boolean.class)) success = (Boolean)m.invoke(testObject); else { m.invoke(testObject); success = true; // If no assert fails } } catch(InvocationTargetException e) { // Actual exception is inside e: System.out.println(e.getCause()); } System.out.println(success ? "" : "(failed)"); testsRun++; if(!success) { failures++; failedTests.add(testClass.getName() + ": " + m.getName()); } if(cleanup != null) cleanup.invoke(testObject, testObject); } catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException(e); } } } public static class TestMethods extends ArrayList { void addIfTestMethod(Method m) { if(m.getAnnotation(Test.class) == null) return; if(!(m.getReturnType().equals(boolean.class) || m.getReturnType().equals(void.class))) throw new RuntimeException("@Test method" + " must return boolean or void"); m.setAccessible(true); // If it's private, etc. add(m); } } private static Method checkForCreatorMethod(Method m) { if(m.getAnnotation(TestObjectCreate.class) == null) return null; if(!m.getReturnType().equals(testClass)) throw new RuntimeException("@TestObjectCreate " + "must return instance of Class to be tested"); if((m.getModifiers() & java.lang.reflect.Modifier.STATIC) < 1) throw new RuntimeException("@TestObjectCreate " + "must be static."); m.setAccessible(true); return m; } private static Method checkForCleanupMethod(Method m) { if(m.getAnnotation(TestObjectCleanup.class) == null) return null; if(!m.getReturnType().equals(void.class)) throw new RuntimeException("@TestObjectCleanup " + "must return void"); if((m.getModifiers() & java.lang.reflect.Modifier.STATIC) < 1) throw new RuntimeException("@TestObjectCleanup " + "must be static."); if(m.getParameterTypes().length == 0 || m.getParameterTypes()[0] != testClass) throw new RuntimeException("@TestObjectCleanup " + "must take an argument of the tested type."); m.setAccessible(true); return m; } private static Object createTestObject(Method creator) { if(creator != null) { try { return creator.invoke(testClass); } catch(IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new RuntimeException("Couldn't run " + "@TestObject (creator) method."); } } else { // Use the no-arg constructor: try { return testClass .getConstructor().newInstance(); } catch(InstantiationException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { throw new RuntimeException( "Couldn't create a test object. " + "Try using a @TestObject method."); } } } } OnJava8-Examples-1.0/onjava/atunit/ClassNameFinder.java000066400000000000000000000114111374004044700230200ustar00rootroot00000000000000// onjava/atunit/ClassNameFinder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.atunit.ClassNameFinder} package onjava.atunit; import java.io.*; import java.nio.file.*; import java.util.*; import onjava.*; public class ClassNameFinder { public static String thisClass(byte[] classBytes) { Map offsetTable = new HashMap<>(); Map classNameTable = new HashMap<>(); try { DataInputStream data = new DataInputStream( new ByteArrayInputStream(classBytes)); int magic = data.readInt(); // 0xcafebabe int minorVersion = data.readShort(); int majorVersion = data.readShort(); int constantPoolCount = data.readShort(); int[] constantPool = new int[constantPoolCount]; for(int i = 1; i < constantPoolCount; i++) { int tag = data.read(); // int tableSize; switch(tag) { case 1: // UTF int length = data.readShort(); char[] bytes = new char[length]; for(int k = 0; k < bytes.length; k++) bytes[k] = (char)data.read(); String className = new String(bytes); classNameTable.put(i, className); break; case 5: // LONG case 6: // DOUBLE data.readLong(); // discard 8 bytes i++; // Special skip necessary break; case 7: // CLASS int offset = data.readShort(); offsetTable.put(i, offset); break; case 8: // STRING data.readShort(); // discard 2 bytes break; case 3: // INTEGER case 4: // FLOAT case 9: // FIELD_REF case 10: // METHOD_REF case 11: // INTERFACE_METHOD_REF case 12: // NAME_AND_TYPE case 18: // Invoke Dynamic data.readInt(); // discard 4 bytes break; case 15: // Method Handle data.readByte(); data.readShort(); break; case 16: // Method Type data.readShort(); break; default: throw new RuntimeException("Bad tag " + tag); } } short accessFlags = data.readShort(); String access = (accessFlags & 0x0001) == 0 ? "nonpublic:" : "public:"; int thisClass = data.readShort(); int superClass = data.readShort(); return access + classNameTable.get( offsetTable.get(thisClass)).replace('/', '.'); } catch(IOException | RuntimeException e) { throw new RuntimeException(e); } } // Demonstration: public static void main(String[] args) throws Exception { PathMatcher matcher = FileSystems.getDefault() .getPathMatcher("glob:**/*.class"); // Walk the entire tree: Files.walk(Paths.get(".")) .filter(matcher::matches) .map(p -> { try { return thisClass(Files.readAllBytes(p)); } catch(Exception e) { throw new RuntimeException(e); } }) .filter(s -> s.startsWith("public:")) // .filter(s -> s.indexOf('$') >= 0) .map(s -> s.split(":")[1]) .filter(s -> !s.startsWith("enums.")) .filter(s -> s.contains(".")) .forEach(System.out::println); } } /* Output: onjava.ArrayShow onjava.atunit.AtUnit$TestMethods onjava.atunit.AtUnit onjava.atunit.ClassNameFinder onjava.atunit.Test onjava.atunit.TestObjectCleanup onjava.atunit.TestObjectCreate onjava.atunit.TestProperty onjava.BasicSupplier onjava.CollectionMethodDifferences onjava.ConvertTo onjava.Count$Boolean onjava.Count$Byte onjava.Count$Character onjava.Count$Double onjava.Count$Float onjava.Count$Integer onjava.Count$Long onjava.Count$Pboolean onjava.Count$Pbyte onjava.Count$Pchar onjava.Count$Pdouble onjava.Count$Pfloat onjava.Count$Pint onjava.Count$Plong onjava.Count$Pshort onjava.Count$Short onjava.Count onjava.CountingIntegerList onjava.CountMap onjava.Countries onjava.Enums onjava.FillMap onjava.HTMLColors onjava.MouseClick onjava.Nap onjava.Null onjava.Operations onjava.OSExecute onjava.OSExecuteException onjava.Pair onjava.ProcessFiles$Strategy onjava.ProcessFiles onjava.Rand$Boolean onjava.Rand$Byte onjava.Rand$Character onjava.Rand$Double onjava.Rand$Float onjava.Rand$Integer onjava.Rand$Long onjava.Rand$Pboolean onjava.Rand$Pbyte onjava.Rand$Pchar onjava.Rand$Pdouble onjava.Rand$Pfloat onjava.Rand$Pint onjava.Rand$Plong onjava.Rand$Pshort onjava.Rand$Short onjava.Rand$String onjava.Rand onjava.Range onjava.Repeat onjava.RmDir onjava.Sets onjava.Stack onjava.Suppliers onjava.TimedAbort onjava.Timer onjava.Tuple onjava.Tuple2 onjava.Tuple3 onjava.Tuple4 onjava.Tuple5 onjava.TypeCounter */ OnJava8-Examples-1.0/onjava/atunit/Test.java000066400000000000000000000005371374004044700207500ustar00rootroot00000000000000// onjava/atunit/Test.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The @Test tag package onjava.atunit; import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface Test {} OnJava8-Examples-1.0/onjava/atunit/TestObjectCleanup.java000066400000000000000000000006141374004044700234030ustar00rootroot00000000000000// onjava/atunit/TestObjectCleanup.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The @Unit @TestObjectCleanup tag package onjava.atunit; import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface TestObjectCleanup {} OnJava8-Examples-1.0/onjava/atunit/TestObjectCreate.java000066400000000000000000000006111374004044700232140ustar00rootroot00000000000000// onjava/atunit/TestObjectCreate.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The @Unit @TestObjectCreate tag package onjava.atunit; import java.lang.annotation.*; @Target(ElementType.METHOD) @Retention(RetentionPolicy.RUNTIME) public @interface TestObjectCreate {} OnJava8-Examples-1.0/onjava/atunit/TestProperty.java000066400000000000000000000007121374004044700225100ustar00rootroot00000000000000// onjava/atunit/TestProperty.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The @Unit @TestProperty tag package onjava.atunit; import java.lang.annotation.*; // Both fields and methods can be tagged as properties: @Target({ElementType.FIELD, ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface TestProperty {} OnJava8-Examples-1.0/operators/000077500000000000000000000000001374004044700164155ustar00rootroot00000000000000OnJava8-Examples-1.0/operators/AllOps.java000066400000000000000000000167611374004044700204650ustar00rootroot00000000000000// operators/AllOps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Tests all operators on all primitive data types // to show which ones are accepted by the Java compiler public class AllOps { // To accept the results of a boolean test: void f(boolean b) {} void boolTest(boolean x, boolean y) { // Arithmetic operators: //- x = x * y; //- x = x / y; //- x = x % y; //- x = x + y; //- x = x - y; //- x++; //- x--; //- x = +y; //- x = -y; // Relational and logical: //- f(x > y); //- f(x >= y); //- f(x < y); //- f(x <= y); f(x == y); f(x != y); f(!y); x = x && y; x = x || y; // Bitwise operators: //- x = ~y; x = x & y; x = x | y; x = x ^ y; //- x = x << 1; //- x = x >> 1; //- x = x >>> 1; // Compound assignment: //- x += y; //- x -= y; //- x *= y; //- x /= y; //- x %= y; //- x <<= 1; //- x >>= 1; //- x >>>= 1; x &= y; x ^= y; x |= y; // Casting: //- char c = (char)x; //- byte b = (byte)x; //- short s = (short)x; //- int i = (int)x; //- long l = (long)x; //- float f = (float)x; //- double d = (double)x; } void charTest(char x, char y) { // Arithmetic operators: x = (char)(x * y); x = (char)(x / y); x = (char)(x % y); x = (char)(x + y); x = (char)(x - y); x++; x--; x = (char) + y; x = (char) - y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: x= (char)~y; x = (char)(x & y); x = (char)(x | y); x = (char)(x ^ y); x = (char)(x << 1); x = (char)(x >> 1); x = (char)(x >>> 1); // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; // Casting: //- boolean bl = (boolean)x; byte b = (byte)x; short s = (short)x; int i = (int)x; long l = (long)x; float f = (float)x; double d = (double)x; } void byteTest(byte x, byte y) { // Arithmetic operators: x = (byte)(x* y); x = (byte)(x / y); x = (byte)(x % y); x = (byte)(x + y); x = (byte)(x - y); x++; x--; x = (byte) + y; x = (byte) - y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: x = (byte)~y; x = (byte)(x & y); x = (byte)(x | y); x = (byte)(x ^ y); x = (byte)(x << 1); x = (byte)(x >> 1); x = (byte)(x >>> 1); // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; // Casting: //- boolean bl = (boolean)x; char c = (char)x; short s = (short)x; int i = (int)x; long l = (long)x; float f = (float)x; double d = (double)x; } void shortTest(short x, short y) { // Arithmetic operators: x = (short)(x * y); x = (short)(x / y); x = (short)(x % y); x = (short)(x + y); x = (short)(x - y); x++; x--; x = (short) + y; x = (short) - y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: x = (short) ~ y; x = (short)(x & y); x = (short)(x | y); x = (short)(x ^ y); x = (short)(x << 1); x = (short)(x >> 1); x = (short)(x >>> 1); // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; // Casting: //- boolean bl = (boolean)x; char c = (char)x; byte b = (byte)x; int i = (int)x; long l = (long)x; float f = (float)x; double d = (double)x; } void intTest(int x, int y) { // Arithmetic operators: x = x * y; x = x / y; x = x % y; x = x + y; x = x - y; x++; x--; x = +y; x = -y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: x = ~y; x = x & y; x = x | y; x = x ^ y; x = x << 1; x = x >> 1; x = x >>> 1; // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; // Casting: //- boolean bl = (boolean)x; char c = (char)x; byte b = (byte)x; short s = (short)x; long l = (long)x; float f = (float)x; double d = (double)x; } void longTest(long x, long y) { // Arithmetic operators: x = x * y; x = x / y; x = x % y; x = x + y; x = x - y; x++; x--; x = +y; x = -y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: x = ~y; x = x & y; x = x | y; x = x ^ y; x = x << 1; x = x >> 1; x = x >>> 1; // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; x <<= 1; x >>= 1; x >>>= 1; x &= y; x ^= y; x |= y; // Casting: //- boolean bl = (boolean)x; char c = (char)x; byte b = (byte)x; short s = (short)x; int i = (int)x; float f = (float)x; double d = (double)x; } void floatTest(float x, float y) { // Arithmetic operators: x = x * y; x = x / y; x = x % y; x = x + y; x = x - y; x++; x--; x = +y; x = -y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: //- x = ~y; //- x = x & y; //- x = x | y; //- x = x ^ y; //- x = x << 1; //- x = x >> 1; //- x = x >>> 1; // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; //- x <<= 1; //- x >>= 1; //- x >>>= 1; //- x &= y; //- x ^= y; //- x |= y; // Casting: //- boolean bl = (boolean)x; char c = (char)x; byte b = (byte)x; short s = (short)x; int i = (int)x; long l = (long)x; double d = (double)x; } void doubleTest(double x, double y) { // Arithmetic operators: x = x * y; x = x / y; x = x % y; x = x + y; x = x - y; x++; x--; x = +y; x = -y; // Relational and logical: f(x > y); f(x >= y); f(x < y); f(x <= y); f(x == y); f(x != y); //- f(!x); //- f(x && y); //- f(x || y); // Bitwise operators: //- x = ~y; //- x = x & y; //- x = x | y; //- x = x ^ y; //- x = x << 1; //- x = x >> 1; //- x = x >>> 1; // Compound assignment: x += y; x -= y; x *= y; x /= y; x %= y; //- x <<= 1; //- x >>= 1; //- x >>>= 1; //- x &= y; //- x ^= y; //- x |= y; // Casting: //- boolean bl = (boolean)x; char c = (char)x; byte b = (byte)x; short s = (short)x; int i = (int)x; long l = (long)x; float f = (float)x; } } OnJava8-Examples-1.0/operators/Assignment.java000066400000000000000000000014651374004044700213760ustar00rootroot00000000000000// operators/Assignment.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Assignment with objects is a bit tricky class Tank { int level; } public class Assignment { public static void main(String[] args) { Tank t1 = new Tank(); Tank t2 = new Tank(); t1.level = 9; t2.level = 47; System.out.println("1: t1.level: " + t1.level + ", t2.level: " + t2.level); t1 = t2; System.out.println("2: t1.level: " + t1.level + ", t2.level: " + t2.level); t1.level = 27; System.out.println("3: t1.level: " + t1.level + ", t2.level: " + t2.level); } } /* Output: 1: t1.level: 9, t2.level: 47 2: t1.level: 47, t2.level: 47 3: t1.level: 27, t2.level: 27 */ OnJava8-Examples-1.0/operators/AutoInc.java000066400000000000000000000013001374004044700206140ustar00rootroot00000000000000// operators/AutoInc.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates the ++ and -- operators public class AutoInc { public static void main(String[] args) { int i = 1; System.out.println("i: " + i); System.out.println("++i: " + ++i); // Pre-increment System.out.println("i++: " + i++); // Post-increment System.out.println("i: " + i); System.out.println("--i: " + --i); // Pre-decrement System.out.println("i--: " + i--); // Post-decrement System.out.println("i: " + i); } } /* Output: i: 1 ++i: 2 i++: 2 i: 3 --i: 2 i--: 2 i: 1 */ OnJava8-Examples-1.0/operators/BitManipulation.java000066400000000000000000000060651374004044700223660ustar00rootroot00000000000000// operators/BitManipulation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using the bitwise operators import java.util.*; public class BitManipulation { public static void main(String[] args) { Random rand = new Random(47); int i = rand.nextInt(); int j = rand.nextInt(); printBinaryInt("-1", -1); printBinaryInt("+1", +1); int maxpos = 2147483647; printBinaryInt("maxpos", maxpos); int maxneg = -2147483648; printBinaryInt("maxneg", maxneg); printBinaryInt("i", i); printBinaryInt("~i", ~i); printBinaryInt("-i", -i); printBinaryInt("j", j); printBinaryInt("i & j", i & j); printBinaryInt("i | j", i | j); printBinaryInt("i ^ j", i ^ j); printBinaryInt("i << 5", i << 5); printBinaryInt("i >> 5", i >> 5); printBinaryInt("(~i) >> 5", (~i) >> 5); printBinaryInt("i >>> 5", i >>> 5); printBinaryInt("(~i) >>> 5", (~i) >>> 5); long l = rand.nextLong(); long m = rand.nextLong(); printBinaryLong("-1L", -1L); printBinaryLong("+1L", +1L); long ll = 9223372036854775807L; printBinaryLong("maxpos", ll); long lln = -9223372036854775808L; printBinaryLong("maxneg", lln); printBinaryLong("l", l); printBinaryLong("~l", ~l); printBinaryLong("-l", -l); printBinaryLong("m", m); printBinaryLong("l & m", l & m); printBinaryLong("l | m", l | m); printBinaryLong("l ^ m", l ^ m); printBinaryLong("l << 5", l << 5); printBinaryLong("l >> 5", l >> 5); printBinaryLong("(~l) >> 5", (~l) >> 5); printBinaryLong("l >>> 5", l >>> 5); printBinaryLong("(~l) >>> 5", (~l) >>> 5); } static void printBinaryInt(String s, int i) { System.out.println( s + ", int: " + i + ", binary:\n " + Integer.toBinaryString(i)); } static void printBinaryLong(String s, long l) { System.out.println( s + ", long: " + l + ", binary:\n " + Long.toBinaryString(l)); } } /* Output: (First 32 Lines) -1, int: -1, binary: 11111111111111111111111111111111 +1, int: 1, binary: 1 maxpos, int: 2147483647, binary: 1111111111111111111111111111111 maxneg, int: -2147483648, binary: 10000000000000000000000000000000 i, int: -1172028779, binary: 10111010001001000100001010010101 ~i, int: 1172028778, binary: 1000101110110111011110101101010 -i, int: 1172028779, binary: 1000101110110111011110101101011 j, int: 1717241110, binary: 1100110010110110000010100010110 i & j, int: 570425364, binary: 100010000000000000000000010100 i | j, int: -25213033, binary: 11111110011111110100011110010111 i ^ j, int: -595638397, binary: 11011100011111110100011110000011 i << 5, int: 1149784736, binary: 1000100100010000101001010100000 i >> 5, int: -36625900, binary: 11111101110100010010001000010100 (~i) >> 5, int: 36625899, binary: 10001011101101110111101011 i >>> 5, int: 97591828, binary: 101110100010010001000010100 (~i) >>> 5, int: 36625899, binary: 10001011101101110111101011 ... */ OnJava8-Examples-1.0/operators/Bool.java000066400000000000000000000024521374004044700201560ustar00rootroot00000000000000// operators/Bool.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Relational and logical operators import java.util.*; public class Bool { public static void main(String[] args) { Random rand = new Random(47); int i = rand.nextInt(100); int j = rand.nextInt(100); System.out.println("i = " + i); System.out.println("j = " + j); System.out.println("i > j is " + (i > j)); System.out.println("i < j is " + (i < j)); System.out.println("i >= j is " + (i >= j)); System.out.println("i <= j is " + (i <= j)); System.out.println("i == j is " + (i == j)); System.out.println("i != j is " + (i != j)); // Treating an int as a boolean is not legal Java: //- System.out.println("i && j is " + (i && j)); //- System.out.println("i || j is " + (i || j)); //- System.out.println("!i is " + !i); System.out.println("(i < 10) && (j < 10) is " + ((i < 10) && (j < 10)) ); System.out.println("(i < 10) || (j < 10) is " + ((i < 10) || (j < 10)) ); } } /* Output: i = 58 j = 55 i > j is true i < j is false i >= j is true i <= j is false i == j is false i != j is true (i < 10) && (j < 10) is false (i < 10) || (j < 10) is false */ OnJava8-Examples-1.0/operators/Casting.java000066400000000000000000000007241374004044700206530ustar00rootroot00000000000000// operators/Casting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Casting { public static void main(String[] args) { int i = 200; long lng = (long)i; lng = i; // "Widening," so a cast is not required long lng2 = (long)200; lng2 = 200; // A "narrowing conversion": i = (int)lng2; // Cast required } } OnJava8-Examples-1.0/operators/CastingNumbers.java000066400000000000000000000013111374004044700222000ustar00rootroot00000000000000// operators/CastingNumbers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // What happens when you cast a float // or double to an integral value? public class CastingNumbers { public static void main(String[] args) { double above = 0.7, below = 0.4; float fabove = 0.7f, fbelow = 0.4f; System.out.println("(int)above: " + (int)above); System.out.println("(int)below: " + (int)below); System.out.println("(int)fabove: " + (int)fabove); System.out.println("(int)fbelow: " + (int)fbelow); } } /* Output: (int)above: 0 (int)below: 0 (int)fabove: 0 (int)fbelow: 0 */ OnJava8-Examples-1.0/operators/EqualsMethod.java000066400000000000000000000005631374004044700216570ustar00rootroot00000000000000// operators/EqualsMethod.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class EqualsMethod { public static void main(String[] args) { Integer n1 = 47; Integer n2 = 47; System.out.println(n1.equals(n2)); } } /* Output: true */ OnJava8-Examples-1.0/operators/EqualsMethod2.java000066400000000000000000000007431374004044700217410ustar00rootroot00000000000000// operators/EqualsMethod2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Default equals() does not compare contents class Value { int i; } public class EqualsMethod2 { public static void main(String[] args) { Value v1 = new Value(); Value v2 = new Value(); v1.i = v2.i = 100; System.out.println(v1.equals(v2)); } } /* Output: false */ OnJava8-Examples-1.0/operators/Equivalence.java000066400000000000000000000006241374004044700215230ustar00rootroot00000000000000// operators/Equivalence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Equivalence { public static void main(String[] args) { Integer n1 = 47; Integer n2 = 47; System.out.println(n1 == n2); System.out.println(n1 != n2); } } /* Output: true false */ OnJava8-Examples-1.0/operators/Exponents.java000066400000000000000000000011401374004044700212370ustar00rootroot00000000000000// operators/Exponents.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // "e" means "10 to the power." public class Exponents { public static void main(String[] args) { // Uppercase and lowercase 'e' are the same: float expFloat = 1.39e-43f; expFloat = 1.39E-43f; System.out.println(expFloat); double expDouble = 47e47d; // 'd' is optional double expDouble2 = 47e47; // Automatically double System.out.println(expDouble); } } /* Output: 1.39E-43 4.7E48 */ OnJava8-Examples-1.0/operators/Literals.java000066400000000000000000000036231374004044700210430ustar00rootroot00000000000000// operators/Literals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Literals { public static void main(String[] args) { int i1 = 0x2f; // Hexadecimal (lowercase) System.out.println( "i1: " + Integer.toBinaryString(i1)); int i2 = 0X2F; // Hexadecimal (uppercase) System.out.println( "i2: " + Integer.toBinaryString(i2)); int i3 = 0177; // Octal (leading zero) System.out.println( "i3: " + Integer.toBinaryString(i3)); char c = 0xffff; // max char hex value System.out.println( "c: " + Integer.toBinaryString(c)); byte b = 0x7f; // max byte hex value 10101111; System.out.println( "b: " + Integer.toBinaryString(b)); short s = 0x7fff; // max short hex value System.out.println( "s: " + Integer.toBinaryString(s)); long n1 = 200L; // long suffix long n2 = 200l; // long suffix (can be confusing) long n3 = 200; // Java 7 Binary Literals: byte blb = (byte)0b00110101; System.out.println( "blb: " + Integer.toBinaryString(blb)); short bls = (short)0B0010111110101111; System.out.println( "bls: " + Integer.toBinaryString(bls)); int bli = 0b00101111101011111010111110101111; System.out.println( "bli: " + Integer.toBinaryString(bli)); long bll = 0b00101111101011111010111110101111; System.out.println( "bll: " + Long.toBinaryString(bll)); float f1 = 1; float f2 = 1F; // float suffix float f3 = 1f; // float suffix double d1 = 1d; // double suffix double d2 = 1D; // double suffix // (Hex and Octal also work with long) } } /* Output: i1: 101111 i2: 101111 i3: 1111111 c: 1111111111111111 b: 1111111 s: 111111111111111 blb: 110101 bls: 10111110101111 bli: 101111101011111010111110101111 bll: 101111101011111010111110101111 */ OnJava8-Examples-1.0/operators/MathOps.java000066400000000000000000000035551374004044700206430ustar00rootroot00000000000000// operators/MathOps.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The mathematical operators import java.util.*; public class MathOps { public static void main(String[] args) { // Create a seeded random number generator: Random rand = new Random(47); int i, j, k; // Choose value from 1 to 100: j = rand.nextInt(100) + 1; System.out.println("j : " + j); k = rand.nextInt(100) + 1; System.out.println("k : " + k); i = j + k; System.out.println("j + k : " + i); i = j - k; System.out.println("j - k : " + i); i = k / j; System.out.println("k / j : " + i); i = k * j; System.out.println("k * j : " + i); i = k % j; System.out.println("k % j : " + i); j %= k; System.out.println("j %= k : " + j); // Floating-point number tests: float u, v, w; // Applies to doubles, too v = rand.nextFloat(); System.out.println("v : " + v); w = rand.nextFloat(); System.out.println("w : " + w); u = v + w; System.out.println("v + w : " + u); u = v - w; System.out.println("v - w : " + u); u = v * w; System.out.println("v * w : " + u); u = v / w; System.out.println("v / w : " + u); // The following also works for char, // byte, short, int, long, and double: u += v; System.out.println("u += v : " + u); u -= v; System.out.println("u -= v : " + u); u *= v; System.out.println("u *= v : " + u); u /= v; System.out.println("u /= v : " + u); } } /* Output: j : 59 k : 56 j + k : 115 j - k : 3 k / j : 0 k * j : 3304 k % j : 56 j %= k : 3 v : 0.5309454 w : 0.0534122 v + w : 0.5843576 v - w : 0.47753322 v * w : 0.028358962 v / w : 9.940527 u += v : 10.471473 u -= v : 9.940527 u *= v : 5.2778773 u /= v : 9.940527 */ OnJava8-Examples-1.0/operators/Overflow.java000066400000000000000000000007471374004044700210730ustar00rootroot00000000000000// operators/Overflow.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Surprise! Java lets you overflow public class Overflow { public static void main(String[] args) { int big = Integer.MAX_VALUE; System.out.println("big = " + big); int bigger = big * 4; System.out.println("bigger = " + bigger); } } /* Output: big = 2147483647 bigger = -4 */ OnJava8-Examples-1.0/operators/PassObject.java000066400000000000000000000011041374004044700213110ustar00rootroot00000000000000// operators/PassObject.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Passing objects to methods might not be // what you're used to class Letter { char c; } public class PassObject { static void f(Letter y) { y.c = 'z'; } public static void main(String[] args) { Letter x = new Letter(); x.c = 'a'; System.out.println("1: x.c: " + x.c); f(x); System.out.println("2: x.c: " + x.c); } } /* Output: 1: x.c: a 2: x.c: z */ OnJava8-Examples-1.0/operators/Precedence.java000066400000000000000000000007461374004044700213240ustar00rootroot00000000000000// operators/Precedence.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Precedence { public static void main(String[] args) { int x = 1, y = 2, z = 3; int a = x + y - 2/2 + z; // [1] int b = x + (y - 2)/(2 + z); // [2] System.out.println("a = " + a); System.out.println("b = " + b); } } /* Output: a = 5 b = 1 */ OnJava8-Examples-1.0/operators/RoundingNumbers.java000066400000000000000000000014211374004044700223770ustar00rootroot00000000000000// operators/RoundingNumbers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Rounding floats and doubles public class RoundingNumbers { public static void main(String[] args) { double above = 0.7, below = 0.4; float fabove = 0.7f, fbelow = 0.4f; System.out.println( "Math.round(above): " + Math.round(above)); System.out.println( "Math.round(below): " + Math.round(below)); System.out.println( "Math.round(fabove): " + Math.round(fabove)); System.out.println( "Math.round(fbelow): " + Math.round(fbelow)); } } /* Output: Math.round(above): 1 Math.round(below): 0 Math.round(fabove): 1 Math.round(fbelow): 0 */ OnJava8-Examples-1.0/operators/ShortCircuit.java000066400000000000000000000016721374004044700217100ustar00rootroot00000000000000// operators/ShortCircuit.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Short-circuiting behavior with logical operators public class ShortCircuit { static boolean test1(int val) { System.out.println("test1(" + val + ")"); System.out.println("result: " + (val < 1)); return val < 1; } static boolean test2(int val) { System.out.println("test2(" + val + ")"); System.out.println("result: " + (val < 2)); return val < 2; } static boolean test3(int val) { System.out.println("test3(" + val + ")"); System.out.println("result: " + (val < 3)); return val < 3; } public static void main(String[] args) { boolean b = test1(0) && test2(2) && test3(2); System.out.println("expression is " + b); } } /* Output: test1(0) result: true test2(2) result: false expression is false */ OnJava8-Examples-1.0/operators/StringOperators.java000066400000000000000000000012271374004044700224270ustar00rootroot00000000000000// operators/StringOperators.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class StringOperators { public static void main(String[] args) { int x = 0, y = 1, z = 2; String s = "x, y, z "; System.out.println(s + x + y + z); // Converts x to a String: System.out.println(x + " " + s); s += "(summed) = "; // Concatenation operator System.out.println(s + (x + y + z)); // Shorthand for Integer.toString(): System.out.println("" + x); } } /* Output: x, y, z 012 0 x, y, z x, y, z (summed) = 3 0 */ OnJava8-Examples-1.0/operators/TernaryIfElse.java000066400000000000000000000012031374004044700217700ustar00rootroot00000000000000// operators/TernaryIfElse.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class TernaryIfElse { static int ternary(int i) { return i < 10 ? i * 100 : i * 10; } static int standardIfElse(int i) { if(i < 10) return i * 100; else return i * 10; } public static void main(String[] args) { System.out.println(ternary(9)); System.out.println(ternary(10)); System.out.println(standardIfElse(9)); System.out.println(standardIfElse(10)); } } /* Output: 900 100 900 100 */ OnJava8-Examples-1.0/operators/URShift.java000066400000000000000000000024511374004044700206060ustar00rootroot00000000000000// operators/URShift.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Test of unsigned right shift public class URShift { public static void main(String[] args) { int i = -1; System.out.println(Integer.toBinaryString(i)); i >>>= 10; System.out.println(Integer.toBinaryString(i)); long l = -1; System.out.println(Long.toBinaryString(l)); l >>>= 10; System.out.println(Long.toBinaryString(l)); short s = -1; System.out.println(Integer.toBinaryString(s)); s >>>= 10; System.out.println(Integer.toBinaryString(s)); byte b = -1; System.out.println(Integer.toBinaryString(b)); b >>>= 10; System.out.println(Integer.toBinaryString(b)); b = -1; System.out.println(Integer.toBinaryString(b)); System.out.println(Integer.toBinaryString(b>>>10)); } } /* Output: 11111111111111111111111111111111 1111111111111111111111 1111111111111111111111111111111111111111111111111111111 111111111 111111111111111111111111111111111111111111111111111111 11111111111111111111111111111111 11111111111111111111111111111111 11111111111111111111111111111111 11111111111111111111111111111111 11111111111111111111111111111111 1111111111111111111111 */ OnJava8-Examples-1.0/operators/Underscores.java000066400000000000000000000011721374004044700215550ustar00rootroot00000000000000// operators/Underscores.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Underscores { public static void main(String[] args) { double d = 341_435_936.445_667; System.out.println(d); int bin = 0b0010_1111_1010_1111_1010_1111_1010_1111; System.out.println(Integer.toBinaryString(bin)); System.out.printf("%x%n", bin); // [1] long hex = 0x7f_e9_b7_aa; System.out.printf("%x%n", hex); } } /* Output: 3.41435936445667E8 101111101011111010111110101111 2fafafaf 7fe9b7aa */ OnJava8-Examples-1.0/patterns/000077500000000000000000000000001374004044700162375ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/BoxObserver.java000066400000000000000000000051321374004044700213430ustar00rootroot00000000000000// patterns/BoxObserver.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of Observer pattern using // Java's built-in observer classes. // {ExcludeFromGradle} // Won't work under WSL2 import javax.swing.*; import java.awt.*; import java.awt.event.*; import java.util.*; import onjava.*; import onjava.MouseClick; // You must inherit a new type of Observable: @SuppressWarnings("deprecation") class BoxObservable extends Observable { @Override public void notifyObservers(Object b) { // Otherwise it won't propagate changes: setChanged(); super.notifyObservers(b); } } @SuppressWarnings("deprecation") public class BoxObserver extends JFrame { Observable notifier = new BoxObservable(); public BoxObserver(int grid) { setTitle("Demonstrates Observer pattern"); Container cp = getContentPane(); cp.setLayout(new GridLayout(grid, grid)); for(int x = 0; x < grid; x++) for(int y = 0; y < grid; y++) cp.add(new OCBox(x, y, notifier)); } public static void main(String[] args) { // For automated test runs: // new TimedAbort(4); int grid = 8; if(args.length > 0) grid = Integer.parseInt(args[0]); JFrame f = new BoxObserver(grid); f.setSize(500, 400); f.setVisible(true); f.setDefaultCloseOperation(DISPOSE_ON_CLOSE); } } @SuppressWarnings("deprecation") class OCBox extends JPanel implements Observer { Observable notifier; int x, y; // Locations in grid Color cColor = newColor(); static final Color[] COLORS = { Color.black, Color.blue, Color.cyan, Color.darkGray, Color.gray, Color.green, Color.lightGray, Color.magenta, Color.orange, Color.pink, Color.red, Color.white, Color.yellow }; static Color newColor() { return COLORS[ (int)(Math.random() * COLORS.length) ]; } OCBox(int x, int y, Observable notifier) { this.x = x; this.y = y; notifier.addObserver(this); this.notifier = notifier; addMouseListener((MouseClick) e -> notifier.notifyObservers(OCBox.this)); } @Override public void paintComponent(Graphics g) { super.paintComponent(g); g.setColor(cColor); Dimension s = getSize(); g.fillRect(0, 0, s.width, s.height); } @Override public void update(Observable o, Object arg) { OCBox clicked = (OCBox)arg; if(nextTo(clicked)) { cColor = clicked.cColor; repaint(); } } private boolean nextTo(OCBox b) { return Math.abs(x - b.x) <= 1 && Math.abs(y - b.y) <= 1; } } OnJava8-Examples-1.0/patterns/CommandPattern.java000066400000000000000000000010671374004044700220220ustar00rootroot00000000000000// patterns/CommandPattern.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class CommandPattern { public static void main(String[] args) { List macro = Arrays.asList( () -> System.out.print("Hello "), () -> System.out.print("World! "), () -> System.out.print("I'm the command pattern!") ); macro.forEach(Runnable::run); } } /* Output: Hello World! I'm the command pattern! */ OnJava8-Examples-1.0/patterns/Facade.java000066400000000000000000000013041374004044700202430ustar00rootroot00000000000000// patterns/Facade.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class A { A(int x) {} } class B { B(long x) {} } class C { C(double x) {} } // Other classes that aren't exposed by the // facade go here ... public class Facade { static A makeA(int x) { return new A(x); } static B makeB(long x) { return new B(x); } static C makeC(double x) { return new C(x); } public static void main(String[] args) { // The client programmer gets the objects // by calling the static methods: A a = Facade.makeA(1); B b = Facade.makeB(1); C c = Facade.makeC(1.0); } } OnJava8-Examples-1.0/patterns/PaperScissorsRock.java000066400000000000000000000056141374004044700225270ustar00rootroot00000000000000// patterns/PaperScissorsRock.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of multiple dispatching import java.util.*; import java.util.function.*; import java.util.stream.*; import onjava.*; import static onjava.Tuple.*; enum Outcome { WIN, LOSE, DRAW } interface Item { Outcome compete(Item it); Outcome eval(Paper p); Outcome eval(Scissors s); Outcome eval(Rock r); } class Paper implements Item { @Override public Outcome compete(Item it) { return it.eval(this); } @Override public Outcome eval(Paper p) { return Outcome.DRAW; } @Override public Outcome eval(Scissors s) { return Outcome.WIN; } @Override public Outcome eval(Rock r) { return Outcome.LOSE; } @Override public String toString() { return "Paper"; } } class Scissors implements Item { @Override public Outcome compete(Item it) { return it.eval(this); } @Override public Outcome eval(Paper p) { return Outcome.LOSE; } @Override public Outcome eval(Scissors s) { return Outcome.DRAW; } @Override public Outcome eval(Rock r) { return Outcome.WIN; } @Override public String toString() { return "Scissors"; } } class Rock implements Item { @Override public Outcome compete(Item it) { return it.eval(this); } @Override public Outcome eval(Paper p) { return Outcome.WIN; } @Override public Outcome eval(Scissors s) { return Outcome.LOSE; } @Override public Outcome eval(Rock r) { return Outcome.DRAW; } @Override public String toString() { return "Rock"; } } class ItemFactory { static List> items = Arrays.asList( Scissors::new, Paper::new, Rock::new); static final int SZ = items.size(); private static SplittableRandom rand = new SplittableRandom(47); public static Item newItem() { return items.get(rand.nextInt(SZ)).get(); } public static Tuple2 newPair() { return tuple(newItem(), newItem()); } } class Compete { public static Outcome match(Tuple2 p) { System.out.print(p.a1 + " -> " + p.a2 + " : "); return p.a1.compete(p.a2); } } public class PaperScissorsRock { public static void main(String[] args) { Stream.generate(ItemFactory::newPair) .limit(20) .map(Compete::match) .forEach(System.out::println); } } /* Output: Scissors -> Rock : LOSE Scissors -> Paper : WIN Rock -> Paper : LOSE Rock -> Rock : DRAW Rock -> Paper : LOSE Paper -> Scissors : LOSE Rock -> Paper : LOSE Scissors -> Scissors : DRAW Scissors -> Rock : LOSE Scissors -> Paper : WIN Scissors -> Rock : LOSE Paper -> Scissors : LOSE Rock -> Rock : DRAW Scissors -> Scissors : DRAW Paper -> Paper : DRAW Scissors -> Paper : WIN Scissors -> Rock : LOSE Scissors -> Paper : WIN Rock -> Paper : LOSE Rock -> Scissors : WIN */ OnJava8-Examples-1.0/patterns/ProxyDemo.java000066400000000000000000000021131374004044700210250ustar00rootroot00000000000000// patterns/ProxyDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple demonstration of the Proxy pattern interface ProxyBase { void f(); void g(); void h(); } class Proxy implements ProxyBase { private ProxyBase implementation; Proxy() { implementation = new Implementation(); } // Pass method calls to the implementation: @Override public void f() { implementation.f(); } @Override public void g() { implementation.g(); } @Override public void h() { implementation.h(); } } class Implementation implements ProxyBase { public void f() { System.out.println("Implementation.f()"); } public void g() { System.out.println("Implementation.g()"); } public void h() { System.out.println("Implementation.h()"); } } public class ProxyDemo { public static void main(String[] args) { Proxy p = new Proxy(); p.f(); p.g(); p.h(); } } /* Output: Implementation.f() Implementation.g() Implementation.h() */ OnJava8-Examples-1.0/patterns/ShapeFactory1.java000066400000000000000000000016531374004044700215600ustar00rootroot00000000000000// patterns/ShapeFactory1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A simple static factory method import java.util.*; import java.util.stream.*; import patterns.shapes.*; public class ShapeFactory1 implements FactoryMethod { public Shape create(String type) { switch(type) { case "Circle": return new Circle(); case "Square": return new Square(); case "Triangle": return new Triangle(); default: throw new BadShapeCreation(type); } } public static void main(String[] args) { FactoryTest.test(new ShapeFactory1()); } } /* Output: Circle[0] draw Circle[0] erase Square[1] draw Square[1] erase Triangle[2] draw Triangle[2] erase Square[3] draw Square[3] erase Circle[4] draw Circle[4] erase Circle[5] draw Circle[5] erase Triangle[6] draw Triangle[6] erase */ OnJava8-Examples-1.0/patterns/ShapeFactory2.java000066400000000000000000000024301374004044700215530ustar00rootroot00000000000000// patterns/ShapeFactory2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.lang.reflect.*; import java.util.stream.*; import patterns.shapes.*; public class ShapeFactory2 implements FactoryMethod { Map factories = new HashMap<>(); static Constructor load(String id) { System.out.println("loading " + id); try { return Class.forName("patterns.shapes." + id) .getConstructor(); } catch(ClassNotFoundException | NoSuchMethodException e) { throw new BadShapeCreation(id); } } public Shape create(String id) { try { return (Shape)factories .computeIfAbsent(id, ShapeFactory2::load) .newInstance(); } catch(Exception e) { throw new BadShapeCreation(id); } } public static void main(String[] args) { FactoryTest.test(new ShapeFactory2()); } } /* Output: loading Circle Circle[0] draw Circle[0] erase loading Square Square[1] draw Square[1] erase loading Triangle Triangle[2] draw Triangle[2] erase Square[3] draw Square[3] erase Circle[4] draw Circle[4] erase Circle[5] draw Circle[5] erase Triangle[6] draw Triangle[6] erase */ OnJava8-Examples-1.0/patterns/ShapeFactory3.java000066400000000000000000000022431374004044700215560ustar00rootroot00000000000000// patterns/ShapeFactory3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Polymorphic factory methods import java.util.*; import java.util.function.*; import java.util.stream.*; import patterns.shapes.*; interface PolymorphicFactory { Shape create(); } class RandomShapes implements Supplier { private final PolymorphicFactory[] factories; private Random rand = new Random(42); RandomShapes(PolymorphicFactory... factories) { this.factories = factories; } public Shape get() { return factories[ rand.nextInt(factories.length)].create(); } } public class ShapeFactory3 { public static void main(String[] args) { RandomShapes rs = new RandomShapes( Circle::new, Square::new, Triangle::new ); Stream.generate(rs) .limit(6) .peek(Shape::draw) .peek(Shape::erase) .count(); } } /* Output: Triangle[0] draw Triangle[0] erase Circle[1] draw Circle[1] erase Circle[2] draw Circle[2] erase Triangle[3] draw Triangle[3] erase Circle[4] draw Circle[4] erase Square[5] draw Square[5] erase */ OnJava8-Examples-1.0/patterns/SingletonPattern.java000066400000000000000000000026351374004044700224100ustar00rootroot00000000000000// patterns/SingletonPattern.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface Resource { int getValue(); void setValue(int x); } // This isn't inherited from a Cloneable // base class and cloneability isn't added so // making it final prevents cloneability from // being added through inheritance. This also // implements thread-safe lazy initialization: final class Singleton { private static final class ResourceImpl implements Resource { private int i; private ResourceImpl(int i) { this.i = i; } public synchronized int getValue() { return i; } public synchronized void setValue(int x) { i = x; } } private static class ResourceHolder { private static Resource resource = new ResourceImpl(47); } public static Resource getResource() { return ResourceHolder.resource; } } public class SingletonPattern { public static void main(String[] args) { Resource r = Singleton.getResource(); System.out.println(r.getValue()); Resource s2 = Singleton.getResource(); s2.setValue(9); System.out.println(r.getValue()); try { // Can't do this: compile-time error. // Singleton s3 = (Singleton)s2.clone(); } catch(Exception e) { throw new RuntimeException(e); } } } /* Output: 47 9 */ OnJava8-Examples-1.0/patterns/StateDemo.java000066400000000000000000000035151374004044700207730ustar00rootroot00000000000000// patterns/StateDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple demonstration of the State pattern interface StateBase { void f(); void g(); void h(); void changeImp(StateBase newImp); } class State implements StateBase { private StateBase implementation; State(StateBase imp) { implementation = imp; } @Override public void changeImp(StateBase newImp) { implementation = newImp; } // Pass method calls to the implementation: @Override public void f() { implementation.f(); } @Override public void g() { implementation.g(); } @Override public void h() { implementation.h(); } } class Implementation1 implements StateBase { @Override public void f() { System.out.println("Implementation1.f()"); } @Override public void g() { System.out.println("Implementation1.g()"); } @Override public void h() { System.out.println("Implementation1.h()"); } @Override public void changeImp(StateBase newImp) {} } class Implementation2 implements StateBase { @Override public void f() { System.out.println("Implementation2.f()"); } @Override public void g() { System.out.println("Implementation2.g()"); } @Override public void h() { System.out.println("Implementation2.h()"); } @Override public void changeImp(StateBase newImp) {} } public class StateDemo { static void test(StateBase b) { b.f(); b.g(); b.h(); } public static void main(String[] args) { StateBase b = new State(new Implementation1()); test(b); b.changeImp(new Implementation2()); test(b); } } /* Output: Implementation1.f() Implementation1.g() Implementation1.h() Implementation2.f() Implementation2.g() Implementation2.h() */ OnJava8-Examples-1.0/patterns/TemplateMethod.java000066400000000000000000000017171374004044700220240ustar00rootroot00000000000000// patterns/TemplateMethod.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple demonstration of Template Method import java.util.stream.*; abstract class ApplicationFramework { ApplicationFramework() { templateMethod(); } abstract void customize1(); abstract void customize2(); // "private" means automatically "final": private void templateMethod() { IntStream.range(0, 5).forEach( n -> { customize1(); customize2(); }); } } // Create a new "application": class MyApp extends ApplicationFramework { @Override void customize1() { System.out.print("Hello "); } @Override void customize2() { System.out.println("World!"); } } public class TemplateMethod { public static void main(String[] args) { new MyApp(); } } /* Output: Hello World! Hello World! Hello World! Hello World! Hello World! */ OnJava8-Examples-1.0/patterns/abstractfactory/000077500000000000000000000000001374004044700214325ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/abstractfactory/GameEnvironment.java000066400000000000000000000037701374004044700254020ustar00rootroot00000000000000// patterns/abstractfactory/GameEnvironment.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An example of the Abstract Factory pattern // {java patterns.abstractfactory.GameEnvironment} package patterns.abstractfactory; import java.util.function.*; interface Obstacle { void action(); } interface Player { void interactWith(Obstacle o); } class Kitty implements Player { @Override public void interactWith(Obstacle ob) { System.out.print("Kitty has encountered a "); ob.action(); } } class KungFuGuy implements Player { @Override public void interactWith(Obstacle ob) { System.out.print("KungFuGuy now battles a "); ob.action(); } } class Puzzle implements Obstacle { @Override public void action() { System.out.println("Puzzle"); } } class NastyWeapon implements Obstacle { @Override public void action() { System.out.println("NastyWeapon"); } } // The Abstract Factory: class GameElementFactory { Supplier player; Supplier obstacle; } // Concrete factories: class KittiesAndPuzzles extends GameElementFactory { KittiesAndPuzzles() { player = Kitty::new; obstacle = Puzzle::new; } } class KillAndDismember extends GameElementFactory { KillAndDismember() { player = KungFuGuy::new; obstacle = NastyWeapon::new; } } public class GameEnvironment { private Player p; private Obstacle ob; public GameEnvironment(GameElementFactory factory) { p = factory.player.get(); ob = factory.obstacle.get(); } public void play() { p.interactWith(ob); } public static void main(String[] args) { GameElementFactory kp = new KittiesAndPuzzles(), kd = new KillAndDismember(); GameEnvironment g1 = new GameEnvironment(kp), g2 = new GameEnvironment(kd); g1.play(); g2.play(); } } /* Output: Kitty has encountered a Puzzle KungFuGuy now battles a NastyWeapon */ OnJava8-Examples-1.0/patterns/adapt/000077500000000000000000000000001374004044700173305ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/adapt/Adapter.java000066400000000000000000000034241374004044700215560ustar00rootroot00000000000000// patterns/adapt/Adapter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Variations on the Adapter pattern // {java patterns.adapt.Adapter} package patterns.adapt; class WhatIHave { public void g() {} public void h() {} } interface WhatIWant { void f(); } class ProxyAdapter implements WhatIWant { WhatIHave whatIHave; ProxyAdapter(WhatIHave wih) { whatIHave = wih; } @Override public void f() { // Implement behavior using // methods in WhatIHave: whatIHave.g(); whatIHave.h(); } } class WhatIUse { public void op(WhatIWant wiw) { wiw.f(); } } // Approach 2: build adapter use into op(): class WhatIUse2 extends WhatIUse { public void op(WhatIHave wih) { new ProxyAdapter(wih).f(); } } // Approach 3: build adapter into WhatIHave: class WhatIHave2 extends WhatIHave implements WhatIWant { @Override public void f() { g(); h(); } } // Approach 4: use an inner class: class WhatIHave3 extends WhatIHave { private class InnerAdapter implements WhatIWant{ @Override public void f() { g(); h(); } } public WhatIWant whatIWant() { return new InnerAdapter(); } } public class Adapter { public static void main(String[] args) { WhatIUse whatIUse = new WhatIUse(); WhatIHave whatIHave = new WhatIHave(); WhatIWant adapt= new ProxyAdapter(whatIHave); whatIUse.op(adapt); // Approach 2: WhatIUse2 whatIUse2 = new WhatIUse2(); whatIUse2.op(whatIHave); // Approach 3: WhatIHave2 whatIHave2 = new WhatIHave2(); whatIUse.op(whatIHave2); // Approach 4: WhatIHave3 whatIHave3 = new WhatIHave3(); whatIUse.op(whatIHave3.whatIWant()); } } OnJava8-Examples-1.0/patterns/chain/000077500000000000000000000000001374004044700173215ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/chain/ChainOfResponsibility.java000066400000000000000000000046041374004044700244370ustar00rootroot00000000000000// patterns/chain/ChainOfResponsibility.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using the Functional interface // {java patterns.chain.ChainOfResponsibility} package patterns.chain; import java.util.*; import java.util.function.*; class Result { boolean success; List line; Result(List data) { success = true; line = data; } Result() { success = false; line = Collections.emptyList(); } } class Fail extends Result {} interface Algorithm { Result algorithm(List line); } class FindMinima { public static Result leastSquares(List line) { System.out.println("LeastSquares.algorithm"); boolean weSucceed = false; if(weSucceed) // Actual test/calculation here return new Result(Arrays.asList(1.1, 2.2)); else // Try the next one in the chain: return new Fail(); } public static Result perturbation(List line) { System.out.println("Perturbation.algorithm"); boolean weSucceed = false; if(weSucceed) // Actual test/calculation here return new Result(Arrays.asList(3.3, 4.4)); else return new Fail(); } public static Result bisection(List line) { System.out.println("Bisection.algorithm"); boolean weSucceed = true; if(weSucceed) // Actual test/calculation here return new Result(Arrays.asList(5.5, 6.6)); else return new Fail(); } static List, Result>> algorithms = Arrays.asList( FindMinima::leastSquares, FindMinima::perturbation, FindMinima::bisection ); public static Result minima(List line) { for(Function, Result> alg : algorithms) { Result result = alg.apply(line); if(result.success) return result; } return new Fail(); } } public class ChainOfResponsibility { public static void main(String[] args) { FindMinima solver = new FindMinima(); List line = Arrays.asList( 1.0, 2.0, 1.0, 2.0, -1.0, 3.0, 4.0, 5.0, 4.0); Result result = solver.minima(line); if(result.success) System.out.println(result.line); else System.out.println("No algorithm found"); } } /* Output: LeastSquares.algorithm Perturbation.algorithm Bisection.algorithm [5.5, 6.6] */ OnJava8-Examples-1.0/patterns/doubledispatch/000077500000000000000000000000001374004044700212315ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/doubledispatch/Aluminum.java000066400000000000000000000011021374004044700236550ustar00rootroot00000000000000// patterns/doubledispatch/Aluminum.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Aluminum for double dispatching package patterns.doubledispatch; import patterns.trash.*; import java.util.*; public class Aluminum extends patterns.trash.Aluminum implements TypedBinMember { public Aluminum(double wt) { super(wt); } @Override public boolean addToBin(List tbins) { return tbins.stream() .anyMatch(tb -> tb.add(this)); } } OnJava8-Examples-1.0/patterns/doubledispatch/Cardboard.java000066400000000000000000000011071374004044700237540ustar00rootroot00000000000000// patterns/doubledispatch/Cardboard.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cardboard for double dispatching package patterns.doubledispatch; import patterns.trash.*; import java.util.*; public class Cardboard extends patterns.trash.Cardboard implements TypedBinMember { public Cardboard(double wt) { super(wt); } @Override public boolean addToBin(List tbins) { return tbins.stream() .anyMatch(tb -> tb.add(this)); } } OnJava8-Examples-1.0/patterns/doubledispatch/DoubleDispatch.java000066400000000000000000000054421374004044700247730ustar00rootroot00000000000000// patterns/doubledispatch/DoubleDispatch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using multiple dispatching to handle more // than one unknown type during a method call // {java patterns.doubledispatch.DoubleDispatch} package patterns.doubledispatch; import patterns.trash.*; import java.util.*; class AluminumBin extends TypedBin { @Override public boolean add(Aluminum a) { return addIt(a); } } class PaperBin extends TypedBin { @Override public boolean add(Paper a) { return addIt(a); } } class GlassBin extends TypedBin { @Override public boolean add(Glass a) { return addIt(a); } } class CardboardBin extends TypedBin { @Override public boolean add(Cardboard a) { return addIt(a); } } class TrashBinSet { private List binSet = Arrays.asList( new AluminumBin(), new PaperBin(), new GlassBin(), new CardboardBin() ); @SuppressWarnings("unchecked") public void sortIntoBins(List bin) { bin.forEach( aBin -> { TypedBinMember t = (TypedBinMember)aBin; if(!t.addToBin(binSet)) System.err.println("Couldn't add " + t); }); } public List binSet() { return binSet; } } public class DoubleDispatch { public static void main(String[] args) { List bin = new ArrayList<>(); TrashBinSet bins = new TrashBinSet(); // ParseTrash still works, without changes: ParseTrash.fillBin("doubledispatch", bin); // Sort from the master bin into the // individually-typed bins: bins.sortIntoBins(bin); // Perform sumValue for each bin... bins.binSet() .forEach(tb -> Trash.sumValue(tb.v)); // ... and for the master bin Trash.sumValue(bin); } } /* Output: (First and Last 10 Lines) Loading patterns.doubledispatch.Glass Loading patterns.doubledispatch.Paper Loading patterns.doubledispatch.Aluminum Loading patterns.doubledispatch.Cardboard weight of patterns.doubledispatch.Aluminum = 89.0 weight of patterns.doubledispatch.Aluminum = 76.0 weight of patterns.doubledispatch.Aluminum = 25.0 weight of patterns.doubledispatch.Aluminum = 34.0 weight of patterns.doubledispatch.Aluminum = 27.0 weight of patterns.doubledispatch.Aluminum = 18.0 ...________...________...________...________... weight of patterns.doubledispatch.Aluminum = 93.0 weight of patterns.doubledispatch.Glass = 93.0 weight of patterns.doubledispatch.Paper = 80.0 weight of patterns.doubledispatch.Glass = 36.0 weight of patterns.doubledispatch.Glass = 12.0 weight of patterns.doubledispatch.Glass = 60.0 weight of patterns.doubledispatch.Paper = 66.0 weight of patterns.doubledispatch.Aluminum = 36.0 weight of patterns.doubledispatch.Cardboard = 22.0 Total value = 1086.0599818825722 */ OnJava8-Examples-1.0/patterns/doubledispatch/Glass.java000066400000000000000000000010631374004044700231450ustar00rootroot00000000000000// patterns/doubledispatch/Glass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Glass for double dispatching package patterns.doubledispatch; import patterns.trash.*; import java.util.*; public class Glass extends patterns.trash.Glass implements TypedBinMember { public Glass(double wt) { super(wt); } @Override public boolean addToBin(List tbins) { return tbins.stream() .anyMatch(tb -> tb.add(this)); } } OnJava8-Examples-1.0/patterns/doubledispatch/Paper.java000066400000000000000000000010631374004044700231430ustar00rootroot00000000000000// patterns/doubledispatch/Paper.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Paper for double dispatching package patterns.doubledispatch; import patterns.trash.*; import java.util.*; public class Paper extends patterns.trash.Paper implements TypedBinMember { public Paper(double wt) { super(wt); } @Override public boolean addToBin(List tbins) { return tbins.stream() .anyMatch(tb -> tb.add(this)); } } OnJava8-Examples-1.0/patterns/doubledispatch/TypedBin.java000066400000000000000000000012471374004044700236160ustar00rootroot00000000000000// patterns/doubledispatch/TypedBin.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A List that can grab the right type package patterns.doubledispatch; import patterns.trash.*; import java.util.*; public class TypedBin { List v = new ArrayList<>(); protected boolean addIt(Trash t) { v.add(t); return true; } public boolean add(Aluminum a) { return false; } public boolean add(Paper a) { return false; } public boolean add(Glass a) { return false; } public boolean add(Cardboard a) { return false; } } OnJava8-Examples-1.0/patterns/doubledispatch/TypedBinMember.java000066400000000000000000000007501374004044700247440ustar00rootroot00000000000000// patterns/doubledispatch/TypedBinMember.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An interface for adding the double dispatching // method to the trash hierarchy without // modifying the original hierarchy package patterns.doubledispatch; import java.util.*; public interface TypedBinMember { // The new method: boolean addToBin(List bins); } OnJava8-Examples-1.0/patterns/dynatrash/000077500000000000000000000000001374004044700202345ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/dynatrash/DynaTrash.java000066400000000000000000000042321374004044700227750ustar00rootroot00000000000000// patterns/dynatrash/DynaTrash.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using a Map of Lists and RTTI to automatically // sort trash into Lists. This solution, despite // the use of RTTI, is extensible. // {java patterns.dynatrash.DynaTrash} package patterns.dynatrash; import patterns.trash.*; import java.util.*; import java.util.stream.*; // Generic TypeMap works in any situation: class TypeMap { private Map> t = new HashMap<>(); public void add(T o) { Class type = o.getClass(); if(t.containsKey(type)) t.get(type).add(o); else { List v = new ArrayList<>(); v.add(o); t.put(type,v); } } public Stream> values() { return t.values().stream(); } } // Adapter class for callbacks // from ParseTrash.fillBin(): class TypeMapAdapter implements Fillable { TypeMap map; TypeMapAdapter(TypeMap tm) { map = tm; } @Override public void addTrash(Trash t) { map.add(t); } } public class DynaTrash { @SuppressWarnings("unchecked") public static void main(String[] args) { TypeMap bin = new TypeMap<>(); ParseTrash.fillBin( "trash", new TypeMapAdapter(bin)); bin.values().forEach(Trash::sumValue); } } /* Output: (First and Last 10 Lines) Loading patterns.trash.Glass Loading patterns.trash.Paper Loading patterns.trash.Aluminum Loading patterns.trash.Cardboard weight of patterns.trash.Paper = 22.0 weight of patterns.trash.Paper = 11.0 weight of patterns.trash.Paper = 88.0 weight of patterns.trash.Paper = 91.0 weight of patterns.trash.Paper = 80.0 weight of patterns.trash.Paper = 66.0 ...________...________...________...________... weight of patterns.trash.Aluminum = 81.0 weight of patterns.trash.Aluminum = 36.0 weight of patterns.trash.Aluminum = 93.0 weight of patterns.trash.Aluminum = 36.0 Total value = 860.0499778985977 weight of patterns.trash.Cardboard = 96.0 weight of patterns.trash.Cardboard = 44.0 weight of patterns.trash.Cardboard = 12.0 weight of patterns.trash.Cardboard = 22.0 Total value = 40.02000072598457 */ OnJava8-Examples-1.0/patterns/observer/000077500000000000000000000000001374004044700200665ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/observer/ObservedFlower.java000066400000000000000000000065401374004044700236660ustar00rootroot00000000000000// patterns/observer/ObservedFlower.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of "Observer" pattern // {java patterns.observer.ObservedFlower} package patterns.observer; import java.util.*; @SuppressWarnings("deprecation") class Flower { private boolean isOpen; private boolean alreadyOpen; private boolean alreadyClosed; Flower() { isOpen = false; } OpenNotifier opening = new OpenNotifier(); CloseNotifier closing = new CloseNotifier(); public void open() { // Opens its petals isOpen = true; opening.notifyObservers(); alreadyClosed = false; } public void close() { // Closes its petals isOpen = false; closing.notifyObservers(); alreadyOpen = false; } class OpenNotifier extends Observable { @Override public void notifyObservers() { if(isOpen && !alreadyOpen) { setChanged(); super.notifyObservers(); alreadyOpen = true; } } } class CloseNotifier extends Observable{ @Override public void notifyObservers() { if(!isOpen && !alreadyClosed) { setChanged(); super.notifyObservers(); alreadyClosed = true; } } } } @SuppressWarnings("deprecation") class Bee { private String name; Bee(String nm) { name = nm; } // Observe openings: public Observer openObserver() { return (ob, a) -> System.out.println( "Bee " + name + "'s breakfast time!"); } // Observe closings: public Observer closeObserver() { return (ob, a) -> System.out.println( "Bee " + name + "'s bed time!"); } } @SuppressWarnings("deprecation") class Hummingbird { private String name; Hummingbird(String nm) { name = nm; } public Observer openObserver() { return (ob, a) -> System.out.println( "Hummingbird " + name + "'s breakfast time!"); } public Observer closeObserver() { return (ob, a) -> System.out.println( "Hummingbird " + name + "'s bed time!"); } } public class ObservedFlower { public static void main(String[] args) { Flower f = new Flower(); Bee ba = new Bee("A"), bb = new Bee("B"); Hummingbird ha = new Hummingbird("A"), hb = new Hummingbird("B"); f.opening.addObserver(ha.openObserver()); f.opening.addObserver(hb.openObserver()); f.opening.addObserver(ba.openObserver()); f.opening.addObserver(bb.openObserver()); f.closing.addObserver(ha.closeObserver()); f.closing.addObserver(hb.closeObserver()); f.closing.addObserver(ba.closeObserver()); f.closing.addObserver(bb.closeObserver()); // Hummingbird B decides to sleep in: f.opening.deleteObserver(hb.openObserver()); // A change that interests observers: f.open(); f.open(); // It's already open, no change. // Bee A doesn't want to go to bed: f.closing.deleteObserver(ba.closeObserver()); f.close(); f.close(); // It's already closed; no change f.opening.deleteObservers(); f.open(); f.close(); } } /* Output: Bee B's breakfast time! Bee A's breakfast time! Hummingbird B's breakfast time! Hummingbird A's breakfast time! Bee B's bed time! Bee A's bed time! Hummingbird B's bed time! Hummingbird A's bed time! Bee B's bed time! Bee A's bed time! Hummingbird B's bed time! Hummingbird A's bed time! */ OnJava8-Examples-1.0/patterns/recyclea/000077500000000000000000000000001374004044700200265ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/recyclea/RecycleA.java000066400000000000000000000070001374004044700223550ustar00rootroot00000000000000// patterns/recyclea/RecycleA.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Recycling with RTTI // {java patterns.recyclea.RecycleA} package patterns.recyclea; import java.util.*; import java.util.function.*; import java.util.stream.*; abstract class Trash { double weight; Trash(double wt) { weight = wt; } abstract double value(); // Sums the value of Trash in a bin: private static double val; static void sumValue(List bin) { val = 0.0f; bin.forEach( t -> { // Polymorphism in action: val += t.weight * t.value(); System.out.println( "weight of " + // Using RTTI to get type // information about the class: t.getClass().getSimpleName() + " = " + t.weight); }); System.out.println("Total value = " + val); } } class Aluminum extends Trash { static double val = 1.67f; Aluminum(double wt) { super(wt); } @Override double value() { return val; } static void value(double newval) { val = newval; } } class Paper extends Trash { static double val = 0.10f; Paper(double wt) { super(wt); } @Override double value() { return val; } static void value(double newval) { val = newval; } } class Glass extends Trash { static double val = 0.23f; Glass(double wt) { super(wt); } @Override double value() { return val; } static void value(double newval) { val = newval; } } class TrashFactory { static List> ttypes = Arrays.asList( Aluminum::new, Paper::new, Glass::new); static final int SZ = ttypes.size(); private static SplittableRandom rand = new SplittableRandom(47); public static Trash newTrash() { return ttypes .get(rand.nextInt(SZ)) .apply(rand.nextDouble()); } } public class RecycleA { public static void main(String[] args) { List bin = Stream.generate(TrashFactory::newTrash) .limit(25) .collect(Collectors.toList()); List glassBin = new ArrayList<>(); List paperBin = new ArrayList<>(); List alBin = new ArrayList<>(); // Sort the Trash: bin.forEach( t -> { // RTTI to discover Trash type: if(t instanceof Aluminum) alBin.add((Aluminum)t); if(t instanceof Paper) paperBin.add((Paper)t); if(t instanceof Glass) glassBin.add((Glass)t); }); Trash.sumValue(alBin); Trash.sumValue(paperBin); Trash.sumValue(glassBin); Trash.sumValue(bin); } } /* Output: (First and Last 11 Lines) weight of Aluminum = 0.2893030122276371 weight of Aluminum = 0.1970234961398979 weight of Aluminum = 0.36295525806274787 weight of Aluminum = 0.4825532324565849 weight of Aluminum = 0.8036398273294586 weight of Aluminum = 0.510430896154935 weight of Aluminum = 0.6703377164093444 weight of Aluminum = 0.41477933066243455 weight of Aluminum = 0.3603022312124007 weight of Aluminum = 0.43690089841661006 weight of Aluminum = 0.6708820087907101 ...________...________...________...________... weight of Aluminum = 0.41477933066243455 weight of Aluminum = 0.3603022312124007 weight of Aluminum = 0.43690089841661006 weight of Glass = 0.5999637765664924 weight of Glass = 0.7748836191212746 weight of Paper = 0.5735994548427199 weight of Glass = 0.5362827750851034 weight of Aluminum = 0.6708820087907101 weight of Paper = 0.8370669795210507 weight of Glass = 0.3397919679731668 Total value = 9.90671597531968 */ OnJava8-Examples-1.0/patterns/recycleb/000077500000000000000000000000001374004044700200275ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/recycleb/RecycleB.java000066400000000000000000000035041374004044700223640ustar00rootroot00000000000000// patterns/recycleb/RecycleB.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java patterns.recycleb.RecycleB} package patterns.recycleb; import patterns.trash.*; import java.util.*; public class RecycleB { public static void main(String[] args) { List bin = new ArrayList<>(); // Fill up the Trash bin: ParseTrash.fillBin("trash", bin); List glassBin = new ArrayList<>(); List paperBin = new ArrayList<>(); List alBin = new ArrayList<>(); // Sort the Trash: bin.forEach( t -> { // RTTI to discover Trash type: if(t instanceof Aluminum) alBin.add((Aluminum)t); if(t instanceof Paper) paperBin.add((Paper)t); if(t instanceof Glass) glassBin.add((Glass)t); }); Trash.sumValue(alBin); Trash.sumValue(paperBin); Trash.sumValue(glassBin); Trash.sumValue(bin); } } /* Output: (First and Last 10 Lines) Loading patterns.trash.Glass Loading patterns.trash.Paper Loading patterns.trash.Aluminum Loading patterns.trash.Cardboard weight of patterns.trash.Aluminum = 89.0 weight of patterns.trash.Aluminum = 76.0 weight of patterns.trash.Aluminum = 25.0 weight of patterns.trash.Aluminum = 34.0 weight of patterns.trash.Aluminum = 27.0 weight of patterns.trash.Aluminum = 18.0 ...________...________...________...________... weight of patterns.trash.Aluminum = 93.0 weight of patterns.trash.Glass = 93.0 weight of patterns.trash.Paper = 80.0 weight of patterns.trash.Glass = 36.0 weight of patterns.trash.Glass = 12.0 weight of patterns.trash.Glass = 60.0 weight of patterns.trash.Paper = 66.0 weight of patterns.trash.Aluminum = 36.0 weight of patterns.trash.Cardboard = 22.0 Total value = 1086.0599818825722 */ OnJava8-Examples-1.0/patterns/recyclec/000077500000000000000000000000001374004044700200305ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/recyclec/RecycleC.java000066400000000000000000000047601374004044700223730ustar00rootroot00000000000000// patterns/recyclec/RecycleC.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Adding more objects to the recycling problem // {java patterns.recyclec.RecycleC} package patterns.recyclec; import patterns.trash.*; import java.util.*; // A List that admits only the right type: class Tbin extends ArrayList { Class binType; Tbin(Class type) { binType = type; } @SuppressWarnings("unchecked") boolean grab(Trash t) { // Comparing class types: if(t.getClass().equals(binType)) { add((T)t); // Downcast to this TBin's type return true; // Object grabbed } return false; // Object not grabbed } } class TbinList extends ArrayList> { // [1] boolean sort(T t) { for(Tbin ts : this) if(ts.grab(t)) return true; return false; // bin not found for t } void sortBin(Tbin bin) { // [2] for(T aBin : bin) if(!sort(aBin)) System.err.println("Bin not found"); } } public class RecycleC { static Tbin bin = new Tbin<>(Trash.class); public static void main(String[] args) { // Fill up the Trash bin: ParseTrash.fillBin("trash", bin); TbinList trashBins = new TbinList<>(); trashBins.add(new Tbin<>(Aluminum.class)); trashBins.add(new Tbin<>(Paper.class)); trashBins.add(new Tbin<>(Glass.class)); // add one line here: [*3*] trashBins.add(new Tbin<>(Cardboard.class)); trashBins.sortBin(bin); // [4] trashBins.forEach(Trash::sumValue); Trash.sumValue(bin); } } /* Output: (First and Last 10 Lines) Loading patterns.trash.Glass Loading patterns.trash.Paper Loading patterns.trash.Aluminum Loading patterns.trash.Cardboard weight of patterns.trash.Aluminum = 89.0 weight of patterns.trash.Aluminum = 76.0 weight of patterns.trash.Aluminum = 25.0 weight of patterns.trash.Aluminum = 34.0 weight of patterns.trash.Aluminum = 27.0 weight of patterns.trash.Aluminum = 18.0 ...________...________...________...________... weight of patterns.trash.Aluminum = 93.0 weight of patterns.trash.Glass = 93.0 weight of patterns.trash.Paper = 80.0 weight of patterns.trash.Glass = 36.0 weight of patterns.trash.Glass = 12.0 weight of patterns.trash.Glass = 60.0 weight of patterns.trash.Paper = 66.0 weight of patterns.trash.Aluminum = 36.0 weight of patterns.trash.Cardboard = 22.0 Total value = 1086.0599818825722 */ OnJava8-Examples-1.0/patterns/shapes/000077500000000000000000000000001374004044700175225ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/shapes/BadShapeCreation.java000066400000000000000000000005341374004044700235230ustar00rootroot00000000000000// patterns/shapes/BadShapeCreation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; public class BadShapeCreation extends RuntimeException { public BadShapeCreation(String msg) { super(msg); } } OnJava8-Examples-1.0/patterns/shapes/Circle.java000066400000000000000000000004001374004044700215600ustar00rootroot00000000000000// patterns/shapes/Circle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; public class Circle extends Shape {} OnJava8-Examples-1.0/patterns/shapes/FactoryMethod.java000066400000000000000000000004421374004044700231350ustar00rootroot00000000000000// patterns/shapes/FactoryMethod.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; public interface FactoryMethod { Shape create(String type); } OnJava8-Examples-1.0/patterns/shapes/FactoryTest.java000066400000000000000000000010421374004044700226310ustar00rootroot00000000000000// patterns/shapes/FactoryTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; import java.util.stream.*; public class FactoryTest { public static void test(FactoryMethod factory) { Stream.of("Circle", "Square", "Triangle", "Square", "Circle", "Circle", "Triangle") .map(factory::create) .peek(Shape::draw) .peek(Shape::erase) .count(); // Terminal operation } } OnJava8-Examples-1.0/patterns/shapes/Shape.java000066400000000000000000000010441374004044700214240ustar00rootroot00000000000000// patterns/shapes/Shape.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; public class Shape { private static int counter = 0; private int id = counter++; @Override public String toString() { return getClass().getSimpleName() + "[" + id + "]"; } public void draw() { System.out.println(this + " draw"); } public void erase() { System.out.println(this + " erase"); } } OnJava8-Examples-1.0/patterns/shapes/Square.java000066400000000000000000000004001374004044700216170ustar00rootroot00000000000000// patterns/shapes/Square.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; public class Square extends Shape {} OnJava8-Examples-1.0/patterns/shapes/Triangle.java000066400000000000000000000004041374004044700221300ustar00rootroot00000000000000// patterns/shapes/Triangle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.shapes; public class Triangle extends Shape {} OnJava8-Examples-1.0/patterns/state/000077500000000000000000000000001374004044700173575ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/state/StateMachineDemo.java000066400000000000000000000031171374004044700233760ustar00rootroot00000000000000// patterns/state/StateMachineDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The StateMachine pattern and Template method // {java patterns.state.StateMachineDemo} package patterns.state; import onjava.Nap; interface State { void run(); } abstract class StateMachine { protected State currentState; protected abstract boolean changeState(); // Template method: protected final void runAll() { while(changeState()) // Customizable currentState.run(); } } // A different subclass for each state: class Wash implements State { @Override public void run() { System.out.println("Washing"); new Nap(0.5); } } class Spin implements State { @Override public void run() { System.out.println("Spinning"); new Nap(0.5); } } class Rinse implements State { @Override public void run() { System.out.println("Rinsing"); new Nap(0.5); } } class Washer extends StateMachine { private int i = 0; // The state table: private State[] states = { new Wash(), new Spin(), new Rinse(), new Spin(), }; Washer() { runAll(); } @Override public boolean changeState() { if(i < states.length) { // Change the state by setting the // surrogate reference to a new object: currentState = states[i++]; return true; } else return false; } } public class StateMachineDemo { public static void main(String[] args) { new Washer(); } } /* Output: Washing Spinning Rinsing Spinning */ OnJava8-Examples-1.0/patterns/strategy/000077500000000000000000000000001374004044700201015ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/strategy/StrategyPattern.java000066400000000000000000000031021374004044700241000ustar00rootroot00000000000000// patterns/strategy/StrategyPattern.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java patterns.strategy.StrategyPattern} package patterns.strategy; import java.util.function.*; import java.util.*; // The common strategy base type: class FindMinima { Function, List> algorithm; } // The various strategies: class LeastSquares extends FindMinima { LeastSquares() { // Line is a sequence of points (Dummy data): algorithm = (line) -> Arrays.asList(1.1, 2.2); } } class Perturbation extends FindMinima { Perturbation() { algorithm = (line) -> Arrays.asList(3.3, 4.4); } } class Bisection extends FindMinima { Bisection() { algorithm = (line) -> Arrays.asList(5.5, 6.6); } } // The "Context" controls the strategy: class MinimaSolver { private FindMinima strategy; MinimaSolver(FindMinima strat) { strategy = strat; } List minima(List line) { return strategy.algorithm.apply(line); } void changeAlgorithm(FindMinima newAlgorithm) { strategy = newAlgorithm; } } public class StrategyPattern { public static void main(String[] args) { MinimaSolver solver = new MinimaSolver(new LeastSquares()); List line = Arrays.asList( 1.0, 2.0, 1.0, 2.0, -1.0, 3.0, 4.0, 5.0, 4.0 ); System.out.println(solver.minima(line)); solver.changeAlgorithm(new Bisection()); System.out.println(solver.minima(line)); } } /* Output: [1.1, 2.2] [5.5, 6.6] */ OnJava8-Examples-1.0/patterns/strategy/StrategyPattern2.java000066400000000000000000000022571374004044700241740ustar00rootroot00000000000000// patterns/strategy/StrategyPattern2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java patterns.strategy.StrategyPattern2} package patterns.strategy; import java.util.function.*; import java.util.*; // "Context" is now incorporated: class FindMinima2 { Function, List> algorithm; FindMinima2() { leastSquares(); } // default // The various strategies: void leastSquares() { algorithm = (line) -> Arrays.asList(1.1, 2.2); } void perturbation() { algorithm = (line) -> Arrays.asList(3.3, 4.4); } void bisection() { algorithm = (line) -> Arrays.asList(5.5, 6.6); } List minima(List line) { return algorithm.apply(line); } } public class StrategyPattern2 { public static void main(String[] args) { FindMinima2 solver = new FindMinima2(); List line = Arrays.asList( 1.0, 2.0, 1.0, 2.0, -1.0, 3.0, 4.0, 5.0, 4.0 ); System.out.println(solver.minima(line)); solver.bisection(); System.out.println(solver.minima(line)); } } /* Output: [1.1, 2.2] [5.5, 6.6] */ OnJava8-Examples-1.0/patterns/trash/000077500000000000000000000000001374004044700173605ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/trash/Aluminum.java000066400000000000000000000007121374004044700220120ustar00rootroot00000000000000// patterns/trash/Aluminum.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.trash; public class Aluminum extends Trash { private static double val = 1.67f; public Aluminum(double wt) { super(wt); } @Override public double value() { return val; } public static void value(double newVal) { val = newVal; } } OnJava8-Examples-1.0/patterns/trash/Cardboard.java000066400000000000000000000007151374004044700221070ustar00rootroot00000000000000// patterns/trash/Cardboard.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.trash; public class Cardboard extends Trash { private static double val = 0.23f; public Cardboard(double wt) { super(wt); } @Override public double value() { return val; } public static void value(double newVal) { val = newVal; } } OnJava8-Examples-1.0/patterns/trash/Fillable.java000066400000000000000000000005141374004044700217350ustar00rootroot00000000000000// patterns/trash/Fillable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Any object that can be filled with Trash package patterns.trash; public interface Fillable { void addTrash(T t); } OnJava8-Examples-1.0/patterns/trash/FillableList.java000066400000000000000000000007361374004044700225770ustar00rootroot00000000000000// patterns/trash/FillableList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Adapter that makes a List Fillable package patterns.trash; import java.util.*; public class FillableList implements Fillable { private List v; public FillableList(List vv) { v = vv; } @Override public void addTrash(T t) { v.add(t); } } OnJava8-Examples-1.0/patterns/trash/Glass.java000066400000000000000000000007011374004044700212720ustar00rootroot00000000000000// patterns/trash/Glass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.trash; public class Glass extends Trash { private static double val = 0.23f; public Glass(double wt) { super(wt); } @Override public double value() { return val; } public static void value(double newVal) { val = newVal; } } OnJava8-Examples-1.0/patterns/trash/Paper.java000066400000000000000000000007011374004044700212700ustar00rootroot00000000000000// patterns/trash/Paper.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package patterns.trash; public class Paper extends Trash { private static double val = 0.10f; public Paper(double wt) { super(wt); } @Override public double value() { return val; } public static void value(double newVal) { val = newVal; } } OnJava8-Examples-1.0/patterns/trash/ParseTrash.java000066400000000000000000000057401374004044700223050ustar00rootroot00000000000000// patterns/trash/ParseTrash.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Open a file and parse its contents into // Trash objects, placing each into a List // {java patterns.trash.ParseTrash} package patterns.trash; import java.util.*; import java.util.stream.*; import java.io.*; import java.nio.file.*; import java.nio.file.Files; public class ParseTrash { public static void fillBin(String pckg, Fillable bin) { try { Files.lines(Paths.get("trash", "Trash.dat")) // Remove empty lines and comment lines: .filter(line -> line.trim().length() != 0) .filter(line -> !line.startsWith("//")) .forEach( line -> { String type = "patterns." + pckg + "." + line.substring( 0, line.indexOf(':')).trim(); double weight = Double.valueOf( line.substring(line.indexOf(':') + 1) .trim()); bin.addTrash(Trash.factory( new Trash.Info(type, weight))); }); } catch(IOException | NumberFormatException | Trash.TrashClassNotFoundException | Trash.CannotCreateTrashException e) { throw new RuntimeException(e); } } // Special case to handle List: public static void fillBin(String pckg, List bin) { fillBin(pckg, new FillableList<>(bin)); } // Basic test: public static void main(String[] args) { List t = new ArrayList<>(); fillBin("trash", t); t.forEach(System.out::println); } } /* Output: Loading patterns.trash.Glass Loading patterns.trash.Paper Loading patterns.trash.Aluminum Loading patterns.trash.Cardboard patterns.trash.Glass w:54.0 v:0.23 patterns.trash.Paper w:22.0 v:0.10 patterns.trash.Paper w:11.0 v:0.10 patterns.trash.Glass w:17.0 v:0.23 patterns.trash.Aluminum w:89.0 v:1.67 patterns.trash.Paper w:88.0 v:0.10 patterns.trash.Aluminum w:76.0 v:1.67 patterns.trash.Cardboard w:96.0 v:0.23 patterns.trash.Aluminum w:25.0 v:1.67 patterns.trash.Aluminum w:34.0 v:1.67 patterns.trash.Glass w:11.0 v:0.23 patterns.trash.Glass w:68.0 v:0.23 patterns.trash.Glass w:43.0 v:0.23 patterns.trash.Aluminum w:27.0 v:1.67 patterns.trash.Cardboard w:44.0 v:0.23 patterns.trash.Aluminum w:18.0 v:1.67 patterns.trash.Paper w:91.0 v:0.10 patterns.trash.Glass w:63.0 v:0.23 patterns.trash.Glass w:50.0 v:0.23 patterns.trash.Glass w:80.0 v:0.23 patterns.trash.Aluminum w:81.0 v:1.67 patterns.trash.Cardboard w:12.0 v:0.23 patterns.trash.Glass w:12.0 v:0.23 patterns.trash.Glass w:54.0 v:0.23 patterns.trash.Aluminum w:36.0 v:1.67 patterns.trash.Aluminum w:93.0 v:1.67 patterns.trash.Glass w:93.0 v:0.23 patterns.trash.Paper w:80.0 v:0.10 patterns.trash.Glass w:36.0 v:0.23 patterns.trash.Glass w:12.0 v:0.23 patterns.trash.Glass w:60.0 v:0.23 patterns.trash.Paper w:66.0 v:0.10 patterns.trash.Aluminum w:36.0 v:1.67 patterns.trash.Cardboard w:22.0 v:0.23 */ OnJava8-Examples-1.0/patterns/trash/Trash.dat000066400000000000000000000005741374004044700211410ustar00rootroot00000000000000// patterns/trash/Trash.dat Glass:54 Paper:22 Paper:11 Glass:17 Aluminum:89 Paper:88 Aluminum:76 Cardboard:96 Aluminum:25 Aluminum:34 Glass:11 Glass:68 Glass:43 Aluminum:27 Cardboard:44 Aluminum:18 Paper:91 Glass:63 Glass:50 Glass:80 Aluminum:81 Cardboard:12 Glass:12 Glass:54 Aluminum:36 Aluminum:93 Glass:93 Paper:80 Glass:36 Glass:12 Glass:60 Paper:66 Aluminum:36 Cardboard:22 OnJava8-Examples-1.0/patterns/trash/Trash.java000066400000000000000000000053471374004044700213150ustar00rootroot00000000000000// patterns/trash/Trash.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Base class for Trash recycling examples package patterns.trash; import java.util.*; import java.lang.reflect.*; public abstract class Trash { private double weight; public Trash(double wt) { weight = wt; } public Trash() {} public abstract double value(); public double weight() { return weight; } // Sums the value of Trash in a bin: static double val; public static void sumValue(List bin) { val = 0.0f; bin.forEach( t -> { val += t.weight() * t.value(); System.out.println("weight of " + // RTTI gets type information // about the class: t.getClass().getName() + " = " + t.weight()); }); System.out.println("Total value = " + val); } @Override public String toString() { // Print correct subclass name: return getClass().getName() + " w:" + weight() + " v:" + String.format("%.2f", value()); } // Remainder of class supports dynamic creation: public static class CannotCreateTrashException extends RuntimeException { public CannotCreateTrashException(Exception why) { super(why); } } public static class TrashClassNotFoundException extends RuntimeException { public TrashClassNotFoundException(Exception why) { super(why); } } public static class Info { public String id; public double data; public Info(String name, double data) { id = name; this.data = data; } } private static List trashTypes = new ArrayList<>(); @SuppressWarnings("unchecked") public static T factory(Info info) { for(Class trashType : trashTypes) { // Determine the type and create one: if(trashType.getName().contains(info.id)) { try { // Get the dynamic constructor method // that takes a double argument: Constructor ctor = trashType.getConstructor(double.class); // Call the constructor to create a // new object: return (T)ctor.newInstance(info.data); } catch(Exception e) { throw new CannotCreateTrashException(e); } } } // The necessary Class was not in the list. Try to // load it, but it must be in your class path! try { System.out.println("Loading " + info.id); trashTypes.add(Class.forName(info.id)); } catch(Exception e) { throw new TrashClassNotFoundException(e); } // Loaded successfully. Recursive call // should work this time: return factory(info); } } OnJava8-Examples-1.0/patterns/trashvisitor/000077500000000000000000000000001374004044700210005ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/trashvisitor/Aluminum.java000066400000000000000000000007521374004044700234360ustar00rootroot00000000000000// patterns/trashvisitor/Aluminum.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Aluminum for the visitor pattern package patterns.trashvisitor; import patterns.trash.*; public class Aluminum extends patterns.trash.Aluminum implements Visitable { public Aluminum(double wt) { super(wt); } @Override public void accept(Visitor v) { v.visit(this); } } OnJava8-Examples-1.0/patterns/trashvisitor/Cardboard.java000066400000000000000000000007571374004044700235350ustar00rootroot00000000000000// patterns/trashvisitor/Cardboard.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cardboard for the visitor pattern package patterns.trashvisitor; import patterns.trash.*; public class Cardboard extends patterns.trash.Cardboard implements Visitable { public Cardboard(double wt) { super(wt); } @Override public void accept(Visitor v) { v.visit(this); } } OnJava8-Examples-1.0/patterns/trashvisitor/Glass.java000066400000000000000000000007331374004044700227170ustar00rootroot00000000000000// patterns/trashvisitor/Glass.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Glass for the visitor pattern package patterns.trashvisitor; import patterns.trash.*; public class Glass extends patterns.trash.Glass implements Visitable { public Glass(double wt) { super(wt); } @Override public void accept(Visitor v) { v.visit(this); } } OnJava8-Examples-1.0/patterns/trashvisitor/Paper.java000066400000000000000000000007331374004044700227150ustar00rootroot00000000000000// patterns/trashvisitor/Paper.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Paper for the visitor pattern package patterns.trashvisitor; import patterns.trash.*; public class Paper extends patterns.trash.Paper implements Visitable { public Paper(double wt) { super(wt); } @Override public void accept(Visitor v) { v.visit(this); } } OnJava8-Examples-1.0/patterns/trashvisitor/TrashVisitor.java000066400000000000000000000066761374004044700243230ustar00rootroot00000000000000// patterns/trashvisitor/TrashVisitor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java patterns.trashvisitor.TrashVisitor} package patterns.trashvisitor; import patterns.trash.*; import java.util.*; // Specific group of algorithms packaged // in each implementation of Visitor: class PriceVisitor implements Visitor { private double alSum; // Aluminum private double pSum; // Paper private double gSum; // Glass private double cSum; // Cardboard public static void show(String s) { System.out.println(s); } @Override public void visit(Aluminum al) { double v = al.weight() * al.value(); show("value of Aluminum= " + v); alSum += v; } @Override public void visit(Paper p) { double v = p.weight() * p.value(); show("value of Paper= " + v); pSum += v; } @Override public void visit(Glass g) { double v = g.weight() * g.value(); show("value of Glass= " + v); gSum += v; } @Override public void visit(Cardboard c) { double v = c.weight() * c.value(); show("value of Cardboard = " + v); cSum += v; } @Override public void total() { show( "Total Aluminum: $" + alSum + "\n" + "Total Paper: $" + pSum + "\n" + "Total Glass: $" + gSum + "\n" + "Total Cardboard: $" + cSum); } } class WeightVisitor implements Visitor { private double alSum; // Aluminum private double pSum; // Paper private double gSum; // Glass private double cSum; // Cardboard public static void show(String s) { System.out.println(s); } @Override public void visit(Aluminum al) { alSum += al.weight(); show("Aluminum weight = " + al.weight()); } @Override public void visit(Paper p) { pSum += p.weight(); show("Paper weight = " + p.weight()); } @Override public void visit(Glass g) { gSum += g.weight(); show("Glass weight = " + g.weight()); } @Override public void visit(Cardboard c) { cSum += c.weight(); show("Cardboard weight = " + c.weight()); } @Override public void total() { show("Total weight Aluminum:" + alSum); show("Total weight Paper:" + pSum); show("Total weight Glass:" + gSum); show("Total weight Cardboard:" + cSum); } } public class TrashVisitor { public static void main(String[] args) { List bin = new ArrayList<>(); // ParseTrash still works, without changes: ParseTrash.fillBin("trashvisitor", bin); List visitors = Arrays.asList( new PriceVisitor(), new WeightVisitor()); bin.forEach( t -> { Visitable v = (Visitable) t; visitors.forEach(visitor -> v.accept(visitor)); }); visitors.forEach(Visitor::total); } } /* Output: (First and Last 10 Lines) Loading patterns.trashvisitor.Glass Loading patterns.trashvisitor.Paper Loading patterns.trashvisitor.Aluminum Loading patterns.trashvisitor.Cardboard value of Glass= 12.420000225305557 Glass weight = 54.0 value of Paper= 2.2000000327825546 Paper weight = 22.0 value of Paper= 1.1000000163912773 Paper weight = 11.0 ...________...________...________...________... value of Cardboard = 5.060000091791153 Cardboard weight = 22.0 Total Aluminum: $860.0499778985977 Total Paper: $35.80000053346157 Total Glass: $150.1900027245283 Total Cardboard: $40.02000072598457 Total weight Aluminum:515.0 Total weight Paper:358.0 Total weight Glass:653.0 Total weight Cardboard:174.0 */ OnJava8-Examples-1.0/patterns/trashvisitor/Visitable.java000066400000000000000000000006401374004044700235650ustar00rootroot00000000000000// patterns/trashvisitor/Visitable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An interface to add visitor functionality to the // Trash hierarchy without modifying the base class package patterns.trashvisitor; public interface Visitable { // The new method: void accept(Visitor v); } OnJava8-Examples-1.0/patterns/trashvisitor/Visitor.java000066400000000000000000000006331374004044700233040ustar00rootroot00000000000000// patterns/trashvisitor/Visitor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The base interface for visitors package patterns.trashvisitor; public interface Visitor { void visit(Aluminum a); void visit(Paper p); void visit(Glass g); void visit(Cardboard c); void total(); } OnJava8-Examples-1.0/patterns/visitor/000077500000000000000000000000001374004044700177365ustar00rootroot00000000000000OnJava8-Examples-1.0/patterns/visitor/BeeAndFlowers.java000066400000000000000000000053101374004044700232600ustar00rootroot00000000000000// patterns/visitor/BeeAndFlowers.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of "visitor" pattern // {java patterns.visitor.BeeAndFlowers} package patterns.visitor; import java.util.*; import java.util.function.*; import java.util.stream.*; interface Visitor { void visit(Gladiolus g); void visit(Renuculus r); void visit(Chrysanthemum c); } // The Flower hierarchy cannot be changed: interface Flower { void accept(Visitor v); } class Gladiolus implements Flower { @Override public void accept(Visitor v) { v.visit(this);} } class Renuculus implements Flower { @Override public void accept(Visitor v) { v.visit(this);} } class Chrysanthemum implements Flower { @Override public void accept(Visitor v) { v.visit(this);} } // Add the ability to produce a String: class StringVal implements Visitor { String s; @Override public String toString() { return s; } @Override public void visit(Gladiolus g) { s = "Gladiolus"; } @Override public void visit(Renuculus r) { s = "Renuculus"; } @Override public void visit(Chrysanthemum c) { s = "Chrysanthemum"; } } // Add the ability to do "Bee" activities: class Bee implements Visitor { @Override public void visit(Gladiolus g) { System.out.println("Bee and Gladiolus"); } @Override public void visit(Renuculus r) { System.out.println("Bee and Renuculus"); } @Override public void visit(Chrysanthemum c) { System.out.println("Bee and Chrysanthemum"); } } class FlowerFactory { static List> flowers = Arrays.asList(Gladiolus::new, Renuculus::new, Chrysanthemum::new); static final int SZ = flowers.size(); private static SplittableRandom rand = new SplittableRandom(47); public static Flower newFlower() { return flowers.get(rand.nextInt(SZ)).get(); } } public class BeeAndFlowers { public static void main(String[] args) { List flowers = Stream.generate(FlowerFactory::newFlower) .limit(10) .collect(Collectors.toList()); StringVal sval = new StringVal(); flowers.forEach(f -> { f.accept(sval); System.out.println(sval); }); // Perform "Bee" operation on all Flowers: Bee bee = new Bee(); flowers.forEach(f -> f.accept(bee)); } } /* Output: Gladiolus Chrysanthemum Gladiolus Renuculus Chrysanthemum Renuculus Chrysanthemum Chrysanthemum Chrysanthemum Renuculus Bee and Gladiolus Bee and Chrysanthemum Bee and Gladiolus Bee and Renuculus Bee and Chrysanthemum Bee and Renuculus Bee and Chrysanthemum Bee and Chrysanthemum Bee and Chrysanthemum Bee and Renuculus */ OnJava8-Examples-1.0/polymorphism/000077500000000000000000000000001374004044700171415ustar00rootroot00000000000000OnJava8-Examples-1.0/polymorphism/CovariantReturn.java000066400000000000000000000014021374004044700231270ustar00rootroot00000000000000// polymorphism/CovariantReturn.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Grain { @Override public String toString() { return "Grain"; } } class Wheat extends Grain { @Override public String toString() { return "Wheat"; } } class Mill { Grain process() { return new Grain(); } } class WheatMill extends Mill { @Override Wheat process() { return new Wheat(); } } public class CovariantReturn { public static void main(String[] args) { Mill m = new Mill(); Grain g = m.process(); System.out.println(g); m = new WheatMill(); g = m.process(); System.out.println(g); } } /* Output: Grain Wheat */ OnJava8-Examples-1.0/polymorphism/FieldAccess.java000066400000000000000000000017541374004044700221600ustar00rootroot00000000000000// polymorphism/FieldAccess.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Direct field access is determined at compile time class Super { public int field = 0; public int getField() { return field; } } class Sub extends Super { public int field = 1; @Override public int getField() { return field; } public int getSuperField() { return super.field; } } public class FieldAccess { public static void main(String[] args) { Super sup = new Sub(); // Upcast System.out.println("sup.field = " + sup.field + ", sup.getField() = " + sup.getField()); Sub sub = new Sub(); System.out.println("sub.field = " + sub.field + ", sub.getField() = " + sub.getField() + ", sub.getSuperField() = " + sub.getSuperField()); } } /* Output: sup.field = 0, sup.getField() = 1 sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0 */ OnJava8-Examples-1.0/polymorphism/Frog.java000066400000000000000000000057471374004044700207160ustar00rootroot00000000000000// polymorphism/Frog.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cleanup and inheritance // {java polymorphism.Frog} package polymorphism; class Characteristic { private String s; Characteristic(String s) { this.s = s; System.out.println("Creating Characteristic " + s); } protected void dispose() { System.out.println("disposing Characteristic " + s); } } class Description { private String s; Description(String s) { this.s = s; System.out.println("Creating Description " + s); } protected void dispose() { System.out.println("disposing Description " + s); } } class LivingCreature { private Characteristic p = new Characteristic("is alive"); private Description t = new Description("Basic Living Creature"); LivingCreature() { System.out.println("LivingCreature()"); } protected void dispose() { System.out.println("LivingCreature dispose"); t.dispose(); p.dispose(); } } class Animal extends LivingCreature { private Characteristic p = new Characteristic("has heart"); private Description t = new Description("Animal not Vegetable"); Animal() { System.out.println("Animal()"); } @Override protected void dispose() { System.out.println("Animal dispose"); t.dispose(); p.dispose(); super.dispose(); } } class Amphibian extends Animal { private Characteristic p = new Characteristic("can live in water"); private Description t = new Description("Both water and land"); Amphibian() { System.out.println("Amphibian()"); } @Override protected void dispose() { System.out.println("Amphibian dispose"); t.dispose(); p.dispose(); super.dispose(); } } public class Frog extends Amphibian { private Characteristic p = new Characteristic("Croaks"); private Description t = new Description("Eats Bugs"); public Frog() { System.out.println("Frog()"); } @Override protected void dispose() { System.out.println("Frog dispose"); t.dispose(); p.dispose(); super.dispose(); } public static void main(String[] args) { Frog frog = new Frog(); System.out.println("Bye!"); frog.dispose(); } } /* Output: Creating Characteristic is alive Creating Description Basic Living Creature LivingCreature() Creating Characteristic has heart Creating Description Animal not Vegetable Animal() Creating Characteristic can live in water Creating Description Both water and land Amphibian() Creating Characteristic Croaks Creating Description Eats Bugs Frog() Bye! Frog dispose disposing Description Eats Bugs disposing Characteristic Croaks Amphibian dispose disposing Description Both water and land disposing Characteristic can live in water Animal dispose disposing Description Animal not Vegetable disposing Characteristic has heart LivingCreature dispose disposing Description Basic Living Creature disposing Characteristic is alive */ OnJava8-Examples-1.0/polymorphism/PolyConstructors.java000066400000000000000000000017261374004044700233660ustar00rootroot00000000000000// polymorphism/PolyConstructors.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Constructors and polymorphism // don't produce what you might expect class Glyph { void draw() { System.out.println("Glyph.draw()"); } Glyph() { System.out.println("Glyph() before draw()"); draw(); System.out.println("Glyph() after draw()"); } } class RoundGlyph extends Glyph { private int radius = 1; RoundGlyph(int r) { radius = r; System.out.println( "RoundGlyph.RoundGlyph(), radius = " + radius); } @Override void draw() { System.out.println( "RoundGlyph.draw(), radius = " + radius); } } public class PolyConstructors { public static void main(String[] args) { new RoundGlyph(5); } } /* Output: Glyph() before draw() RoundGlyph.draw(), radius = 0 Glyph() after draw() RoundGlyph.RoundGlyph(), radius = 5 */ OnJava8-Examples-1.0/polymorphism/PrivateOverride.java000066400000000000000000000011551374004044700231200ustar00rootroot00000000000000// polymorphism/PrivateOverride.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Trying to override a private method // {java polymorphism.PrivateOverride} package polymorphism; public class PrivateOverride { private void f() { System.out.println("private f()"); } public static void main(String[] args) { PrivateOverride po = new Derived(); po.f(); } } class Derived extends PrivateOverride { public void f() { System.out.println("public f()"); } } /* Output: private f() */ OnJava8-Examples-1.0/polymorphism/PrivateOverride2.java000066400000000000000000000011341374004044700231770ustar00rootroot00000000000000// polymorphism/PrivateOverride2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Detecting a mistaken override using @Override // {WillNotCompile} package polymorphism; public class PrivateOverride2 { private void f() { System.out.println("private f()"); } public static void main(String[] args) { PrivateOverride2 po = new Derived2(); po.f(); } } class Derived2 extends PrivateOverride2 { @Override public void f() { System.out.println("public f()"); } } OnJava8-Examples-1.0/polymorphism/RTTI.java000066400000000000000000000017201374004044700205660ustar00rootroot00000000000000// polymorphism/RTTI.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Downcasting & Runtime type information (RTTI) // {ThrowsException} class Useful { public void f() {} public void g() {} } class MoreUseful extends Useful { @Override public void f() {} @Override public void g() {} public void u() {} public void v() {} public void w() {} } public class RTTI { public static void main(String[] args) { Useful[] x = { new Useful(), new MoreUseful() }; x[0].f(); x[1].g(); // Compile time: method not found in Useful: //- x[1].u(); ((MoreUseful)x[1]).u(); // Downcast/RTTI ((MoreUseful)x[0]).u(); // Exception thrown } } /* Output: ___[ Error Output ]___ Exception in thread "main" java.lang.ClassCastException: Useful cannot be cast to MoreUseful at RTTI.main(RTTI.java:31) */ OnJava8-Examples-1.0/polymorphism/ReferenceCounting.java000066400000000000000000000032061374004044700234120ustar00rootroot00000000000000// polymorphism/ReferenceCounting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cleaning up shared member objects class Shared { private int refcount = 0; private static long counter = 0; private final long id = counter++; Shared() { System.out.println("Creating " + this); } public void addRef() { refcount++; } protected void dispose() { if(--refcount == 0) System.out.println("Disposing " + this); } @Override public String toString() { return "Shared " + id; } } class Composing { private Shared shared; private static long counter = 0; private final long id = counter++; Composing(Shared shared) { System.out.println("Creating " + this); this.shared = shared; this.shared.addRef(); } protected void dispose() { System.out.println("disposing " + this); shared.dispose(); } @Override public String toString() { return "Composing " + id; } } public class ReferenceCounting { public static void main(String[] args) { Shared shared = new Shared(); Composing[] composing = { new Composing(shared), new Composing(shared), new Composing(shared), new Composing(shared), new Composing(shared) }; for(Composing c : composing) c.dispose(); } } /* Output: Creating Shared 0 Creating Composing 0 Creating Composing 1 Creating Composing 2 Creating Composing 3 Creating Composing 4 disposing Composing 0 disposing Composing 1 disposing Composing 2 disposing Composing 3 disposing Composing 4 Disposing Shared 0 */ OnJava8-Examples-1.0/polymorphism/Sandwich.java000066400000000000000000000020671374004044700215510ustar00rootroot00000000000000// polymorphism/Sandwich.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Order of constructor calls // {java polymorphism.Sandwich} package polymorphism; class Meal { Meal() { System.out.println("Meal()"); } } class Bread { Bread() { System.out.println("Bread()"); } } class Cheese { Cheese() { System.out.println("Cheese()"); } } class Lettuce { Lettuce() { System.out.println("Lettuce()"); } } class Lunch extends Meal { Lunch() { System.out.println("Lunch()"); } } class PortableLunch extends Lunch { PortableLunch() { System.out.println("PortableLunch()"); } } public class Sandwich extends PortableLunch { private Bread b = new Bread(); private Cheese c = new Cheese(); private Lettuce l = new Lettuce(); public Sandwich() { System.out.println("Sandwich()"); } public static void main(String[] args) { new Sandwich(); } } /* Output: Meal() Lunch() PortableLunch() Bread() Cheese() Lettuce() Sandwich() */ OnJava8-Examples-1.0/polymorphism/Shapes.java000066400000000000000000000011321374004044700212240ustar00rootroot00000000000000// polymorphism/Shapes.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Polymorphism in Java import polymorphism.shape.*; public class Shapes { public static void main(String[] args) { RandomShapes gen = new RandomShapes(); // Make polymorphic method calls: for(Shape shape : gen.array(9)) shape.draw(); } } /* Output: Triangle.draw() Triangle.draw() Square.draw() Triangle.draw() Square.draw() Triangle.draw() Square.draw() Triangle.draw() Circle.draw() */ OnJava8-Examples-1.0/polymorphism/StaticPolymorphism.java000066400000000000000000000015541374004044700236630ustar00rootroot00000000000000// polymorphism/StaticPolymorphism.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Static methods are not polymorphic class StaticSuper { public static String staticGet() { return "Base staticGet()"; } public String dynamicGet() { return "Base dynamicGet()"; } } class StaticSub extends StaticSuper { public static String staticGet() { return "Derived staticGet()"; } @Override public String dynamicGet() { return "Derived dynamicGet()"; } } public class StaticPolymorphism { public static void main(String[] args) { StaticSuper sup = new StaticSub(); // Upcast System.out.println(StaticSuper.staticGet()); System.out.println(sup.dynamicGet()); } } /* Output: Base staticGet() Derived dynamicGet() */ OnJava8-Examples-1.0/polymorphism/Transmogrify.java000066400000000000000000000016321374004044700224720ustar00rootroot00000000000000// polymorphism/Transmogrify.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Dynamically changing the behavior of an object // via composition (the "State" design pattern) class Actor { public void act() {} } class HappyActor extends Actor { @Override public void act() { System.out.println("HappyActor"); } } class SadActor extends Actor { @Override public void act() { System.out.println("SadActor"); } } class Stage { private Actor actor = new HappyActor(); public void change() { actor = new SadActor(); } public void performPlay() { actor.act(); } } public class Transmogrify { public static void main(String[] args) { Stage stage = new Stage(); stage.performPlay(); stage.change(); stage.performPlay(); } } /* Output: HappyActor SadActor */ OnJava8-Examples-1.0/polymorphism/music/000077500000000000000000000000001374004044700202615ustar00rootroot00000000000000OnJava8-Examples-1.0/polymorphism/music/Instrument.java000066400000000000000000000005101374004044700232700ustar00rootroot00000000000000// polymorphism/music/Instrument.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package polymorphism.music; class Instrument { public void play(Note n) { System.out.println("Instrument.play()"); } } OnJava8-Examples-1.0/polymorphism/music/Music.java000066400000000000000000000010261374004044700222030ustar00rootroot00000000000000// polymorphism/music/Music.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Inheritance & upcasting // {java polymorphism.music.Music} package polymorphism.music; public class Music { public static void tune(Instrument i) { // ... i.play(Note.MIDDLE_C); } public static void main(String[] args) { Wind flute = new Wind(); tune(flute); // Upcasting } } /* Output: Wind.play() MIDDLE_C */ OnJava8-Examples-1.0/polymorphism/music/Music2.java000066400000000000000000000021021374004044700222610ustar00rootroot00000000000000// polymorphism/music/Music2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Overloading instead of upcasting // {java polymorphism.music.Music2} package polymorphism.music; class Stringed extends Instrument { @Override public void play(Note n) { System.out.println("Stringed.play() " + n); } } class Brass extends Instrument { @Override public void play(Note n) { System.out.println("Brass.play() " + n); } } public class Music2 { public static void tune(Wind i) { i.play(Note.MIDDLE_C); } public static void tune(Stringed i) { i.play(Note.MIDDLE_C); } public static void tune(Brass i) { i.play(Note.MIDDLE_C); } public static void main(String[] args) { Wind flute = new Wind(); Stringed violin = new Stringed(); Brass frenchHorn = new Brass(); tune(flute); // No upcasting tune(violin); tune(frenchHorn); } } /* Output: Wind.play() MIDDLE_C Stringed.play() MIDDLE_C Brass.play() MIDDLE_C */ OnJava8-Examples-1.0/polymorphism/music/Note.java000066400000000000000000000005011374004044700220250ustar00rootroot00000000000000// polymorphism/music/Note.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Notes to play on musical instruments package polymorphism.music; public enum Note { MIDDLE_C, C_SHARP, B_FLAT; // Etc. } OnJava8-Examples-1.0/polymorphism/music/Wind.java000066400000000000000000000007121374004044700220250ustar00rootroot00000000000000// polymorphism/music/Wind.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package polymorphism.music; // Wind objects are instruments // because they have the same interface: public class Wind extends Instrument { // Redefine interface method: @Override public void play(Note n) { System.out.println("Wind.play() " + n); } } OnJava8-Examples-1.0/polymorphism/music3/000077500000000000000000000000001374004044700203445ustar00rootroot00000000000000OnJava8-Examples-1.0/polymorphism/music3/Music3.java000066400000000000000000000044321374004044700223550ustar00rootroot00000000000000// polymorphism/music3/Music3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // An extensible program // {java polymorphism.music3.Music3} package polymorphism.music3; import polymorphism.music.Note; class Instrument { void play(Note n) { System.out.println("Instrument.play() " + n); } String what() { return "Instrument"; } void adjust() { System.out.println("Adjusting Instrument"); } } class Wind extends Instrument { @Override void play(Note n) { System.out.println("Wind.play() " + n); } @Override String what() { return "Wind"; } @Override void adjust() { System.out.println("Adjusting Wind"); } } class Percussion extends Instrument { @Override void play(Note n) { System.out.println("Percussion.play() " + n); } @Override String what() { return "Percussion"; } @Override void adjust() { System.out.println("Adjusting Percussion"); } } class Stringed extends Instrument { @Override void play(Note n) { System.out.println("Stringed.play() " + n); } @Override String what() { return "Stringed"; } @Override void adjust() { System.out.println("Adjusting Stringed"); } } class Brass extends Wind { @Override void play(Note n) { System.out.println("Brass.play() " + n); } @Override void adjust() { System.out.println("Adjusting Brass"); } } class Woodwind extends Wind { @Override void play(Note n) { System.out.println("Woodwind.play() " + n); } @Override String what() { return "Woodwind"; } } public class Music3 { // Doesn't care about type, so new types // added to the system still work right: public static void tune(Instrument i) { // ... i.play(Note.MIDDLE_C); } public static void tuneAll(Instrument[] e) { for(Instrument i : e) tune(i); } public static void main(String[] args) { // Upcasting during addition to the array: Instrument[] orchestra = { new Wind(), new Percussion(), new Stringed(), new Brass(), new Woodwind() }; tuneAll(orchestra); } } /* Output: Wind.play() MIDDLE_C Percussion.play() MIDDLE_C Stringed.play() MIDDLE_C Brass.play() MIDDLE_C Woodwind.play() MIDDLE_C */ OnJava8-Examples-1.0/polymorphism/shape/000077500000000000000000000000001374004044700202415ustar00rootroot00000000000000OnJava8-Examples-1.0/polymorphism/shape/Circle.java000066400000000000000000000006511374004044700223070ustar00rootroot00000000000000// polymorphism/shape/Circle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package polymorphism.shape; public class Circle extends Shape { @Override public void draw() { System.out.println("Circle.draw()"); } @Override public void erase() { System.out.println("Circle.erase()"); } } OnJava8-Examples-1.0/polymorphism/shape/RandomShapes.java000066400000000000000000000013541374004044700234730ustar00rootroot00000000000000// polymorphism/shape/RandomShapes.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A "factory" that randomly creates shapes package polymorphism.shape; import java.util.*; public class RandomShapes { private Random rand = new Random(47); public Shape get() { switch(rand.nextInt(3)) { default: case 0: return new Circle(); case 1: return new Square(); case 2: return new Triangle(); } } public Shape[] array(int sz) { Shape[] shapes = new Shape[sz]; // Fill up the array with shapes: for(int i = 0; i < shapes.length; i++) shapes[i] = get(); return shapes; } } OnJava8-Examples-1.0/polymorphism/shape/Shape.java000066400000000000000000000004501374004044700221430ustar00rootroot00000000000000// polymorphism/shape/Shape.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package polymorphism.shape; public class Shape { public void draw() {} public void erase() {} } OnJava8-Examples-1.0/polymorphism/shape/Square.java000066400000000000000000000006511374004044700223460ustar00rootroot00000000000000// polymorphism/shape/Square.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package polymorphism.shape; public class Square extends Shape { @Override public void draw() { System.out.println("Square.draw()"); } @Override public void erase() { System.out.println("Square.erase()"); } } OnJava8-Examples-1.0/polymorphism/shape/Triangle.java000066400000000000000000000006611374004044700226540ustar00rootroot00000000000000// polymorphism/shape/Triangle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package polymorphism.shape; public class Triangle extends Shape { @Override public void draw() { System.out.println("Triangle.draw()"); } @Override public void erase() { System.out.println("Triangle.erase()"); } } OnJava8-Examples-1.0/references/000077500000000000000000000000001374004044700165205ustar00rootroot00000000000000OnJava8-Examples-1.0/references/AddingClone.java000066400000000000000000000034441374004044700215370ustar00rootroot00000000000000// references/AddingClone.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // You must go through a few gyrations // to add cloning to your own class import java.util.*; import java.util.stream.*; class Int2 implements Cloneable { private int i; Int2(int ii) { i = ii; } public void increment() { i++; } @Override public String toString() { return Integer.toString(i); } @Override public Int2 clone() { try { return (Int2)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } } // Inheritance doesn't remove cloneability: class Int3 extends Int2 { private int j; // Automatically duplicated Int3(int i) { super(i); } } public class AddingClone { @SuppressWarnings("unchecked") public static void main(String[] args) { Int2 x = new Int2(10); Int2 x2 = x.clone(); x2.increment(); System.out.println( "x = " + x + ", x2 = " + x2); // Anything inherited is also cloneable: Int3 x3 = new Int3(7); x3 = (Int3)x3.clone(); ArrayList v = IntStream.range(0, 10) .mapToObj(Int2::new) .collect(Collectors .toCollection(ArrayList::new)); System.out.println("v: " + v); ArrayList v2 = (ArrayList)v.clone(); // Now clone each element: IntStream.range(0, v.size()) .forEach(i -> v2.set(i, v.get(i).clone())); // Increment all v2's elements: v2.forEach(Int2::increment); System.out.println("v2: " + v2); // See if it changed v's elements: System.out.println("v: " + v); } } /* Output: x = 10, x2 = 11 v: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] v2: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] v: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] */ OnJava8-Examples-1.0/references/Alias1.java000066400000000000000000000012571374004044700205020ustar00rootroot00000000000000// references/Alias1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Aliasing two references to one object public class Alias1 { private int i; public Alias1(int ii) { i = ii; } public static void main(String[] args) { Alias1 x = new Alias1(7); Alias1 y = x; // Assign the reference (1) System.out.println("x: " + x.i); System.out.println("y: " + y.i); System.out.println("Incrementing x"); x.i++; // [2] System.out.println("x: " + x.i); System.out.println("y: " + y.i); } } /* Output: x: 7 y: 7 Incrementing x x: 8 y: 8 */ OnJava8-Examples-1.0/references/Alias2.java000066400000000000000000000011561374004044700205010ustar00rootroot00000000000000// references/Alias2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Method calls implicitly alias their arguments public class Alias2 { private int i; public Alias2(int i) { this.i = i; } public static void f(Alias2 reference) { reference.i++; } public static void main(String[] args) { Alias2 x = new Alias2(7); System.out.println("x: " + x.i); System.out.println("Calling f(x)"); f(x); System.out.println("x: " + x.i); } } /* Output: x: 7 Calling f(x) x: 8 */ OnJava8-Examples-1.0/references/CheckCloneable.java000066400000000000000000000054671374004044700222210ustar00rootroot00000000000000// references/CheckCloneable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Check to see if a reference can be cloned // Can't clone this -- doesn't override clone(): class Ordinary {} // Overrides clone, doesn't implement Cloneable: class WrongClone extends Ordinary { @Override public Object clone() throws CloneNotSupportedException { return super.clone(); // Throws exception } } // Does all the right things for cloning: class IsCloneable extends Ordinary implements Cloneable { @Override public Object clone() throws CloneNotSupportedException { return super.clone(); } } // Turn off cloning by throwing the exception: class NoMore extends IsCloneable { @Override public Object clone() throws CloneNotSupportedException { throw new CloneNotSupportedException(); } } class TryMore extends NoMore { @Override public Object clone() throws CloneNotSupportedException { // Calls NoMore.clone(), throws exception: return super.clone(); } } class BackOn extends NoMore { private BackOn duplicate(BackOn b) { // Somehow make a copy of b and return that // copy. A dummy copy, just to make a point: return new BackOn(); } @Override public Object clone() { // Doesn't call NoMore.clone(): return duplicate(this); } } // You can't inherit from this, so you can't // override clone() as you can in BackOn: final class ReallyNoMore extends NoMore {} public class CheckCloneable { public static Ordinary tryToClone(Ordinary ord) { String id = ord.getClass().getName(); System.out.println("Attempting " + id); Ordinary x = null; if(ord instanceof Cloneable) { try { x = (Ordinary)((IsCloneable)ord).clone(); System.out.println("Cloned " + id); } catch(CloneNotSupportedException e) { System.out.println( "Could not clone " + id); } } else { System.out.println("Doesn't implement Cloneable"); } return x; } public static void main(String[] args) { // Upcasting: Ordinary[] ord = { new IsCloneable(), new WrongClone(), new NoMore(), new TryMore(), new BackOn(), new ReallyNoMore(), }; Ordinary x = new Ordinary(); // This won't compile because // clone() is protected in Object: //- x = (Ordinary)x.clone(); // Checks first to see if the class // implements Cloneable: for(Ordinary ord1 : ord) { tryToClone(ord1); } } } /* Output: Attempting IsCloneable Cloned IsCloneable Attempting WrongClone Doesn't implement Cloneable Attempting NoMore Could not clone NoMore Attempting TryMore Could not clone TryMore Attempting BackOn Cloned BackOn Attempting ReallyNoMore Could not clone ReallyNoMore */ OnJava8-Examples-1.0/references/CloneArrayList.java000066400000000000000000000020451374004044700222570ustar00rootroot00000000000000// references/CloneArrayList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The clone() operation works for only a few // items in the standard Java library import java.util.*; import java.util.stream.*; class Int { private int i; Int(int ii) { i = ii; } public void increment() { i++; } @Override public String toString() { return Integer.toString(i); } } public class CloneArrayList { public static void main(String[] args) { ArrayList v = IntStream.range(0, 10) .mapToObj(Int::new) .collect(Collectors .toCollection(ArrayList::new)); System.out.println("v: " + v); @SuppressWarnings("unchecked") ArrayList v2 = (ArrayList)v.clone(); // Increment all v2's elements: v2.forEach(Int::increment); // See if it changed v's elements: System.out.println("v: " + v); } } /* Output: v: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] v: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] */ OnJava8-Examples-1.0/references/Compete.java000066400000000000000000000043011374004044700207550ustar00rootroot00000000000000// references/Compete.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import onjava.Timer; class Thing1 implements Serializable {} class Thing2 implements Serializable { Thing1 t1 = new Thing1(); } class Thing3 implements Cloneable { @Override public Thing3 clone() { try { return (Thing3)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } } class Thing4 implements Cloneable { private Thing3 t3 = new Thing3(); @Override public Thing4 clone() { Thing4 t4 = null; try { t4 = (Thing4)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } // Clone the field, too: t4.t3 = t3.clone(); return t4; } } public class Compete { public static final int SIZE = 100000; public static void main(String[] args) throws Exception { Thing2[] a = new Thing2[SIZE]; for(int i = 0; i < SIZE; i++) a[i] = new Thing2(); Thing4[] b = new Thing4[SIZE]; for(int i = 0; i < SIZE; i++) b[i] = new Thing4(); Timer timer = new Timer(); try( ByteArrayOutputStream buf = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(buf) ) { for(Thing2 a1 : a) { oos.writeObject(a1); } // Now get copies: try( ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream( buf.toByteArray())) ) { Thing2[] c = new Thing2[SIZE]; for(int i = 0; i < SIZE; i++) c[i] = (Thing2)in.readObject(); } } System.out.println( "Duplication via serialization: " + timer.duration() + " Milliseconds"); // Now try cloning: timer = new Timer(); Thing4[] d = new Thing4[SIZE]; for(int i = 0; i < SIZE; i++) d[i] = b[i].clone(); System.out.println( "Duplication via cloning: " + timer.duration() + " Milliseconds"); } } /* Output: Duplication via serialization: 516 Milliseconds Duplication via cloning: 71 Milliseconds */ OnJava8-Examples-1.0/references/CopyConstructor.java000066400000000000000000000113401374004044700225420ustar00rootroot00000000000000// references/CopyConstructor.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A constructor to copy an object of the same // type, as an attempt to create a local copy import java.lang.reflect.*; class FruitQualities { private int weight; private int color; private int firmness; private int ripeness; private int smell; // etc. // No-arg constructor: FruitQualities() { // Do something meaningful... } // Other constructors: // ... // Copy constructor: FruitQualities(FruitQualities f) { weight = f.weight; color = f.color; firmness = f.firmness; ripeness = f.ripeness; smell = f.smell; // etc. } } class Seed { // Members... Seed() { /* No-arg constructor */ } Seed(Seed s) { /* Copy constructor */ } } class Fruit { private FruitQualities fq; private int seeds; private Seed[] s; Fruit(FruitQualities q, int seedCount) { fq = q; seeds = seedCount; s = new Seed[seeds]; for(int i = 0; i < seeds; i++) s[i] = new Seed(); } // Other constructors: // ... // Copy constructor: Fruit(Fruit f) { fq = new FruitQualities(f.fq); seeds = f.seeds; s = new Seed[seeds]; // Call all Seed copy-constructors: for(int i = 0; i < seeds; i++) s[i] = new Seed(f.s[i]); // Other copy-construction activities... } // This allows derived constructors (or other // methods) to put in different qualities: protected void addQualities(FruitQualities q) { fq = q; } protected FruitQualities getQualities() { return fq; } } class Tomato extends Fruit { Tomato() { super(new FruitQualities(), 100); } Tomato(Tomato t) { // Copy-constructor super(t); // Upcast to base copy-constructor // Other copy-construction activities... } } class ZebraQualities extends FruitQualities { private int stripedness; // No-arg constructor: ZebraQualities() { super(); // do something meaningful... } ZebraQualities(ZebraQualities z) { super(z); stripedness = z.stripedness; } } class GreenZebra extends Tomato { GreenZebra() { addQualities(new ZebraQualities()); } GreenZebra(GreenZebra g) { super(g); // Calls Tomato(Tomato) // Restore the right qualities: addQualities(new ZebraQualities()); } public void evaluate() { ZebraQualities zq = (ZebraQualities)getQualities(); // Do something with the qualities // ... } } public class CopyConstructor { public static void ripen(Tomato t) { // Use the "copy constructor": t = new Tomato(t); // [1] System.out.println("In ripen, t is a " + t.getClass().getName()); } public static void slice(Fruit f) { f = new Fruit(f); // [2] Hmmm... will this work? System.out.println("In slice, f is a " + f.getClass().getName()); } @SuppressWarnings("unchecked") public static void ripen2(Tomato t) { try { Class c = t.getClass(); // Use the "copy constructor": Constructor ct = c.getConstructor(new Class[] { c }); Object obj = ct.newInstance(new Object[] { t }); System.out.println("In ripen2, t is a " + obj.getClass().getName()); } catch(NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { System.out.println(e); } } @SuppressWarnings("unchecked") public static void slice2(Fruit f) { try { Class c = f.getClass(); Constructor ct = c.getConstructor(new Class[] { c }); Object obj = ct.newInstance(new Object[] { f }); System.out.println("In slice2, f is a " + obj.getClass().getName()); } catch(NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { System.out.println(e); } } public static void main(String[] args) { Tomato tomato = new Tomato(); ripen(tomato); // OK slice(tomato); // OOPS! ripen2(tomato); // OK slice2(tomato); // OK GreenZebra g = new GreenZebra(); ripen(g); // OOPS! slice(g); // OOPS! ripen2(g); // OK slice2(g); // OK g.evaluate(); } } /* Output: In ripen, t is a Tomato In slice, f is a Fruit java.lang.NoSuchMethodException: Tomato.(Tomato) java.lang.NoSuchMethodException: Tomato.(Tomato) In ripen, t is a Tomato In slice, f is a Fruit java.lang.NoSuchMethodException: GreenZebra.(GreenZebra) java.lang.NoSuchMethodException: GreenZebra.(GreenZebra) */ OnJava8-Examples-1.0/references/DepthReading.java000066400000000000000000000013731374004044700217250ustar00rootroot00000000000000// references/DepthReading.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cloning a composed object package references; public class DepthReading implements Cloneable { private double depth; public DepthReading(double depth) { this.depth = depth; } @Override public DepthReading clone() { try { return (DepthReading)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } public double getDepth() { return depth; } public void setDepth(double depth) { this.depth = depth; } @Override public String toString() { return String.valueOf(depth); } } OnJava8-Examples-1.0/references/HorrorFlick.java000066400000000000000000000016331374004044700216120ustar00rootroot00000000000000// references/HorrorFlick.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Insert Cloneability at any level of inheritance class Person {} class Hero extends Person {} class Scientist extends Person implements Cloneable { @Override public Scientist clone() { try { return (Scientist)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } } class MadScientist extends Scientist {} public class HorrorFlick { public static void main(String[] args) { Person p = new Person(); Hero h = new Hero(); Scientist s = new Scientist(); MadScientist m = new MadScientist(); //- p = (Person)p.clone(); // Compile error //- h = (Hero)h.clone(); // Compile error s = s.clone(); m = (MadScientist)m.clone(); } } OnJava8-Examples-1.0/references/Immutable1.java000066400000000000000000000016441374004044700213700ustar00rootroot00000000000000// references/Immutable1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Immutable objects are immune to aliasing public class Immutable1 { private int data; public Immutable1(int initVal) { data = initVal; } public int read() { return data; } public boolean nonzero() { return data != 0; } public Immutable1 multiply(int multiplier) { return new Immutable1(data * multiplier); } public static void f(Immutable1 i1) { Immutable1 quad = i1.multiply(4); System.out.println("i1 = " + i1.read()); System.out.println("quad = " + quad.read()); } public static void main(String[] args) { Immutable1 x = new Immutable1(47); System.out.println("x = " + x.read()); f(x); System.out.println("x = " + x.read()); } } /* Output: x = 47 i1 = 47 quad = 188 x = 47 */ OnJava8-Examples-1.0/references/Immutable2.java000066400000000000000000000032141374004044700213640ustar00rootroot00000000000000// references/Immutable2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A companion class to modify immutable objects class Mutable { private int data; Mutable(int initVal) { data = initVal; } public Mutable add(int x) { data += x; return this; } public Mutable multiply(int x) { data *= x; return this; } public Immutable2 makeImmutable2() { return new Immutable2(data); } } public class Immutable2 { private int data; public Immutable2(int initVal) { data = initVal; } public int read() { return data; } public boolean nonzero() { return data != 0; } public Immutable2 add(int x) { return new Immutable2(data + x); } public Immutable2 multiply(int x) { return new Immutable2(data * x); } public Mutable makeMutable() { return new Mutable(data); } public static Immutable2 modify1(Immutable2 y) { Immutable2 val = y.add(12); val = val.multiply(3); val = val.add(11); val = val.multiply(2); return val; } // This produces the same result: public static Immutable2 modify2(Immutable2 y) { Mutable m = y.makeMutable(); m.add(12).multiply(3).add(11).multiply(2); return m.makeImmutable2(); } public static void main(String[] args) { Immutable2 i2 = new Immutable2(47); Immutable2 r1 = modify1(i2); Immutable2 r2 = modify2(i2); System.out.println("i2 = " + i2.read()); System.out.println("r1 = " + r1.read()); System.out.println("r2 = " + r2.read()); } } /* Output: i2 = 47 r1 = 376 r2 = 376 */ OnJava8-Examples-1.0/references/ImmutableInteger.java000066400000000000000000000012131374004044700226150ustar00rootroot00000000000000// references/ImmutableInteger.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The Integer class cannot be changed import java.util.*; import java.util.stream.*; public class ImmutableInteger { public static void main(String[] args) { @SuppressWarnings("deprecation") List v = IntStream.range(0, 10) .mapToObj(Integer::new) .collect(Collectors.toList()); System.out.println(v); // But how do you change the int // inside the Integer? } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] */ OnJava8-Examples-1.0/references/ImmutableStrings.java000066400000000000000000000013041374004044700226520ustar00rootroot00000000000000// references/ImmutableStrings.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrating StringBuilder public class ImmutableStrings { public static void main(String[] args) { String foo = "foo"; String s = "abc" + foo + "def" + Integer.toString(47); System.out.println(s); // The "equivalent" using StringBuilder: StringBuilder sb = new StringBuilder("abc"); // Creates String sb.append(foo); sb.append("def"); // Creates String sb.append(Integer.toString(47)); System.out.println(sb); } } /* Output: abcfoodef47 abcfoodef47 */ OnJava8-Examples-1.0/references/LocalCopy.java000066400000000000000000000025531374004044700212550ustar00rootroot00000000000000// references/LocalCopy.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creating local copies with clone() class Duplo implements Cloneable { private int n; Duplo(int n) { this.n = n; } @Override public Duplo clone() { // [1] try { return (Duplo)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } public int getValue() { return n; } public void setValue(int n) { this.n = n; } public void increment() { n++; } @Override public String toString() { return Integer.toString(n); } } public class LocalCopy { public static Duplo g(Duplo v) { // Passing a reference, modifies outside object: v.increment(); return v; } public static Duplo f(Duplo v) { v = v.clone(); // [2] Local copy v.increment(); return v; } public static void main(String[] args) { Duplo a = new Duplo(11); Duplo b = g(a); // Reference equivalence, not object equivalence: System.out.println("a == b: " + (a == b) + "\na = " + a + "\nb = " + b); Duplo c = new Duplo(47); Duplo d = f(c); System.out.println("c == d: " + (c == d) + "\nc = " + c + "\nd = " + d); } } /* Output: a == b: true a = 12 b = 12 c == d: false c = 47 d = 48 */ OnJava8-Examples-1.0/references/MutableInteger.java000066400000000000000000000016001374004044700222670ustar00rootroot00000000000000// references/MutableInteger.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A changeable wrapper class import java.util.*; import java.util.stream.*; class IntValue { private int n; IntValue(int x) { n = x; } public int getValue() { return n; } public void setValue(int n) { this.n = n; } public void increment() { n++; } @Override public String toString() { return Integer.toString(n); } } public class MutableInteger { public static void main(String[] args) { List v = IntStream.range(0, 10) .mapToObj(IntValue::new) .collect(Collectors.toList()); System.out.println(v); v.forEach(IntValue::increment); System.out.println(v); } } /* Output: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] */ OnJava8-Examples-1.0/references/OceanReading.java000066400000000000000000000024371374004044700217100ustar00rootroot00000000000000// references/OceanReading.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cloning a composed object package references; public class OceanReading implements Cloneable { private DepthReading depth; private TemperatureReading temperature; public OceanReading(double tdata, double ddata) { temperature = new TemperatureReading(tdata); depth = new DepthReading(ddata); } @Override public OceanReading clone() { OceanReading or = null; try { or = (OceanReading)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } // Must clone references: or.depth = (DepthReading)or.depth.clone(); or.temperature = (TemperatureReading)or.temperature.clone(); return or; } public TemperatureReading getTemperatureReading() { return temperature; } public void setTemperatureReading(TemperatureReading tr) { temperature = tr; } public DepthReading getDepthReading() { return depth; } public void setDepthReading(DepthReading dr) { this.depth = dr; } @Override public String toString() { return "temperature: " + temperature + ", depth: " + depth; } } OnJava8-Examples-1.0/references/PassReferences.java000066400000000000000000000010661374004044700222760ustar00rootroot00000000000000// references/PassReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class PassReferences { public static void f(PassReferences h) { System.out.println("h inside f(): " + h); } public static void main(String[] args) { PassReferences p = new PassReferences(); System.out.println("p inside main(): " + p); f(p); } } /* Output: p inside main(): PassReferences@15db9742 h inside f(): PassReferences@15db9742 */ OnJava8-Examples-1.0/references/SimplerMutableInteger.java000066400000000000000000000014211374004044700236240ustar00rootroot00000000000000// references/SimplerMutableInteger.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A trivial wrapper class import java.util.*; import java.util.stream.*; class IntValue2 { public int n; IntValue2(int n) { this.n = n; } } public class SimplerMutableInteger { public static void main(String[] args) { List v = IntStream.range(0, 10) .mapToObj(IntValue2::new) .collect(Collectors.toList()); v.forEach(iv2 -> System.out.print(iv2.n + " ")); System.out.println(); v.forEach(iv2 -> iv2.n += 1); v.forEach(iv2 -> System.out.print(iv2.n + " ")); } } /* Output: 0 1 2 3 4 5 6 7 8 9 1 2 3 4 5 6 7 8 9 10 */ OnJava8-Examples-1.0/references/Snake.java000066400000000000000000000023021374004044700204210ustar00rootroot00000000000000// references/Snake.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Tests cloning to see if reference // destinations are also cloned public class Snake implements Cloneable { private Snake next; private char c; // Value of i == number of segments public Snake(int i, char x) { c = x; if(--i > 0) next = new Snake(i, (char)(x + 1)); } public void increment() { c++; if(next != null) next.increment(); } @Override public String toString() { String s = ":" + c; if(next != null) s += next.toString(); return s; } @Override public Snake clone() { try { return (Snake)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } public static void main(String[] args) { Snake s = new Snake(5, 'a'); System.out.println("s = " + s); Snake s2 = s.clone(); System.out.println("s2 = " + s2); s.increment(); System.out.println( "after s.increment, s2 = " + s2); } } /* Output: s = :a:b:c:d:e s2 = :a:b:c:d:e after s.increment, s2 = :a:c:d:e:f */ OnJava8-Examples-1.0/references/Stringer.java000066400000000000000000000010361374004044700211600ustar00rootroot00000000000000// references/Stringer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Stringer { public static String upcase(String s) { return s.toUpperCase(); } public static void main(String[] args) { String q = new String("howdy"); System.out.println(q); // howdy String qq = upcase(q); System.out.println(qq); // HOWDY System.out.println(q); // howdy } } /* Output: howdy HOWDY howdy */ OnJava8-Examples-1.0/references/TemperatureReading.java000066400000000000000000000016171374004044700231570ustar00rootroot00000000000000// references/TemperatureReading.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Cloning a composed object package references; public class TemperatureReading implements Cloneable { private long time; private double temperature; public TemperatureReading(double temperature) { time = System.currentTimeMillis(); this.temperature = temperature; } @Override public TemperatureReading clone() { try { return (TemperatureReading)super.clone(); } catch(CloneNotSupportedException e) { throw new RuntimeException(e); } } public double getTemperature() { return temperature; } public void setTemperature(double temp) { this.temperature = temp; } @Override public String toString() { return String.valueOf(temperature); } } OnJava8-Examples-1.0/references/tests/000077500000000000000000000000001374004044700176625ustar00rootroot00000000000000OnJava8-Examples-1.0/references/tests/DeepCopyTest.java000066400000000000000000000016301374004044700230750ustar00rootroot00000000000000// references/tests/DeepCopyTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package references; import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; public class DeepCopyTest { @Test public void testClone() { OceanReading reading = new OceanReading(33.9, 100.5); // Now clone it: OceanReading clone = reading.clone(); TemperatureReading tr = clone.getTemperatureReading(); tr.setTemperature(tr.getTemperature() + 1); clone.setTemperatureReading(tr); DepthReading dr = clone.getDepthReading(); dr.setDepth(dr.getDepth() + 1); clone.setDepthReading(dr); assertEquals(reading.toString(), "temperature: 33.9, depth: 100.5"); assertEquals(clone.toString(), "temperature: 34.9, depth: 101.5"); } } OnJava8-Examples-1.0/reuse/000077500000000000000000000000001374004044700155225ustar00rootroot00000000000000OnJava8-Examples-1.0/reuse/Bath.java000066400000000000000000000024021374004044700172410ustar00rootroot00000000000000// reuse/Bath.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Constructor initialization with composition class Soap { private String s; Soap() { System.out.println("Soap()"); s = "Constructed"; } @Override public String toString() { return s; } } public class Bath { private String // Initializing at point of definition: s1 = "Happy", s2 = "Happy", s3, s4; private Soap castille; private int i; private float toy; public Bath() { System.out.println("Inside Bath()"); s3 = "Joy"; toy = 3.14f; castille = new Soap(); } // Instance initialization: { i = 47; } @Override public String toString() { if(s4 == null) // Delayed initialization: s4 = "Joy"; return "s1 = " + s1 + "\n" + "s2 = " + s2 + "\n" + "s3 = " + s3 + "\n" + "s4 = " + s4 + "\n" + "i = " + i + "\n" + "toy = " + toy + "\n" + "castille = " + castille; } public static void main(String[] args) { Bath b = new Bath(); System.out.println(b); } } /* Output: Inside Bath() Soap() s1 = Happy s2 = Happy s3 = Joy s4 = Joy i = 47 toy = 3.14 castille = Constructed */ OnJava8-Examples-1.0/reuse/Beetle.java000066400000000000000000000020141374004044700175620ustar00rootroot00000000000000// reuse/Beetle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The full process of initialization class Insect { private int i = 9; protected int j; Insect() { System.out.println("i = " + i + ", j = " + j); j = 39; } private static int x1 = printInit("static Insect.x1 initialized"); static int printInit(String s) { System.out.println(s); return 47; } } public class Beetle extends Insect { private int k = printInit("Beetle.k initialized"); public Beetle() { System.out.println("k = " + k); System.out.println("j = " + j); } private static int x2 = printInit("static Beetle.x2 initialized"); public static void main(String[] args) { System.out.println("Beetle constructor"); Beetle b = new Beetle(); } } /* Output: static Insect.x1 initialized static Beetle.x2 initialized Beetle constructor i = 9, j = 0 Beetle.k initialized k = 47 j = 39 */ OnJava8-Examples-1.0/reuse/BlankFinal.java000066400000000000000000000014751374004044700203750ustar00rootroot00000000000000// reuse/BlankFinal.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // "Blank" final fields class Poppet { private int i; Poppet(int ii) { i = ii; } } public class BlankFinal { private final int i = 0; // Initialized final private final int j; // Blank final private final Poppet p; // Blank final reference // Blank finals MUST be initialized in constructor: public BlankFinal() { j = 1; // Initialize blank final p = new Poppet(1); // Init blank final reference } public BlankFinal(int x) { j = x; // Initialize blank final p = new Poppet(x); // Init blank final reference } public static void main(String[] args) { new BlankFinal(); new BlankFinal(47); } } OnJava8-Examples-1.0/reuse/CADSystem.java000066400000000000000000000045601374004044700201660ustar00rootroot00000000000000// reuse/CADSystem.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Ensuring proper cleanup // {java reuse.CADSystem} package reuse; class Shape { Shape(int i) { System.out.println("Shape constructor"); } void dispose() { System.out.println("Shape dispose"); } } class Circle extends Shape { Circle(int i) { super(i); System.out.println("Drawing Circle"); } @Override void dispose() { System.out.println("Erasing Circle"); super.dispose(); } } class Triangle extends Shape { Triangle(int i) { super(i); System.out.println("Drawing Triangle"); } @Override void dispose() { System.out.println("Erasing Triangle"); super.dispose(); } } class Line extends Shape { private int start, end; Line(int start, int end) { super(start); this.start = start; this.end = end; System.out.println( "Drawing Line: " + start + ", " + end); } @Override void dispose() { System.out.println( "Erasing Line: " + start + ", " + end); super.dispose(); } } public class CADSystem extends Shape { private Circle c; private Triangle t; private Line[] lines = new Line[3]; public CADSystem(int i) { super(i + 1); for(int j = 0; j < lines.length; j++) lines[j] = new Line(j, j*j); c = new Circle(1); t = new Triangle(1); System.out.println("Combined constructor"); } @Override public void dispose() { System.out.println("CADSystem.dispose()"); // The order of cleanup is the reverse // of the order of initialization: t.dispose(); c.dispose(); for(int i = lines.length - 1; i >= 0; i--) lines[i].dispose(); super.dispose(); } public static void main(String[] args) { CADSystem x = new CADSystem(47); try { // Code and exception handling... } finally { x.dispose(); } } } /* Output: Shape constructor Shape constructor Drawing Line: 0, 0 Shape constructor Drawing Line: 1, 1 Shape constructor Drawing Line: 2, 4 Shape constructor Drawing Circle Shape constructor Drawing Triangle Combined constructor CADSystem.dispose() Erasing Triangle Shape dispose Erasing Circle Shape dispose Erasing Line: 2, 4 Shape dispose Erasing Line: 1, 1 Shape dispose Erasing Line: 0, 0 Shape dispose Shape dispose */ OnJava8-Examples-1.0/reuse/Car.java000066400000000000000000000016251374004044700170760ustar00rootroot00000000000000// reuse/Car.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Composition with public objects class Engine { public void start() {} public void rev() {} public void stop() {} } class Wheel { public void inflate(int psi) {} } class Window { public void rollup() {} public void rolldown() {} } class Door { public Window window = new Window(); public void open() {} public void close() {} } public class Car { public Engine engine = new Engine(); public Wheel[] wheel = new Wheel[4]; public Door left = new Door(), right = new Door(); // 2-door public Car() { for(int i = 0; i < 4; i++) wheel[i] = new Wheel(); } public static void main(String[] args) { Car car = new Car(); car.left.window.rollup(); car.wheel[0].inflate(72); } } OnJava8-Examples-1.0/reuse/Cartoon.java000066400000000000000000000012161374004044700177720ustar00rootroot00000000000000// reuse/Cartoon.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Constructor calls during inheritance class Art { Art() { System.out.println("Art constructor"); } } class Drawing extends Art { Drawing() { System.out.println("Drawing constructor"); } } public class Cartoon extends Drawing { public Cartoon() { System.out.println("Cartoon constructor"); } public static void main(String[] args) { Cartoon x = new Cartoon(); } } /* Output: Art constructor Drawing constructor Cartoon constructor */ OnJava8-Examples-1.0/reuse/Chess.java000066400000000000000000000012621374004044700174330ustar00rootroot00000000000000// reuse/Chess.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Inheritance, constructors and arguments class Game { Game(int i) { System.out.println("Game constructor"); } } class BoardGame extends Game { BoardGame(int i) { super(i); System.out.println("BoardGame constructor"); } } public class Chess extends BoardGame { Chess() { super(11); System.out.println("Chess constructor"); } public static void main(String[] args) { Chess x = new Chess(); } } /* Output: Game constructor BoardGame constructor Chess constructor */ OnJava8-Examples-1.0/reuse/DerivedSpaceShip.java000066400000000000000000000010541374004044700215470ustar00rootroot00000000000000// reuse/DerivedSpaceShip.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class DerivedSpaceShip extends SpaceShipControls { private String name; public DerivedSpaceShip(String name) { this.name = name; } @Override public String toString() { return name; } public static void main(String[] args) { DerivedSpaceShip protector = new DerivedSpaceShip("NSEA Protector"); protector.forward(100); } } OnJava8-Examples-1.0/reuse/Detergent.java000066400000000000000000000024421374004044700203100ustar00rootroot00000000000000// reuse/Detergent.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Inheritance syntax & properties class Cleanser { private String s = "Cleanser"; public void append(String a) { s += a; } public void dilute() { append(" dilute()"); } public void apply() { append(" apply()"); } public void scrub() { append(" scrub()"); } @Override public String toString() { return s; } public static void main(String[] args) { Cleanser x = new Cleanser(); x.dilute(); x.apply(); x.scrub(); System.out.println(x); } } public class Detergent extends Cleanser { // Change a method: @Override public void scrub() { append(" Detergent.scrub()"); super.scrub(); // Call base-class version } // Add methods to the interface: public void foam() { append(" foam()"); } // Test the new class: public static void main(String[] args) { Detergent x = new Detergent(); x.dilute(); x.apply(); x.scrub(); x.foam(); System.out.println(x); System.out.println("Testing base class:"); Cleanser.main(args); } } /* Output: Cleanser dilute() apply() Detergent.scrub() scrub() foam() Testing base class: Cleanser dilute() apply() scrub() */ OnJava8-Examples-1.0/reuse/FinalArguments.java000066400000000000000000000013471374004044700213110ustar00rootroot00000000000000// reuse/FinalArguments.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using "final" with method arguments class Gizmo { public void spin() {} } public class FinalArguments { void with(final Gizmo g) { //- g = new Gizmo(); // Illegal -- g is final } void without(Gizmo g) { g = new Gizmo(); // OK -- g not final g.spin(); } // void f(final int i) { i++; } // Can't change // You can only read from a final primitive: int g(final int i) { return i + 1; } public static void main(String[] args) { FinalArguments bf = new FinalArguments(); bf.without(null); bf.with(null); } } OnJava8-Examples-1.0/reuse/FinalData.java000066400000000000000000000034221374004044700202110ustar00rootroot00000000000000// reuse/FinalData.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The effect of final on fields import java.util.*; class Value { int i; // Package access Value(int i) { this.i = i; } } public class FinalData { private static Random rand = new Random(47); private String id; public FinalData(String id) { this.id = id; } // Can be compile-time constants: private final int valueOne = 9; private static final int VALUE_TWO = 99; // Typical public constant: public static final int VALUE_THREE = 39; // Cannot be compile-time constants: private final int i4 = rand.nextInt(20); static final int INT_5 = rand.nextInt(20); private Value v1 = new Value(11); private final Value v2 = new Value(22); private static final Value VAL_3 = new Value(33); // Arrays: private final int[] a = { 1, 2, 3, 4, 5, 6 }; @Override public String toString() { return id + ": " + "i4 = " + i4 + ", INT_5 = " + INT_5; } public static void main(String[] args) { FinalData fd1 = new FinalData("fd1"); //- fd1.valueOne++; // Error: can't change value fd1.v2.i++; // Object isn't constant! fd1.v1 = new Value(9); // OK -- not final for(int i = 0; i < fd1.a.length; i++) fd1.a[i]++; // Object isn't constant! //- fd1.v2 = new Value(0); // Error: Can't //- fd1.VAL_3 = new Value(1); // change reference //- fd1.a = new int[3]; System.out.println(fd1); System.out.println("Creating new FinalData"); FinalData fd2 = new FinalData("fd2"); System.out.println(fd1); System.out.println(fd2); } } /* Output: fd1: i4 = 15, INT_5 = 18 Creating new FinalData fd1: i4 = 15, INT_5 = 18 fd2: i4 = 13, INT_5 = 18 */ OnJava8-Examples-1.0/reuse/FinalOverridingIllusion.java000066400000000000000000000025051374004044700231700ustar00rootroot00000000000000// reuse/FinalOverridingIllusion.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // It only looks like you can override // a private or private final method class WithFinals { // Identical to "private" alone: private final void f() { System.out.println("WithFinals.f()"); } // Also automatically "final": private void g() { System.out.println("WithFinals.g()"); } } class OverridingPrivate extends WithFinals { private final void f() { System.out.println("OverridingPrivate.f()"); } private void g() { System.out.println("OverridingPrivate.g()"); } } class OverridingPrivate2 extends OverridingPrivate { public final void f() { System.out.println("OverridingPrivate2.f()"); } public void g() { System.out.println("OverridingPrivate2.g()"); } } public class FinalOverridingIllusion { public static void main(String[] args) { OverridingPrivate2 op2 = new OverridingPrivate2(); op2.f(); op2.g(); // You can upcast: OverridingPrivate op = op2; // But you can't call the methods: //- op.f(); //- op.g(); // Same here: WithFinals wf = op2; //- wf.f(); //- wf.g(); } } /* Output: OverridingPrivate2.f() OverridingPrivate2.g() */ OnJava8-Examples-1.0/reuse/Hide.java000066400000000000000000000014461374004044700172430ustar00rootroot00000000000000// reuse/Hide.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Overloading a base-class method name in a derived // class does not hide the base-class versions class Homer { char doh(char c) { System.out.println("doh(char)"); return 'd'; } float doh(float f) { System.out.println("doh(float)"); return 1.0f; } } class Milhouse {} class Bart extends Homer { void doh(Milhouse m) { System.out.println("doh(Milhouse)"); } } public class Hide { public static void main(String[] args) { Bart b = new Bart(); b.doh(1); b.doh('x'); b.doh(1.0f); b.doh(new Milhouse()); } } /* Output: doh(float) doh(char) doh(float) doh(Milhouse) */ OnJava8-Examples-1.0/reuse/Jurassic.java000066400000000000000000000010701374004044700201460ustar00rootroot00000000000000// reuse/Jurassic.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Making an entire class final class SmallBrain {} final class Dinosaur { int i = 7; int j = 1; SmallBrain x = new SmallBrain(); void f() {} } //- class Further extends Dinosaur {} // error: Cannot extend final class 'Dinosaur' public class Jurassic { public static void main(String[] args) { Dinosaur n = new Dinosaur(); n.f(); n.i = 40; n.j++; } } OnJava8-Examples-1.0/reuse/Lisa.java000066400000000000000000000004671374004044700172640ustar00rootroot00000000000000// reuse/Lisa.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {WillNotCompile} class Lisa extends Homer { @Override void doh(Milhouse m) { System.out.println("doh(Milhouse)"); } } OnJava8-Examples-1.0/reuse/Orc.java000066400000000000000000000021241374004044700171070ustar00rootroot00000000000000// reuse/Orc.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The protected keyword class Villain { private String name; protected void set(String nm) { name = nm; } Villain(String name) { this.name = name; } @Override public String toString() { return "I'm a Villain and my name is " + name; } } public class Orc extends Villain { private int orcNumber; public Orc(String name, int orcNumber) { super(name); this.orcNumber = orcNumber; } public void change(String name, int orcNumber) { set(name); // Available because it's protected this.orcNumber = orcNumber; } @Override public String toString() { return "Orc " + orcNumber + ": " + super.toString(); } public static void main(String[] args) { Orc orc = new Orc("Limburger", 12); System.out.println(orc); orc.change("Bob", 19); System.out.println(orc); } } /* Output: Orc 12: I'm a Villain and my name is Limburger Orc 19: I'm a Villain and my name is Bob */ OnJava8-Examples-1.0/reuse/PlaceSetting.java000066400000000000000000000031521374004044700207500ustar00rootroot00000000000000// reuse/PlaceSetting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Combining composition & inheritance class Plate { Plate(int i) { System.out.println("Plate constructor"); } } class DinnerPlate extends Plate { DinnerPlate(int i) { super(i); System.out.println("DinnerPlate constructor"); } } class Utensil { Utensil(int i) { System.out.println("Utensil constructor"); } } class Spoon extends Utensil { Spoon(int i) { super(i); System.out.println("Spoon constructor"); } } class Fork extends Utensil { Fork(int i) { super(i); System.out.println("Fork constructor"); } } class Knife extends Utensil { Knife(int i) { super(i); System.out.println("Knife constructor"); } } // A cultural way of doing something: class Custom { Custom(int i) { System.out.println("Custom constructor"); } } public class PlaceSetting extends Custom { private Spoon sp; private Fork frk; private Knife kn; private DinnerPlate pl; public PlaceSetting(int i) { super(i + 1); sp = new Spoon(i + 2); frk = new Fork(i + 3); kn = new Knife(i + 4); pl = new DinnerPlate(i + 5); System.out.println("PlaceSetting constructor"); } public static void main(String[] args) { PlaceSetting x = new PlaceSetting(9); } } /* Output: Custom constructor Utensil constructor Spoon constructor Utensil constructor Fork constructor Utensil constructor Knife constructor Plate constructor DinnerPlate constructor PlaceSetting constructor */ OnJava8-Examples-1.0/reuse/SpaceShipControls.java000066400000000000000000000006551374004044700217760ustar00rootroot00000000000000// reuse/SpaceShipControls.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SpaceShipControls { void up(int velocity) {} void down(int velocity) {} void left(int velocity) {} void right(int velocity) {} void forward(int velocity) {} void back(int velocity) {} void turboBoost() {} } OnJava8-Examples-1.0/reuse/SpaceShipDelegation.java000066400000000000000000000020331374004044700222360ustar00rootroot00000000000000// reuse/SpaceShipDelegation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SpaceShipDelegation { private String name; private SpaceShipControls controls = new SpaceShipControls(); public SpaceShipDelegation(String name) { this.name = name; } // Delegated methods: public void back(int velocity) { controls.back(velocity); } public void down(int velocity) { controls.down(velocity); } public void forward(int velocity) { controls.forward(velocity); } public void left(int velocity) { controls.left(velocity); } public void right(int velocity) { controls.right(velocity); } public void turboBoost() { controls.turboBoost(); } public void up(int velocity) { controls.up(velocity); } public static void main(String[] args) { SpaceShipDelegation protector = new SpaceShipDelegation("NSEA Protector"); protector.forward(100); } } OnJava8-Examples-1.0/reuse/SprinklerSystem.java000066400000000000000000000021231374004044700215410ustar00rootroot00000000000000// reuse/SprinklerSystem.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Composition for code reuse class WaterSource { private String s; WaterSource() { System.out.println("WaterSource()"); s = "Constructed"; } @Override public String toString() { return s; } } public class SprinklerSystem { private String valve1, valve2, valve3, valve4; private WaterSource source = new WaterSource(); private int i; private float f; @Override public String toString() { return "valve1 = " + valve1 + " " + "valve2 = " + valve2 + " " + "valve3 = " + valve3 + " " + "valve4 = " + valve4 + "\n" + "i = " + i + " " + "f = " + f + " " + "source = " + source; // [1] } public static void main(String[] args) { SprinklerSystem sprinklers = new SprinklerSystem(); System.out.println(sprinklers); } } /* Output: WaterSource() valve1 = null valve2 = null valve3 = null valve4 = null i = 0 f = 0.0 source = Constructed */ OnJava8-Examples-1.0/reuse/Wind.java000066400000000000000000000010461374004044700172670ustar00rootroot00000000000000// reuse/Wind.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Inheritance & upcasting class Instrument { public void play() {} static void tune(Instrument i) { // ... i.play(); } } // Wind objects are instruments // because they have the same interface: public class Wind extends Instrument { public static void main(String[] args) { Wind flute = new Wind(); Instrument.tune(flute); // Upcasting } } OnJava8-Examples-1.0/serialization/000077500000000000000000000000001374004044700172545ustar00rootroot00000000000000OnJava8-Examples-1.0/serialization/APerson.java000066400000000000000000000045071374004044700214740ustar00rootroot00000000000000// serialization/APerson.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Use the XOM library to write and read XML // nu.xom.Node comes from http://www.xom.nu import nu.xom.*; import java.io.*; import java.util.*; public class APerson { private String first, last; public APerson(String first, String last) { this.first = first; this.last = last; } // Produce an XML Element from this APerson object: public Element getXML() { Element person = new Element("person"); Element firstName = new Element("first"); firstName.appendChild(first); Element lastName = new Element("last"); lastName.appendChild(last); person.appendChild(firstName); person.appendChild(lastName); return person; } // Constructor restores a APerson from XML: public APerson(Element person) { first = person .getFirstChildElement("first").getValue(); last = person .getFirstChildElement("last").getValue(); } @Override public String toString() { return first + " " + last; } // Make it human-readable: public static void format(OutputStream os, Document doc) throws Exception { Serializer serializer = new Serializer(os,"ISO-8859-1"); serializer.setIndent(4); serializer.setMaxLength(60); serializer.write(doc); serializer.flush(); } public static void main(String[] args) throws Exception { List people = Arrays.asList( new APerson("Dr. Bunsen", "Honeydew"), new APerson("Gonzo", "The Great"), new APerson("Phillip J.", "Fry")); System.out.println(people); Element root = new Element("people"); for(APerson p : people) root.appendChild(p.getXML()); Document doc = new Document(root); format(System.out, doc); format(new BufferedOutputStream( new FileOutputStream("People.xml")), doc); } } /* Output: [Dr. Bunsen Honeydew, Gonzo The Great, Phillip J. Fry] Dr. Bunsen Honeydew Gonzo The Great Phillip J. Fry */ OnJava8-Examples-1.0/serialization/AStoreCADState.java000066400000000000000000000067741374004044700226430ustar00rootroot00000000000000// serialization/AStoreCADState.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Saving the state of a fictitious CAD system import java.io.*; import java.util.*; import java.util.stream.*; enum Color { RED, BLUE, GREEN } abstract class Shape implements Serializable { private int xPos, yPos, dimension; private static Random rand = new Random(47); private static int counter = 0; public abstract void setColor(Color newColor); public abstract Color getColor(); Shape(int xVal, int yVal, int dim) { xPos = xVal; yPos = yVal; dimension = dim; } public String toString() { return getClass() + "color[" + getColor() + "] xPos[" + xPos + "] yPos[" + yPos + "] dim[" + dimension + "]\n"; } public static Shape randomFactory() { int xVal = rand.nextInt(100); int yVal = rand.nextInt(100); int dim = rand.nextInt(100); switch(counter++ % 3) { default: case 0: return new Circle(xVal, yVal, dim); case 1: return new Square(xVal, yVal, dim); case 2: return new Line(xVal, yVal, dim); } } } class Circle extends Shape { private static Color color = Color.RED; Circle(int xVal, int yVal, int dim) { super(xVal, yVal, dim); } public void setColor(Color newColor) { color = newColor; } public Color getColor() { return color; } } class Square extends Shape { private static Color color = Color.RED; Square(int xVal, int yVal, int dim) { super(xVal, yVal, dim); } public void setColor(Color newColor) { color = newColor; } public Color getColor() { return color; } } class Line extends Shape { private static Color color = Color.RED; public static void serializeStaticState(ObjectOutputStream os) throws IOException { os.writeObject(color); } public static void deserializeStaticState(ObjectInputStream os) throws IOException, ClassNotFoundException { color = (Color)os.readObject(); } Line(int xVal, int yVal, int dim) { super(xVal, yVal, dim); } public void setColor(Color newColor) { color = newColor; } public Color getColor() { return color; } } public class AStoreCADState { public static void main(String[] args) { List> shapeTypes = Arrays.asList( Circle.class, Square.class, Line.class); List shapes = IntStream.range(0, 10) .mapToObj(i -> Shape.randomFactory()) .collect(Collectors.toList()); // Set all the static colors to GREEN: shapes.forEach(s -> s.setColor(Color.GREEN)); // Save the state vector: try( ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("CADState.dat")) ) { out.writeObject(shapeTypes); Line.serializeStaticState(out); out.writeObject(shapes); } catch(IOException e) { throw new RuntimeException(e); } // Display the shapes: System.out.println(shapes); } } /* Output: [class Circlecolor[GREEN] xPos[58] yPos[55] dim[93] , class Squarecolor[GREEN] xPos[61] yPos[61] dim[29] , class Linecolor[GREEN] xPos[68] yPos[0] dim[22] , class Circlecolor[GREEN] xPos[7] yPos[88] dim[28] , class Squarecolor[GREEN] xPos[51] yPos[89] dim[9] , class Linecolor[GREEN] xPos[78] yPos[98] dim[61] , class Circlecolor[GREEN] xPos[20] yPos[58] dim[16] , class Squarecolor[GREEN] xPos[40] yPos[11] dim[22] , class Linecolor[GREEN] xPos[4] yPos[83] dim[6] , class Circlecolor[GREEN] xPos[75] yPos[10] dim[42] ] */ OnJava8-Examples-1.0/serialization/Alien.java000066400000000000000000000004261374004044700211510ustar00rootroot00000000000000// serialization/Alien.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A serializable class import java.io.*; public class Alien implements Serializable {} OnJava8-Examples-1.0/serialization/Blip3.java000066400000000000000000000040071374004044700210710ustar00rootroot00000000000000// serialization/Blip3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Reconstructing an externalizable object import java.io.*; public class Blip3 implements Externalizable { private int i; private String s; // No initialization public Blip3() { System.out.println("Blip3 Constructor"); // s, i not initialized } public Blip3(String x, int a) { System.out.println("Blip3(String x, int a)"); s = x; i = a; // s & i initialized only in non-no-arg constructor. } @Override public String toString() { return s + i; } @Override public void writeExternal(ObjectOutput out) throws IOException { System.out.println("Blip3.writeExternal"); // You must do this: out.writeObject(s); out.writeInt(i); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { System.out.println("Blip3.readExternal"); // You must do this: s = (String)in.readObject(); i = in.readInt(); } public static void main(String[] args) { System.out.println("Constructing objects:"); Blip3 b3 = new Blip3("A String ", 47); System.out.println(b3); try( ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Blip3.serialized")) ) { System.out.println("Saving object:"); o.writeObject(b3); } catch(IOException e) { throw new RuntimeException(e); } // Now get it back: System.out.println("Recovering b3:"); try( ObjectInputStream in = new ObjectInputStream( new FileInputStream("Blip3.serialized")) ) { b3 = (Blip3)in.readObject(); } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } System.out.println(b3); } } /* Output: Constructing objects: Blip3(String x, int a) A String 47 Saving object: Blip3.writeExternal Recovering b3: Blip3 Constructor Blip3.readExternal A String 47 */ OnJava8-Examples-1.0/serialization/Blips.java000066400000000000000000000041171374004044700211730ustar00rootroot00000000000000// serialization/Blips.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple use of Externalizable & a pitfall import java.io.*; class Blip1 implements Externalizable { public Blip1() { System.out.println("Blip1 Constructor"); } @Override public void writeExternal(ObjectOutput out) throws IOException { System.out.println("Blip1.writeExternal"); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { System.out.println("Blip1.readExternal"); } } class Blip2 implements Externalizable { Blip2() { System.out.println("Blip2 Constructor"); } @Override public void writeExternal(ObjectOutput out) throws IOException { System.out.println("Blip2.writeExternal"); } @Override public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException { System.out.println("Blip2.readExternal"); } } public class Blips { public static void main(String[] args) { System.out.println("Constructing objects:"); Blip1 b1 = new Blip1(); Blip2 b2 = new Blip2(); try( ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Blips.serialized")) ) { System.out.println("Saving objects:"); o.writeObject(b1); o.writeObject(b2); } catch(IOException e) { throw new RuntimeException(e); } // Now get them back: System.out.println("Recovering b1:"); try( ObjectInputStream in = new ObjectInputStream( new FileInputStream("Blips.serialized")) ) { b1 = (Blip1)in.readObject(); } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } // OOPS! Throws an exception: //- System.out.println("Recovering b2:"); //- b2 = (Blip2)in.readObject(); } } /* Output: Constructing objects: Blip1 Constructor Blip2 Constructor Saving objects: Blip1.writeExternal Blip2.writeExternal Recovering b1: Blip1 Constructor Blip1.readExternal */ OnJava8-Examples-1.0/serialization/FreezeAlien.java000066400000000000000000000010231374004044700223040ustar00rootroot00000000000000// serialization/FreezeAlien.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Create a serialized output file import java.io.*; public class FreezeAlien { public static void main(String[] args) throws Exception { try( ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("X.file")); ) { Alien quellek = new Alien(); out.writeObject(quellek); } } } OnJava8-Examples-1.0/serialization/Logon.java000066400000000000000000000033071374004044700212000ustar00rootroot00000000000000// serialization/Logon.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates the "transient" keyword import java.util.concurrent.*; import java.io.*; import java.util.*; import onjava.Nap; public class Logon implements Serializable { private Date date = new Date(); private String username; private transient String password; public Logon(String name, String pwd) { username = name; password = pwd; } @Override public String toString() { return "logon info: \n username: " + username + "\n date: " + date + "\n password: " + password; } public static void main(String[] args) { Logon a = new Logon("Hulk", "myLittlePony"); System.out.println("logon a = " + a); try( ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("Logon.dat")) ) { o.writeObject(a); } catch(IOException e) { throw new RuntimeException(e); } new Nap(1); // Now get them back: try( ObjectInputStream in = new ObjectInputStream( new FileInputStream("Logon.dat")) ) { System.out.println( "Recovering object at " + new Date()); a = (Logon)in.readObject(); } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } System.out.println("logon a = " + a); } } /* Output: logon a = logon info: username: Hulk date: Tue May 09 06:07:47 MDT 2017 password: myLittlePony Recovering object at Tue May 09 06:07:49 MDT 2017 logon a = logon info: username: Hulk date: Tue May 09 06:07:47 MDT 2017 password: null */ OnJava8-Examples-1.0/serialization/MyWorld.java000066400000000000000000000055321374004044700215210ustar00rootroot00000000000000// serialization/MyWorld.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.util.*; class House implements Serializable {} class Animal implements Serializable { private String name; private House preferredHouse; Animal(String nm, House h) { name = nm; preferredHouse = h; } @Override public String toString() { return name + "[" + super.toString() + "], " + preferredHouse + "\n"; } } public class MyWorld { public static void main(String[] args) { House house = new House(); List animals = new ArrayList<>(); animals.add( new Animal("Bosco the dog", house)); animals.add( new Animal("Ralph the hamster", house)); animals.add( new Animal("Molly the cat", house)); System.out.println("animals: " + animals); try( ByteArrayOutputStream buf1 = new ByteArrayOutputStream(); ObjectOutputStream o1 = new ObjectOutputStream(buf1) ) { o1.writeObject(animals); o1.writeObject(animals); // Write a 2nd set // Write to a different stream: try( ByteArrayOutputStream buf2 = new ByteArrayOutputStream(); ObjectOutputStream o2 = new ObjectOutputStream(buf2) ) { o2.writeObject(animals); // Now get them back: try( ObjectInputStream in1 = new ObjectInputStream( new ByteArrayInputStream( buf1.toByteArray())); ObjectInputStream in2 = new ObjectInputStream( new ByteArrayInputStream( buf2.toByteArray())) ) { List animals1 = (List)in1.readObject(), animals2 = (List)in1.readObject(), animals3 = (List)in2.readObject(); System.out.println( "animals1: " + animals1); System.out.println( "animals2: " + animals2); System.out.println( "animals3: " + animals3); } } } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } } } /* Output: animals: [Bosco the dog[Animal@15db9742], House@6d06d69c , Ralph the hamster[Animal@7852e922], House@6d06d69c , Molly the cat[Animal@4e25154f], House@6d06d69c ] animals1: [Bosco the dog[Animal@7ba4f24f], House@3b9a45b3 , Ralph the hamster[Animal@7699a589], House@3b9a45b3 , Molly the cat[Animal@58372a00], House@3b9a45b3 ] animals2: [Bosco the dog[Animal@7ba4f24f], House@3b9a45b3 , Ralph the hamster[Animal@7699a589], House@3b9a45b3 , Molly the cat[Animal@58372a00], House@3b9a45b3 ] animals3: [Bosco the dog[Animal@4dd8dc3], House@6d03e736 , Ralph the hamster[Animal@568db2f2], House@6d03e736 , Molly the cat[Animal@378bf509], House@6d03e736 ] */ OnJava8-Examples-1.0/serialization/People.java000066400000000000000000000015231374004044700213440ustar00rootroot00000000000000// serialization/People.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // nu.xom.Node comes from http://www.xom.nu // {RunFirst: APerson} import nu.xom.*; import java.io.File; import java.util.*; public class People extends ArrayList { public People(String fileName) throws Exception { Document doc = new Builder().build(new File(fileName)); Elements elements = doc.getRootElement().getChildElements(); for(int i = 0; i < elements.size(); i++) add(new APerson(elements.get(i))); } public static void main(String[] args) throws Exception { People p = new People("People.xml"); System.out.println(p); } } /* Output: [Dr. Bunsen Honeydew, Gonzo The Great, Phillip J. Fry] */ OnJava8-Examples-1.0/serialization/RecoverCADState.java000066400000000000000000000026731374004044700230450ustar00rootroot00000000000000// serialization/RecoverCADState.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Restoring the state of the fictitious CAD system // {RunFirst: AStoreCADState} import java.io.*; import java.util.*; public class RecoverCADState { @SuppressWarnings("unchecked") public static void main(String[] args) { try( ObjectInputStream in = new ObjectInputStream( new FileInputStream("CADState.dat")) ) { // Read in the same order they were written: List> shapeTypes = (List>)in.readObject(); Line.deserializeStaticState(in); List shapes = (List)in.readObject(); System.out.println(shapes); } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } } } /* Output: [class Circlecolor[RED] xPos[58] yPos[55] dim[93] , class Squarecolor[RED] xPos[61] yPos[61] dim[29] , class Linecolor[GREEN] xPos[68] yPos[0] dim[22] , class Circlecolor[RED] xPos[7] yPos[88] dim[28] , class Squarecolor[RED] xPos[51] yPos[89] dim[9] , class Linecolor[GREEN] xPos[78] yPos[98] dim[61] , class Circlecolor[RED] xPos[20] yPos[58] dim[16] , class Squarecolor[RED] xPos[40] yPos[11] dim[22] , class Linecolor[GREEN] xPos[4] yPos[83] dim[6] , class Circlecolor[RED] xPos[75] yPos[10] dim[42] ] */ OnJava8-Examples-1.0/serialization/SerialCtl.java000066400000000000000000000032461374004044700220060ustar00rootroot00000000000000// serialization/SerialCtl.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Controlling serialization by adding your own // writeObject() and readObject() methods import java.io.*; public class SerialCtl implements Serializable { private String a; private transient String b; public SerialCtl(String aa, String bb) { a = "Not Transient: " + aa; b = "Transient: " + bb; } @Override public String toString() { return a + "\n" + b; } private void writeObject(ObjectOutputStream stream) throws IOException { stream.defaultWriteObject(); stream.writeObject(b); } private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException { stream.defaultReadObject(); b = (String)stream.readObject(); } public static void main(String[] args) { SerialCtl sc = new SerialCtl("Test1", "Test2"); System.out.println("Before:\n" + sc); try ( ByteArrayOutputStream buf = new ByteArrayOutputStream(); ObjectOutputStream o = new ObjectOutputStream(buf); ) { o.writeObject(sc); // Now get it back: try ( ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream( buf.toByteArray())); ) { SerialCtl sc2 = (SerialCtl)in.readObject(); System.out.println("After:\n" + sc2); } } catch(IOException | ClassNotFoundException e) { throw new RuntimeException(e); } } } /* Output: Before: Not Transient: Test1 Transient: Test2 After: Not Transient: Test1 Transient: Test2 */ OnJava8-Examples-1.0/serialization/Worm.java000066400000000000000000000051541374004044700210500ustar00rootroot00000000000000// serialization/Worm.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates object serialization import java.io.*; import java.util.*; class Data implements Serializable { private int n; Data(int n) { this.n = n; } @Override public String toString() { return Integer.toString(n); } } public class Worm implements Serializable { private static Random rand = new Random(47); private Data[] d = { new Data(rand.nextInt(10)), new Data(rand.nextInt(10)), new Data(rand.nextInt(10)) }; private Worm next; private char c; // Value of i == number of segments public Worm(int i, char x) { System.out.println("Worm constructor: " + i); c = x; if(--i > 0) next = new Worm(i, (char)(x + 1)); } public Worm() { System.out.println("No-arg constructor"); } @Override public String toString() { StringBuilder result = new StringBuilder(":"); result.append(c); result.append("("); for(Data dat : d) result.append(dat); result.append(")"); if(next != null) result.append(next); return result.toString(); } public static void main(String[] args) throws ClassNotFoundException, IOException { Worm w = new Worm(6, 'a'); System.out.println("w = " + w); try( ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("worm.dat")) ) { out.writeObject("Worm storage\n"); out.writeObject(w); } try( ObjectInputStream in = new ObjectInputStream( new FileInputStream("worm.dat")) ) { String s = (String)in.readObject(); Worm w2 = (Worm)in.readObject(); System.out.println(s + "w2 = " + w2); } try( ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream out2 = new ObjectOutputStream(bout) ) { out2.writeObject("Worm storage\n"); out2.writeObject(w); out2.flush(); try( ObjectInputStream in2 = new ObjectInputStream( new ByteArrayInputStream( bout.toByteArray())) ) { String s = (String)in2.readObject(); Worm w3 = (Worm)in2.readObject(); System.out.println(s + "w3 = " + w3); } } } } /* Output: Worm constructor: 6 Worm constructor: 5 Worm constructor: 4 Worm constructor: 3 Worm constructor: 2 Worm constructor: 1 w = :a(853):b(119):c(802):d(788):e(199):f(881) Worm storage w2 = :a(853):b(119):c(802):d(788):e(199):f(881) Worm storage w3 = :a(853):b(119):c(802):d(788):e(199):f(881) */ OnJava8-Examples-1.0/serialization/xfiles/000077500000000000000000000000001374004044700205465ustar00rootroot00000000000000OnJava8-Examples-1.0/serialization/xfiles/ThawAlien.java000066400000000000000000000012061374004044700232640ustar00rootroot00000000000000// serialization/xfiles/ThawAlien.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Recover a serialized file // {java serialization.xfiles.ThawAlien} // {RunFirst: FreezeAlien} package serialization.xfiles; import java.io.*; public class ThawAlien { public static void main(String[] args) throws Exception { ObjectInputStream in = new ObjectInputStream( new FileInputStream(new File("X.file"))); Object mystery = in.readObject(); System.out.println(mystery.getClass()); } } /* Output: class Alien */ OnJava8-Examples-1.0/settings.gradle000066400000000000000000000005771374004044700174300ustar00rootroot00000000000000def isSubproject = { File file -> file.isDirectory() && !file.name.contains('.git') && !file.name.contains('.gradle') && !file.name.contains('.idea') && !file.name.contains('build') && !file.name.contains('gradle') && !file.name.contains('test') } String[] subprojects = rootDir.listFiles().findAll(isSubproject).collect { it.name } include subprojects OnJava8-Examples-1.0/standardio/000077500000000000000000000000001374004044700165275ustar00rootroot00000000000000OnJava8-Examples-1.0/standardio/ChangeSystemOut.java000066400000000000000000000007111374004044700224530ustar00rootroot00000000000000// standardio/ChangeSystemOut.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Turn System.out into a PrintWriter import java.io.*; public class ChangeSystemOut { public static void main(String[] args) { PrintWriter out = new PrintWriter(System.out, true); out.println("Hello, world"); } } /* Output: Hello, world */ OnJava8-Examples-1.0/standardio/Echo.java000066400000000000000000000011261374004044700202500ustar00rootroot00000000000000// standardio/Echo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // How to read from standard input import java.io.*; import onjava.TimedAbort; public class Echo { public static void main(String[] args) { TimedAbort abort = new TimedAbort(2); new BufferedReader( new InputStreamReader(System.in)) .lines() .peek(ln -> abort.restart()) .forEach(System.out::println); // Ctrl-Z or two seconds inactivity // terminates the program } } OnJava8-Examples-1.0/standardio/OSExecuteDemo.java000066400000000000000000000007201374004044700220420ustar00rootroot00000000000000// standardio/OSExecuteDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates standard I/O redirection // javap -cp build/classes/java/main OSExecuteDemo // {ExcludeFromGradle} import onjava.*; public class OSExecuteDemo {} /* Output: Compiled from "OSExecuteDemo.java" public class OSExecuteDemo { public OSExecuteDemo(); } */ OnJava8-Examples-1.0/standardio/Redirecting.java000066400000000000000000000016471374004044700216410ustar00rootroot00000000000000// standardio/Redirecting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates standard I/O redirection import java.io.*; public class Redirecting { public static void main(String[] args) { PrintStream console = System.out; try( BufferedInputStream in = new BufferedInputStream( new FileInputStream("Redirecting.java")); PrintStream out = new PrintStream( new BufferedOutputStream( new FileOutputStream("Redirecting.txt"))) ) { System.setIn(in); System.setOut(out); System.setErr(out); new BufferedReader( new InputStreamReader(System.in)) .lines() .forEach(System.out::println); } catch(IOException e) { throw new RuntimeException(e); } finally { System.setOut(console); } } } OnJava8-Examples-1.0/staticchecking/000077500000000000000000000000001374004044700173625ustar00rootroot00000000000000OnJava8-Examples-1.0/staticchecking/DogsAndRobots.cpp000066400000000000000000000010701374004044700225740ustar00rootroot00000000000000// staticchecking/DogsAndRobots.cpp // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. #include using namespace std; class Dog { public: void talk() { cout << "Arf!" << endl; } void reproduce() {} }; class Robot { public: void talk() { cout << "Click!" << endl; } void oilChange() {} }; template void speak(T speaker) { speaker.talk(); } int main() { Dog d; Robot r; speak(d); speak(r); } /* Output: Arf! Click! */ OnJava8-Examples-1.0/staticchecking/DogsAndRobots.py000066400000000000000000000007201374004044700224430ustar00rootroot00000000000000# staticchecking/DogsAndRobots.py # (c)2020 MindView LLC: see Copyright.txt # We make no guarantees that this code is fit for any purpose. # Visit http://OnJava8.com for more book information. def speak(anything): anything.talk() class Dog: def talk(self): print("Arf!") def reproduce(self): pass class Robot: def talk(self): print("Click!") def oilChange(self): pass a = Dog() b = Robot() speak(a) speak(b) output = """ Arf! Click! """ OnJava8-Examples-1.0/staticchecking/NoBasePetSpeak.py000066400000000000000000000012571374004044700225450ustar00rootroot00000000000000# staticchecking/NoBasePetSpeak.py # (c)2020 MindView LLC: see Copyright.txt # We make no guarantees that this code is fit for any purpose. # Visit http://OnJava8.com for more book information. #- Speaking pets without base classes class Cat: def speak(self): print("meow!") class Dog: def speak(self): print("woof!") class Bob: def bow(self): print("thank you, thank you!") def speak(self): print("Welcome to the neighborhood!") def drive(self): print("beep, beep!") def command(pet): pet.speak() pets = [ Cat(), Dog(), Bob() ] for pet in pets: command(pet) output = """ meow! woof! Welcome to the neighborhood! """ OnJava8-Examples-1.0/staticchecking/PetSpeak.py000066400000000000000000000007751374004044700214610ustar00rootroot00000000000000# staticchecking/PetSpeak.py # (c)2020 MindView LLC: see Copyright.txt # We make no guarantees that this code is fit for any purpose. # Visit http://OnJava8.com for more book information. #- Speaking pets in Python class Pet: def speak(self): pass class Cat(Pet): def speak(self): print("meow!") class Dog(Pet): def speak(self): print("woof!") def command(pet): pet.speak() pets = [ Cat(), Dog() ] # (1) for pet in pets: # (2) command(pet) output = """ meow! woof! """ OnJava8-Examples-1.0/staticchecking/dogsandrobots.go000066400000000000000000000010711374004044700225600ustar00rootroot00000000000000// staticchecking/dogsandrobots.go // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package main import "fmt" type Dog struct {} func (this Dog) talk() { fmt.Printf("woof!\n")} func (this Dog) reproduce() {} type Robot struct {} func (this Robot) talk() { fmt.Printf("Click!\n") } func (this Robot) oilChange() {} func speak(speaker interface { talk() }) { speaker.talk(); } func main() { speak(Dog{}) speak(Robot{}) } /* Output: woof! Click! */ OnJava8-Examples-1.0/staticchecking/dr/000077500000000000000000000000001374004044700177675ustar00rootroot00000000000000OnJava8-Examples-1.0/staticchecking/dr/DogsAndRobots.java000066400000000000000000000015471374004044700233510ustar00rootroot00000000000000// staticchecking/dr/DogsAndRobots.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java staticchecking.dr.DogsAndRobots} package staticchecking.dr; interface Speaks { void talk(); } class Dog implements Speaks { public void talk() { System.out.println("Woof!"); } public void reproduce() { } } class Robot implements Speaks { public void talk() { System.out.println("Click!"); } public void oilChange() { } } class Communicate { public static void speak(T speaker) { speaker.talk(); } } public class DogsAndRobots { public static void main(String[] args) { Dog d = new Dog(); Robot r = new Robot(); Communicate.speak(d); Communicate.speak(r); } } /* Output: Woof! Click! */ OnJava8-Examples-1.0/staticchecking/drc/000077500000000000000000000000001374004044700201325ustar00rootroot00000000000000OnJava8-Examples-1.0/staticchecking/drc/DogAndRobotCollections.java000066400000000000000000000022031374004044700253330ustar00rootroot00000000000000// staticchecking/drc/DogAndRobotCollections.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java staticchecking.drc.DogAndRobotCollections} package staticchecking.drc; import java.util.*; class Dog { public void talk() { System.out.println("Woof!"); } public void reproduce() { } } class Robot { public void talk() { System.out.println("Click!"); } public void oilChange() { } } public class DogAndRobotCollections { public static void main(String[] args) { List dogList = new ArrayList<>(); List robotList = new ArrayList<>(); for(int i = 0; i < 10; i++) dogList.add(new Dog()); //- dogList.add(new Robot()); // Compile-time error for(int i = 0; i < 10; i++) robotList.add(new Robot()); //- robotList.add(new Dog()); // Compile-time error dogList.forEach(Dog::talk); robotList.forEach(Robot::talk); } } /* Output: Woof! Woof! Woof! Woof! Woof! Woof! Woof! Woof! Woof! Woof! Click! Click! Click! Click! Click! Click! Click! Click! Click! Click! */ OnJava8-Examples-1.0/staticchecking/latent/000077500000000000000000000000001374004044700206515ustar00rootroot00000000000000OnJava8-Examples-1.0/staticchecking/latent/Latent.java000066400000000000000000000026041374004044700227450ustar00rootroot00000000000000// staticchecking/latent/Latent.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java staticchecking.latent.Latent} package staticchecking.latent; import java.lang.reflect.*; class Dog { public void talk() { System.out.println("Woof!"); } public void reproduce() {} } class Robot { public void talk() { System.out.println("Click!"); } public void oilChange() {} } class Mime { public void walkAgainstTheWind() {} public String toString() { return "Mime"; } } class Communicate { public static void speak(Object speaker) { try { Class spkr = speaker.getClass(); Method talk = spkr.getMethod("talk", (Class[])null); talk.invoke(speaker, new Object[]{}); } catch(NoSuchMethodException e) { System.out.println( speaker + " cannot talk"); } catch(IllegalAccessException e) { System.out.println( speaker + " IllegalAccessException"); } catch(InvocationTargetException e) { System.out.println( speaker + " InvocationTargetException"); } } } public class Latent { public static void main(String[] args) { Communicate.speak(new Dog()); Communicate.speak(new Robot()); Communicate.speak(new Mime()); } } /* Output: Woof! Click! Mime cannot talk */ OnJava8-Examples-1.0/staticchecking/petspeak.go000066400000000000000000000017421374004044700215310ustar00rootroot00000000000000// staticchecking/petspeak.go // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package main import "fmt" type Cat struct {} func (this Cat) speak() { fmt.Printf("meow!\n")} type Dog struct {} func (this Dog) speak() { fmt.Printf("woof!\n")} type Bob struct {} func (this Bob) bow() { fmt.Printf("thank you, thank you!\n") } func (this Bob) speak() { fmt.Printf("Welcome to the neighborhood!\n") } func (this Bob) drive() { fmt.Printf("beep, beep!\n") } type Speaker interface { speak() } func command(s Speaker) { s.speak() } // If "Speaker" is never used // anywhere else, it can be anonymous: func command2(s interface { speak() }) { s.speak() } func main() { command(Cat{}) command(Dog{}) command(Bob{}) command2(Cat{}) command2(Dog{}) command2(Bob{}) } /* Output: meow! woof! Welcome to the neighborhood! meow! woof! Welcome to the neighborhood! */ OnJava8-Examples-1.0/staticchecking/petspeak/000077500000000000000000000000001374004044700211765ustar00rootroot00000000000000OnJava8-Examples-1.0/staticchecking/petspeak/PetSpeak.java000066400000000000000000000013601374004044700235550ustar00rootroot00000000000000// staticchecking/petspeak/PetSpeak.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Speaking pets in Java // {java staticchecking.petspeak.PetSpeak} package staticchecking.petspeak; interface Pet { void speak(); } class Cat implements Pet { public void speak() { System.out.println("meow!"); } } class Dog implements Pet { public void speak() { System.out.println("woof!"); } } public class PetSpeak { static void command(Pet p) { p.speak(); } public static void main(String[] args) { Pet[] pets = { new Cat(), new Dog() }; for(Pet pet : pets) command(pet); } } /* Output: meow! woof! */ OnJava8-Examples-1.0/streams/000077500000000000000000000000001374004044700160555ustar00rootroot00000000000000OnJava8-Examples-1.0/streams/ArrayStreams.java000066400000000000000000000016171374004044700213420ustar00rootroot00000000000000// streams/ArrayStreams.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class ArrayStreams { public static void main(String[] args) { Arrays.stream( new double[] { 3.14159, 2.718, 1.618 }) .forEach(n -> System.out.format("%f ", n)); System.out.println(); Arrays.stream(new int[] { 1, 3, 5 }) .forEach(n -> System.out.format("%d ", n)); System.out.println(); Arrays.stream(new long[] { 11, 22, 44, 66 }) .forEach(n -> System.out.format("%d ", n)); System.out.println(); // Select a subrange: Arrays.stream( new int[] { 1, 3, 5, 7, 15, 28, 37 }, 3, 6) .forEach(n -> System.out.format("%d ", n)); } } /* Output: 3.141590 2.718000 1.618000 1 3 5 11 22 44 66 7 15 28 */ OnJava8-Examples-1.0/streams/Bubble.java000066400000000000000000000007331374004044700201160ustar00rootroot00000000000000// streams/Bubble.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Bubble { public final int i; public Bubble(int n) { i = n; } @Override public String toString() { return "Bubble(" + i + ")"; } private static int count = 0; public static Bubble bubbler() { return new Bubble(count++); } } OnJava8-Examples-1.0/streams/Bubbles.java000066400000000000000000000006701374004044700203010ustar00rootroot00000000000000// streams/Bubbles.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class Bubbles { public static void main(String[] args) { Stream.generate(Bubble::bubbler) .limit(5) .forEach(System.out::println); } } /* Output: Bubble(0) Bubble(1) Bubble(2) Bubble(3) Bubble(4) */ OnJava8-Examples-1.0/streams/Cheese.dat000066400000000000000000000003011374004044700177350ustar00rootroot00000000000000// streams/Cheese.dat Not much of a cheese shop really, is it? Finest in the district, sir. And what leads you to that conclusion? Well, it's so clean. It's certainly uncontaminated by cheese. OnJava8-Examples-1.0/streams/CollectionToStream.java000066400000000000000000000020041374004044700224660ustar00rootroot00000000000000// streams/CollectionToStream.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class CollectionToStream { public static void main(String[] args) { List bubbles = Arrays.asList( new Bubble(1), new Bubble(2), new Bubble(3)); System.out.println( bubbles.stream() .mapToInt(b -> b.i) .sum()); Set w = new HashSet<>(Arrays.asList( "It's a wonderful day for pie!".split(" "))); w.stream() .map(x -> x + " ") .forEach(System.out::print); System.out.println(); Map m = new HashMap<>(); m.put("pi", 3.14159); m.put("e", 2.718); m.put("phi", 1.618); m.entrySet().stream() .map(e -> e.getKey() + ": " + e.getValue()) .forEach(System.out::println); } } /* Output: 6 a pie! It's for wonderful day phi: 1.618 e: 2.718 pi: 3.14159 */ OnJava8-Examples-1.0/streams/CreatingOptionals.java000066400000000000000000000016411374004044700223470ustar00rootroot00000000000000// streams/CreatingOptionals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; class CreatingOptionals { static void test(String testName, Optional opt) { System.out.println(" === " + testName + " === "); System.out.println(opt.orElse("Null")); } public static void main(String[] args) { test("empty", Optional.empty()); test("of", Optional.of("Howdy")); try { test("of", Optional.of(null)); } catch(Exception e) { System.out.println(e); } test("ofNullable", Optional.ofNullable("Hi")); test("ofNullable", Optional.ofNullable(null)); } } /* Output: === empty === Null === of === Howdy java.lang.NullPointerException === ofNullable === Hi === ofNullable === Null */ OnJava8-Examples-1.0/streams/Duplicator.java000066400000000000000000000006541374004044700210330ustar00rootroot00000000000000// streams/Duplicator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class Duplicator { public static void main(String[] args) { Stream.generate(() -> "duplicate") .limit(3) .forEach(System.out::println); } } /* Output: duplicate duplicate duplicate */ OnJava8-Examples-1.0/streams/Fibonacci.java000066400000000000000000000012341374004044700205750ustar00rootroot00000000000000// streams/Fibonacci.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class Fibonacci { int x = 1; Stream numbers() { return Stream.iterate(0, i -> { int result = x + i; x = i; return result; }); } public static void main(String[] args) { new Fibonacci().numbers() .skip(20) // Don't use the first 20 .limit(10) // Then take 10 of them .forEach(System.out::println); } } /* Output: 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 */ OnJava8-Examples-1.0/streams/FileToWords.java000066400000000000000000000010371374004044700211220ustar00rootroot00000000000000// streams/FileToWords.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.nio.file.*; import java.util.stream.*; import java.util.regex.Pattern; public class FileToWords { public static Stream stream(String filePath) throws Exception { return Files.lines(Paths.get(filePath)) .skip(1) // First (comment) line .flatMap(line -> Pattern.compile("\\W+").splitAsStream(line)); } } OnJava8-Examples-1.0/streams/FileToWordsBuilder.java000066400000000000000000000016301374004044700224300ustar00rootroot00000000000000// streams/FileToWordsBuilder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.nio.file.*; import java.util.stream.*; public class FileToWordsBuilder { Stream.Builder builder = Stream.builder(); public FileToWordsBuilder(String filePath) throws Exception { Files.lines(Paths.get(filePath)) .skip(1) // Skip the comment line at the beginning .forEach(line -> { for(String w : line.split("[ .?,]+")) builder.add(w); }); } Stream stream() { return builder.build(); } public static void main(String[] args) throws Exception { new FileToWordsBuilder("Cheese.dat").stream() .limit(7) .map(w -> w + " ") .forEach(System.out::print); } } /* Output: Not much of a cheese shop really */ OnJava8-Examples-1.0/streams/FileToWordsRegexp.java000066400000000000000000000020171374004044700222740ustar00rootroot00000000000000// streams/FileToWordsRegexp.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.nio.file.*; import java.util.stream.*; import java.util.regex.Pattern; public class FileToWordsRegexp { private String all; public FileToWordsRegexp(String filePath) throws Exception { all = Files.lines(Paths.get(filePath)) .skip(1) // First (comment) line .collect(Collectors.joining(" ")); } public Stream stream() { return Pattern .compile("[ .,?]+").splitAsStream(all); } public static void main(String[] args) throws Exception { FileToWordsRegexp fw = new FileToWordsRegexp("Cheese.dat"); fw.stream() .limit(7) .map(w -> w + " ") .forEach(System.out::print); fw.stream() .skip(7) .limit(2) .map(w -> w + " ") .forEach(System.out::print); } } /* Output: Not much of a cheese shop really is it */ OnJava8-Examples-1.0/streams/FileToWordsTest.java000066400000000000000000000011551374004044700217630ustar00rootroot00000000000000// streams/FileToWordsTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class FileToWordsTest { public static void main(String[] args) throws Exception { FileToWords.stream("Cheese.dat") .limit(7) .forEach(s -> System.out.format("%s ", s)); System.out.println(); FileToWords.stream("Cheese.dat") .skip(7) .limit(2) .forEach(s -> System.out.format("%s ", s)); } } /* Output: Not much of a cheese shop really is it */ OnJava8-Examples-1.0/streams/FlatMap.java000066400000000000000000000007511374004044700202470ustar00rootroot00000000000000// streams/FlatMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class FlatMap { public static void main(String[] args) { Stream.of(1, 2, 3) .flatMap( i -> Stream.of("Gonzo", "Fozzie", "Beaker")) .forEach(System.out::println); } } /* Output: Gonzo Fozzie Beaker Gonzo Fozzie Beaker Gonzo Fozzie Beaker */ OnJava8-Examples-1.0/streams/ForEach.java000066400000000000000000000015351374004044700202330ustar00rootroot00000000000000// streams/ForEach.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import static streams.RandInts.*; public class ForEach { static final int SZ = 14; public static void main(String[] args) { rands().limit(SZ) .forEach(n -> System.out.format("%d ", n)); System.out.println(); rands().limit(SZ) .parallel() .forEach(n -> System.out.format("%d ", n)); System.out.println(); rands().limit(SZ) .parallel() .forEachOrdered(n -> System.out.format("%d ", n)); } } /* Output: 258 555 693 861 961 429 868 200 522 207 288 128 551 589 551 861 429 589 200 522 555 693 258 128 868 288 961 207 258 555 693 861 961 429 868 200 522 207 288 128 551 589 */ OnJava8-Examples-1.0/streams/FunctionMap.java000066400000000000000000000022151374004044700211430ustar00rootroot00000000000000// streams/FunctionMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; class FunctionMap { static String[] elements = { "12", "", "23", "45" }; static Stream testStream() { return Arrays.stream(elements); } static void test(String descr, Function func) { System.out.println(" ---( " + descr + " )---"); testStream() .map(func) .forEach(System.out::println); } public static void main(String[] args) { test("add brackets", s -> "[" + s + "]"); test("Increment", s -> { try { return Integer.parseInt(s) + 1 + ""; } catch(NumberFormatException e) { return s; } }); test("Replace", s -> s.replace("2", "9")); test("Take last digit", s -> s.length() > 0 ? s.charAt(s.length() - 1) + "" : s); } } /* Output: ---( add brackets )--- [12] [] [23] [45] ---( Increment )--- 13 24 46 ---( Replace )--- 19 93 45 ---( Take last digit )--- 2 3 5 */ OnJava8-Examples-1.0/streams/FunctionMap2.java000066400000000000000000000012461374004044700212300ustar00rootroot00000000000000// streams/FunctionMap2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Different input and output types import java.util.*; import java.util.stream.*; class Numbered { final int n; Numbered(int n) { this.n = n; } @Override public String toString() { return "Numbered(" + n + ")"; } } class FunctionMap2 { public static void main(String[] args) { Stream.of(1, 5, 7, 9, 11, 13) .map(Numbered::new) .forEach(System.out::println); } } /* Output: Numbered(1) Numbered(5) Numbered(7) Numbered(9) Numbered(11) Numbered(13) */ OnJava8-Examples-1.0/streams/FunctionMap3.java000066400000000000000000000014501374004044700212260ustar00rootroot00000000000000// streams/FunctionMap3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Producing numeric output streams import java.util.*; import java.util.stream.*; class FunctionMap3 { public static void main(String[] args) { Stream.of("5", "7", "9") .mapToInt(Integer::parseInt) .forEach(n -> System.out.format("%d ", n)); System.out.println(); Stream.of("17", "19", "23") .mapToLong(Long::parseLong) .forEach(n -> System.out.format("%d ", n)); System.out.println(); Stream.of("17", "1.9", ".23") .mapToDouble(Double::parseDouble) .forEach(n -> System.out.format("%f ", n)); } } /* Output: 5 7 9 17 19 23 17.000000 1.900000 0.230000 */ OnJava8-Examples-1.0/streams/Generator.java000066400000000000000000000013321374004044700206450ustar00rootroot00000000000000// streams/Generator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.function.*; import java.util.stream.*; public class Generator implements Supplier { Random rand = new Random(47); char[] letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray(); public String get() { return "" + letters[rand.nextInt(letters.length)]; } public static void main(String[] args) { String word = Stream.generate(new Generator()) .limit(30) .collect(Collectors.joining()); System.out.println(word); } } /* Output: YNZBRNYGCFOWZNTCQRGSEGZMMJMROE */ OnJava8-Examples-1.0/streams/ImperativeRandoms.java000066400000000000000000000010661374004044700223540ustar00rootroot00000000000000// streams/ImperativeRandoms.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ImperativeRandoms { public static void main(String[] args) { Random rand = new Random(47); SortedSet rints = new TreeSet<>(); while(rints.size() < 7) { int r = rand.nextInt(20); if(r < 5) continue; rints.add(r); } System.out.println(rints); } } /* Output: [7, 8, 9, 11, 13, 15, 18] */ OnJava8-Examples-1.0/streams/Informational.java000066400000000000000000000013201374004044700215160ustar00rootroot00000000000000// streams/Informational.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; import java.util.function.*; public class Informational { public static void main(String[] args) throws Exception { System.out.println( FileToWords.stream("Cheese.dat").count()); System.out.println( FileToWords.stream("Cheese.dat") .min(String.CASE_INSENSITIVE_ORDER) .orElse("NONE")); System.out.println( FileToWords.stream("Cheese.dat") .max(String.CASE_INSENSITIVE_ORDER) .orElse("NONE")); } } /* Output: 32 a you */ OnJava8-Examples-1.0/streams/LastElement.java000066400000000000000000000012131374004044700211320ustar00rootroot00000000000000// streams/LastElement.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class LastElement { public static void main(String[] args) { OptionalInt last = IntStream.range(10, 20) .reduce((n1, n2) -> n2); System.out.println(last.orElse(-1)); // Non-numeric object: Optional lastobj = Stream.of("one", "two", "three") .reduce((n1, n2) -> n2); System.out.println( lastobj.orElse("Nothing there!")); } } /* Output: 19 three */ OnJava8-Examples-1.0/streams/Looping.java000066400000000000000000000007261374004044700203340ustar00rootroot00000000000000// streams/Looping.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import static onjava.Repeat.*; public class Looping { static void hi() { System.out.println("Hi!"); } public static void main(String[] args) { repeat(3, () -> System.out.println("Looping!")); repeat(2, Looping::hi); } } /* Output: Looping! Looping! Looping! Hi! Hi! */ OnJava8-Examples-1.0/streams/Machine2.java000066400000000000000000000010641374004044700203470ustar00rootroot00000000000000// streams/Machine2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import onjava.Operations; public class Machine2 { public static void main(String[] args) { Arrays.stream(new Operations[] { () -> Operations.show("Bing"), () -> Operations.show("Crack"), () -> Operations.show("Twist"), () -> Operations.show("Pop") }).forEach(Operations::execute); } } /* Output: Bing Crack Twist Pop */ OnJava8-Examples-1.0/streams/MapCollector.java000066400000000000000000000022701374004044700213050ustar00rootroot00000000000000// streams/MapCollector.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; class Pair { public final Character c; public final Integer i; Pair(Character c, Integer i) { this.c = c; this.i = i; } public Character getC() { return c; } public Integer getI() { return i; } @Override public String toString() { return "Pair(" + c + ", " + i + ")"; } } class RandomPair { Random rand = new Random(47); // An infinite iterator of random capital letters: Iterator capChars = rand.ints(65,91) .mapToObj(i -> (char)i) .iterator(); public Stream stream() { return rand.ints(100, 1000).distinct() .mapToObj(i -> new Pair(capChars.next(), i)); } } public class MapCollector { public static void main(String[] args) { Map map = new RandomPair().stream() .limit(8) .collect( Collectors.toMap(Pair::getI, Pair::getC)); System.out.println(map); } } /* Output: {688=W, 309=C, 293=B, 761=N, 858=N, 668=G, 622=F, 751=N} */ OnJava8-Examples-1.0/streams/Matching.java000066400000000000000000000017631374004044700204610ustar00rootroot00000000000000// streams/Matching.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrates short-circuiting of *Match() operations import java.util.stream.*; import java.util.function.*; import static streams.RandInts.*; interface Matcher extends BiPredicate, Predicate> {} public class Matching { static void show(Matcher match, int val) { System.out.println( match.test( IntStream.rangeClosed(1, 9) .boxed() .peek(n -> System.out.format("%d ", n)), n -> n < val)); } public static void main(String[] args) { show(Stream::allMatch, 10); show(Stream::allMatch, 4); show(Stream::anyMatch, 2); show(Stream::anyMatch, 0); show(Stream::noneMatch, 5); show(Stream::noneMatch, 0); } } /* Output: 1 2 3 4 5 6 7 8 9 true 1 2 3 4 false 1 true 1 2 3 4 5 6 7 8 9 false 1 false 1 2 3 4 5 6 7 8 9 true */ OnJava8-Examples-1.0/streams/NumericStreamInfo.java000066400000000000000000000012751374004044700223170ustar00rootroot00000000000000// streams/NumericStreamInfo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; import static streams.RandInts.*; public class NumericStreamInfo { public static void main(String[] args) { System.out.println(rands().average().getAsDouble()); System.out.println(rands().max().getAsInt()); System.out.println(rands().min().getAsInt()); System.out.println(rands().sum()); System.out.println(rands().summaryStatistics()); } } /* Output: 507.94 998 8 50794 IntSummaryStatistics{count=100, sum=50794, min=8, average=507.940000, max=998} */ OnJava8-Examples-1.0/streams/OptionalBasics.java000066400000000000000000000011571374004044700216360ustar00rootroot00000000000000// streams/OptionalBasics.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; class OptionalBasics { static void test(Optional optString) { if(optString.isPresent()) System.out.println(optString.get()); else System.out.println("Nothing inside!"); } public static void main(String[] args) { test(Stream.of("Epithets").findFirst()); test(Stream.empty().findFirst()); } } /* Output: Epithets Nothing inside! */ OnJava8-Examples-1.0/streams/OptionalFilter.java000066400000000000000000000030461374004044700216560ustar00rootroot00000000000000// streams/OptionalFilter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; class OptionalFilter { static String[] elements = { "Foo", "", "Bar", "Baz", "Bingo" }; static Stream testStream() { return Arrays.stream(elements); } static void test(String descr, Predicate pred) { System.out.println(" ---( " + descr + " )---"); for(int i = 0; i <= elements.length; i++) { System.out.println( testStream() .skip(i) .findFirst() .filter(pred)); } } public static void main(String[] args) { test("true", str -> true); test("false", str -> false); test("str != \"\"", str -> str != ""); test("str.length() == 3", str -> str.length() == 3); test("startsWith(\"B\")", str -> str.startsWith("B")); } } /* Output: ---( true )--- Optional[Foo] Optional[] Optional[Bar] Optional[Baz] Optional[Bingo] Optional.empty ---( false )--- Optional.empty Optional.empty Optional.empty Optional.empty Optional.empty Optional.empty ---( str != "" )--- Optional[Foo] Optional.empty Optional[Bar] Optional[Baz] Optional[Bingo] Optional.empty ---( str.length() == 3 )--- Optional[Foo] Optional.empty Optional[Bar] Optional[Baz] Optional.empty Optional.empty ---( startsWith("B") )--- Optional.empty Optional.empty Optional[Bar] Optional[Baz] Optional[Bingo] Optional.empty */ OnJava8-Examples-1.0/streams/OptionalFlatMap.java000066400000000000000000000031131374004044700217500ustar00rootroot00000000000000// streams/OptionalFlatMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; class OptionalFlatMap { static String[] elements = { "12", "", "23", "45" }; static Stream testStream() { return Arrays.stream(elements); } static void test(String descr, Function> func) { System.out.println(" ---( " + descr + " )---"); for(int i = 0; i <= elements.length; i++) { System.out.println( testStream() .skip(i) .findFirst() .flatMap(func)); } } public static void main(String[] args) { test("Add brackets", s -> Optional.of("[" + s + "]")); test("Increment", s -> { try { return Optional.of( Integer.parseInt(s) + 1 + ""); } catch(NumberFormatException e) { return Optional.of(s); } }); test("Replace", s -> Optional.of(s.replace("2", "9"))); test("Take last digit", s -> Optional.of(s.length() > 0 ? s.charAt(s.length() - 1) + "" : s)); } } /* Output: ---( Add brackets )--- Optional[[12]] Optional[[]] Optional[[23]] Optional[[45]] Optional.empty ---( Increment )--- Optional[13] Optional[] Optional[24] Optional[46] Optional.empty ---( Replace )--- Optional[19] Optional[] Optional[93] Optional[45] Optional.empty ---( Take last digit )--- Optional[2] Optional[] Optional[3] Optional[5] Optional.empty */ OnJava8-Examples-1.0/streams/OptionalMap.java000066400000000000000000000032751374004044700211520ustar00rootroot00000000000000// streams/OptionalMap.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; class OptionalMap { static String[] elements = { "12", "", "23", "45" }; static Stream testStream() { return Arrays.stream(elements); } static void test(String descr, Function func) { System.out.println(" ---( " + descr + " )---"); for(int i = 0; i <= elements.length; i++) { System.out.println( testStream() .skip(i) .findFirst() // Produces an Optional .map(func)); } } public static void main(String[] args) { // If Optional is not empty, map() first extracts // the contents which it then passes // to the function: test("Add brackets", s -> "[" + s + "]"); test("Increment", s -> { try { return Integer.parseInt(s) + 1 + ""; } catch(NumberFormatException e) { return s; } }); test("Replace", s -> s.replace("2", "9")); test("Take last digit", s -> s.length() > 0 ? s.charAt(s.length() - 1) + "" : s); } // After the function is finished, map() wraps the // result in an Optional before returning it: } /* Output: ---( Add brackets )--- Optional[[12]] Optional[[]] Optional[[23]] Optional[[45]] Optional.empty ---( Increment )--- Optional[13] Optional[] Optional[24] Optional[46] Optional.empty ---( Replace )--- Optional[19] Optional[] Optional[93] Optional[45] Optional.empty ---( Take last digit )--- Optional[2] Optional[] Optional[3] Optional[5] Optional.empty */ OnJava8-Examples-1.0/streams/Optionals.java000066400000000000000000000033441374004044700206740ustar00rootroot00000000000000// streams/Optionals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; public class Optionals { static void basics(Optional optString) { if(optString.isPresent()) System.out.println(optString.get()); else System.out.println("Nothing inside!"); } static void ifPresent(Optional optString) { optString.ifPresent(System.out::println); } static void orElse(Optional optString) { System.out.println(optString.orElse("Nada")); } static void orElseGet(Optional optString) { System.out.println( optString.orElseGet(() -> "Generated")); } static void orElseThrow(Optional optString) { try { System.out.println(optString.orElseThrow( () -> new Exception("Supplied"))); } catch(Exception e) { System.out.println("Caught " + e); } } static void test(String testName, Consumer> cos) { System.out.println(" === " + testName + " === "); cos.accept(Stream.of("Epithets").findFirst()); cos.accept(Stream.empty().findFirst()); } public static void main(String[] args) { test("basics", Optionals::basics); test("ifPresent", Optionals::ifPresent); test("orElse", Optionals::orElse); test("orElseGet", Optionals::orElseGet); test("orElseThrow", Optionals::orElseThrow); } } /* Output: === basics === Epithets Nothing inside! === ifPresent === Epithets === orElse === Epithets Nada === orElseGet === Epithets Generated === orElseThrow === Epithets Caught java.lang.Exception: Supplied */ OnJava8-Examples-1.0/streams/OptionalsFromEmptyStreams.java000066400000000000000000000016041374004044700240730ustar00rootroot00000000000000// streams/OptionalsFromEmptyStreams.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; class OptionalsFromEmptyStreams { public static void main(String[] args) { System.out.println(Stream.empty() .findFirst()); System.out.println(Stream.empty() .findAny()); System.out.println(Stream.empty() .max(String.CASE_INSENSITIVE_ORDER)); System.out.println(Stream.empty() .min(String.CASE_INSENSITIVE_ORDER)); System.out.println(Stream.empty() .reduce((s1, s2) -> s1 + s2)); System.out.println(IntStream.empty() .average()); } } /* Output: Optional.empty Optional.empty Optional.empty Optional.empty Optional.empty OptionalDouble.empty */ OnJava8-Examples-1.0/streams/Peeking.java000066400000000000000000000011041374004044700202760ustar00rootroot00000000000000// streams/Peeking.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Peeking { public static void main(String[] args) throws Exception { FileToWords.stream("Cheese.dat") .skip(21) .limit(4) .map(w -> w + " ") .peek(System.out::print) .map(String::toUpperCase) .peek(System.out::print) .map(String::toLowerCase) .forEach(System.out::print); } } /* Output: Well WELL well it IT it s S s so SO so */ OnJava8-Examples-1.0/streams/Prime.java000066400000000000000000000015371374004044700200020ustar00rootroot00000000000000// streams/Prime.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; import static java.util.stream.LongStream.*; public class Prime { public static boolean isPrime(long n) { return rangeClosed(2, (long)Math.sqrt(n)) .noneMatch(i -> n % i == 0); } public LongStream numbers() { return iterate(2, i -> i + 1) .filter(Prime::isPrime); } public static void main(String[] args) { new Prime().numbers() .limit(10) .forEach(n -> System.out.format("%d ", n)); System.out.println(); new Prime().numbers() .skip(90) .limit(10) .forEach(n -> System.out.format("%d ", n)); } } /* Output: 2 3 5 7 11 13 17 19 23 29 467 479 487 491 499 503 509 521 523 541 */ OnJava8-Examples-1.0/streams/RandInts.java000066400000000000000000000006651374004044700204510ustar00rootroot00000000000000// streams/RandInts.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package streams; import java.util.*; import java.util.stream.*; public class RandInts { private static int[] rints = new Random(47).ints(0, 1000).limit(100).toArray(); public static IntStream rands() { return Arrays.stream(rints); } } OnJava8-Examples-1.0/streams/RandomGenerators.java000066400000000000000000000032061374004044700221730ustar00rootroot00000000000000// streams/RandomGenerators.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class RandomGenerators { public static void show(Stream stream) { stream .limit(4) .forEach(System.out::println); System.out.println("++++++++"); } public static void main(String[] args) { Random rand = new Random(47); show(rand.ints().boxed()); show(rand.longs().boxed()); show(rand.doubles().boxed()); // Control the lower and upper bounds: show(rand.ints(10, 20).boxed()); show(rand.longs(50, 100).boxed()); show(rand.doubles(20, 30).boxed()); // Control the stream size: show(rand.ints(2).boxed()); show(rand.longs(2).boxed()); show(rand.doubles(2).boxed()); // Control the stream size and bounds: show(rand.ints(3, 3, 9).boxed()); show(rand.longs(3, 12, 22).boxed()); show(rand.doubles(3, 11.5, 12.3).boxed()); } } /* Output: -1172028779 1717241110 -2014573909 229403722 ++++++++ 2955289354441303771 3476817843704654257 -8917117694134521474 4941259272818818752 ++++++++ 0.2613610344283964 0.0508673570556899 0.8037155449603999 0.7620665811558285 ++++++++ 16 10 11 12 ++++++++ 65 99 54 58 ++++++++ 29.86777681078574 24.83968447804611 20.09247112332014 24.046793846338723 ++++++++ 1169976606 1947946283 ++++++++ 2970202997824602425 -2325326920272830366 ++++++++ 0.7024254510631527 0.6648552384607359 ++++++++ 6 7 7 ++++++++ 17 12 20 ++++++++ 12.27872414236691 11.732085449736195 12.196509449817267 ++++++++ */ OnJava8-Examples-1.0/streams/RandomWords.java000066400000000000000000000022621374004044700211610ustar00rootroot00000000000000// streams/RandomWords.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; import java.io.*; import java.nio.file.*; public class RandomWords implements Supplier { List words = new ArrayList<>(); Random rand = new Random(47); RandomWords(String fname) throws IOException { List lines = Files.readAllLines(Paths.get(fname)); // Skip the first line: for(String line : lines.subList(1, lines.size())) { for(String word : line.split("[ .?,]+")) words.add(word.toLowerCase()); } } public String get() { return words.get(rand.nextInt(words.size())); } @Override public String toString() { return words.stream() .collect(Collectors.joining(" ")); } public static void main(String[] args) throws Exception { System.out.println( Stream.generate(new RandomWords("Cheese.dat")) .limit(10) .collect(Collectors.joining(" "))); } } /* Output: it shop sir the much cheese by conclusion district is */ OnJava8-Examples-1.0/streams/Randoms.java000066400000000000000000000006661374004044700203330ustar00rootroot00000000000000// streams/Randoms.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class Randoms { public static void main(String[] args) { new Random(47) .ints(5, 20) .distinct() .limit(7) .sorted() .forEach(System.out::println); } } /* Output: 6 10 13 16 17 18 19 */ OnJava8-Examples-1.0/streams/Ranges.java000066400000000000000000000012261374004044700201400ustar00rootroot00000000000000// streams/Ranges.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import static java.util.stream.IntStream.*; public class Ranges { public static void main(String[] args) { // The traditional way: int result = 0; for(int i = 10; i < 20; i++) result += i; System.out.println(result); // for-in with a range: result = 0; for(int i : range(10, 20).toArray()) result += i; System.out.println(result); // Use streams: System.out.println(range(10, 20).sum()); } } /* Output: 145 145 145 */ OnJava8-Examples-1.0/streams/Reduce.java000066400000000000000000000016731374004044700201360ustar00rootroot00000000000000// streams/Reduce.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; class Frobnitz { int size; Frobnitz(int sz) { size = sz; } @Override public String toString() { return "Frobnitz(" + size + ")"; } // Generator: static Random rand = new Random(47); static final int BOUND = 100; static Frobnitz supply() { return new Frobnitz(rand.nextInt(BOUND)); } } public class Reduce { public static void main(String[] args) { Stream.generate(Frobnitz::supply) .limit(10) .peek(System.out::println) .reduce((fr0, fr1) -> fr0.size < 50 ? fr0 : fr1) .ifPresent(System.out::println); } } /* Output: Frobnitz(58) Frobnitz(55) Frobnitz(93) Frobnitz(61) Frobnitz(61) Frobnitz(29) Frobnitz(68) Frobnitz(0) Frobnitz(22) Frobnitz(7) Frobnitz(29) */ OnJava8-Examples-1.0/streams/SelectElement.java000066400000000000000000000011761374004044700214560ustar00rootroot00000000000000// streams/SelectElement.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import static streams.RandInts.*; public class SelectElement { public static void main(String[] args) { System.out.println(rands().findFirst().getAsInt()); System.out.println( rands().parallel().findFirst().getAsInt()); System.out.println(rands().findAny().getAsInt()); System.out.println( rands().parallel().findAny().getAsInt()); } } /* Output: 258 258 258 242 */ OnJava8-Examples-1.0/streams/Signal.java000066400000000000000000000015241374004044700201370ustar00rootroot00000000000000// streams/Signal.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import java.util.function.*; public class Signal { private final String msg; public Signal(String msg) { this.msg = msg; } public String getMsg() { return msg; } @Override public String toString() { return "Signal(" + msg + ")"; } static Random rand = new Random(47); public static Signal morse() { switch(rand.nextInt(4)) { case 1: return new Signal("dot"); case 2: return new Signal("dash"); default: return null; } } public static Stream> stream() { return Stream.generate(Signal::morse) .map(signal -> Optional.ofNullable(signal)); } } OnJava8-Examples-1.0/streams/SortedComparator.java000066400000000000000000000010441374004044700222070ustar00rootroot00000000000000// streams/SortedComparator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SortedComparator { public static void main(String[] args) throws Exception { FileToWords.stream("Cheese.dat") .skip(10) .limit(10) .sorted(Comparator.reverseOrder()) .map(w -> w + " ") .forEach(System.out::print); } } /* Output: you what to the that sir leads in district And */ OnJava8-Examples-1.0/streams/SpecialCollector.java000066400000000000000000000011761374004044700221540ustar00rootroot00000000000000// streams/SpecialCollector.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class SpecialCollector { public static void main(String[] args) throws Exception { ArrayList words = FileToWords.stream("Cheese.dat") .collect(ArrayList::new, ArrayList::add, ArrayList::addAll); words.stream() .filter(s -> s.equals("cheese")) .forEach(System.out::println); } } /* Output: cheese cheese */ OnJava8-Examples-1.0/streams/StreamOf.java000066400000000000000000000012651374004044700204440ustar00rootroot00000000000000// streams/StreamOf.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class StreamOf { public static void main(String[] args) { Stream.of( new Bubble(1), new Bubble(2), new Bubble(3)) .forEach(System.out::println); Stream.of("It's ", "a ", "wonderful ", "day ", "for ", "pie!") .forEach(System.out::print); System.out.println(); Stream.of(3.14159, 2.718, 1.618) .forEach(System.out::println); } } /* Output: Bubble(1) Bubble(2) Bubble(3) It's a wonderful day for pie! 3.14159 2.718 1.618 */ OnJava8-Examples-1.0/streams/StreamOfOptionals.java000066400000000000000000000015101374004044700223260ustar00rootroot00000000000000// streams/StreamOfOptionals.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class StreamOfOptionals { public static void main(String[] args) { Signal.stream() .limit(10) .forEach(System.out::println); System.out.println(" ---"); Signal.stream() .limit(10) .filter(Optional::isPresent) .map(Optional::get) .forEach(System.out::println); } } /* Output: Optional[Signal(dash)] Optional[Signal(dot)] Optional[Signal(dash)] Optional.empty Optional.empty Optional[Signal(dash)] Optional.empty Optional[Signal(dot)] Optional[Signal(dash)] Optional[Signal(dash)] --- Signal(dot) Signal(dot) Signal(dash) Signal(dash) */ OnJava8-Examples-1.0/streams/StreamOfRandoms.java000066400000000000000000000011411374004044700217610ustar00rootroot00000000000000// streams/StreamOfRandoms.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class StreamOfRandoms { static Random rand = new Random(47); public static void main(String[] args) { Stream.of(1, 2, 3, 4, 5) .flatMapToInt(i -> IntStream.concat( rand.ints(0, 100).limit(i), IntStream.of(-1))) .forEach(n -> System.out.format("%d ", n)); } } /* Output: 58 -1 55 93 -1 61 61 29 -1 68 0 22 7 -1 88 28 51 89 9 -1 */ OnJava8-Examples-1.0/streams/StreamOfStreams.java000066400000000000000000000011171374004044700217770ustar00rootroot00000000000000// streams/StreamOfStreams.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; public class StreamOfStreams { public static void main(String[] args) { Stream.of(1, 2, 3) .map(i -> Stream.of("Gonzo", "Kermit", "Beaker")) .map(e-> e.getClass().getName()) .forEach(System.out::println); } } /* Output: java.util.stream.ReferencePipeline$Head java.util.stream.ReferencePipeline$Head java.util.stream.ReferencePipeline$Head */ OnJava8-Examples-1.0/streams/TreeSetOfWords.java000066400000000000000000000020471374004044700216020ustar00rootroot00000000000000// streams/TreeSetOfWords.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.nio.file.*; import java.util.stream.*; public class TreeSetOfWords { public static void main(String[] args) throws Exception { Set words2 = Files.lines(Paths.get("TreeSetOfWords.java")) .flatMap(s -> Arrays.stream(s.split("\\W+"))) .filter(s -> !s.matches("\\d+")) // No numbers .map(String::trim) .filter(s -> s.length() > 2) .limit(100) .collect(Collectors.toCollection(TreeSet::new)); System.out.println(words2); } } /* Output: [Arrays, Collectors, Exception, Files, Output, Paths, Set, String, System, TreeSet, TreeSetOfWords, args, class, collect, file, filter, flatMap, get, import, java, length, limit, lines, main, map, matches, new, nio, numbers, out, println, public, split, static, stream, streams, throws, toCollection, trim, util, void, words2] */ OnJava8-Examples-1.0/strings/000077500000000000000000000000001374004044700160705ustar00rootroot00000000000000OnJava8-Examples-1.0/strings/ArrayListDisplay.java000066400000000000000000000011771374004044700222010ustar00rootroot00000000000000// strings/ArrayListDisplay.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; import generics.coffee.*; public class ArrayListDisplay { public static void main(String[] args) { List coffees = Stream.generate(new CoffeeSupplier()) .limit(10) .collect(Collectors.toList()); System.out.println(coffees); } } /* Output: [Americano 0, Latte 1, Americano 2, Mocha 3, Mocha 4, Breve 5, Americano 6, Latte 7, Cappuccino 8, Cappuccino 9] */ OnJava8-Examples-1.0/strings/BetterRead.java000066400000000000000000000021371374004044700207570ustar00rootroot00000000000000// strings/BetterRead.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class BetterRead { public static void main(String[] args) { Scanner stdin = new Scanner(SimpleRead.input); System.out.println("What is your name?"); String name = stdin.nextLine(); System.out.println(name); System.out.println( "How old are you? What is your favorite double?"); System.out.println("(input: )"); int age = stdin.nextInt(); double favorite = stdin.nextDouble(); System.out.println(age); System.out.println(favorite); System.out.format("Hi %s.%n", name); System.out.format("In 5 years you will be %d.%n", age + 5); System.out.format("My favorite double is %f.", favorite / 2); } } /* Output: What is your name? Sir Robin of Camelot How old are you? What is your favorite double? (input: ) 22 1.61803 Hi Sir Robin of Camelot. In 5 years you will be 27. My favorite double is 0.809015. */ OnJava8-Examples-1.0/strings/Concatenation.java000066400000000000000000000006151374004044700215220ustar00rootroot00000000000000// strings/Concatenation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Concatenation { public static void main(String[] args) { String mango = "mango"; String s = "abc" + mango + "def" + 47; System.out.println(s); } } /* Output: abcmangodef47 */ OnJava8-Examples-1.0/strings/Conversion.java000066400000000000000000000050221374004044700210570ustar00rootroot00000000000000// strings/Conversion.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.math.*; import java.util.*; public class Conversion { public static void main(String[] args) { Formatter f = new Formatter(System.out); char u = 'a'; System.out.println("u = 'a'"); f.format("s: %s%n", u); // f.format("d: %d%n", u); f.format("c: %c%n", u); f.format("b: %b%n", u); // f.format("f: %f%n", u); // f.format("e: %e%n", u); // f.format("x: %x%n", u); f.format("h: %h%n", u); int v = 121; System.out.println("v = 121"); f.format("d: %d%n", v); f.format("c: %c%n", v); f.format("b: %b%n", v); f.format("s: %s%n", v); // f.format("f: %f%n", v); // f.format("e: %e%n", v); f.format("x: %x%n", v); f.format("h: %h%n", v); BigInteger w = new BigInteger("50000000000000"); System.out.println( "w = new BigInteger(\"50000000000000\")"); f.format("d: %d%n", w); // f.format("c: %c%n", w); f.format("b: %b%n", w); f.format("s: %s%n", w); // f.format("f: %f%n", w); // f.format("e: %e%n", w); f.format("x: %x%n", w); f.format("h: %h%n", w); double x = 179.543; System.out.println("x = 179.543"); // f.format("d: %d%n", x); // f.format("c: %c%n", x); f.format("b: %b%n", x); f.format("s: %s%n", x); f.format("f: %f%n", x); f.format("e: %e%n", x); // f.format("x: %x%n", x); f.format("h: %h%n", x); Conversion y = new Conversion(); System.out.println("y = new Conversion()"); // f.format("d: %d%n", y); // f.format("c: %c%n", y); f.format("b: %b%n", y); f.format("s: %s%n", y); // f.format("f: %f%n", y); // f.format("e: %e%n", y); // f.format("x: %x%n", y); f.format("h: %h%n", y); boolean z = false; System.out.println("z = false"); // f.format("d: %d%n", z); // f.format("c: %c%n", z); f.format("b: %b%n", z); f.format("s: %s%n", z); // f.format("f: %f%n", z); // f.format("e: %e%n", z); // f.format("x: %x%n", z); f.format("h: %h%n", z); } } /* Output: u = 'a' s: a c: a b: true h: 61 v = 121 d: 121 c: y b: true s: 121 x: 79 h: 79 w = new BigInteger("50000000000000") d: 50000000000000 b: true s: 50000000000000 x: 2d79883d2000 h: 8842a1a7 x = 179.543 b: true s: 179.543 f: 179.543000 e: 1.795430e+02 h: 1ef462c y = new Conversion() b: true s: Conversion@15db9742 h: 15db9742 z = false b: false s: false h: 4d5 */ OnJava8-Examples-1.0/strings/DatabaseException.java000066400000000000000000000012121374004044700223120ustar00rootroot00000000000000// strings/DatabaseException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class DatabaseException extends Exception { public DatabaseException(int transactionID, int queryID, String message) { super(String.format("(t%d, q%d) %s", transactionID, queryID, message)); } public static void main(String[] args) { try { throw new DatabaseException(3, 7, "Write failed"); } catch(Exception e) { System.out.println(e); } } } /* Output: DatabaseException: (t3, q7) Write failed */ OnJava8-Examples-1.0/strings/Finding.java000066400000000000000000000014051374004044700203110ustar00rootroot00000000000000// strings/Finding.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; public class Finding { public static void main(String[] args) { Matcher m = Pattern.compile("\\w+") .matcher( "Evening is full of the linnet's wings"); while(m.find()) System.out.print(m.group() + " "); System.out.println(); int i = 0; while(m.find(i)) { System.out.print(m.group() + " "); i++; } } } /* Output: Evening is full of the linnet s wings Evening vening ening ning ing ng g is is s full full ull ll l of of f the the he e linnet linnet innet nnet net et t s s wings wings ings ngs gs s */ OnJava8-Examples-1.0/strings/Groups.java000066400000000000000000000025431374004044700202160ustar00rootroot00000000000000// strings/Groups.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; public class Groups { public static final String POEM = "Twas brillig, and the slithy toves\n" + "Did gyre and gimble in the wabe.\n" + "All mimsy were the borogoves,\n" + "And the mome raths outgrabe.\n\n" + "Beware the Jabberwock, my son,\n" + "The jaws that bite, the claws that catch.\n" + "Beware the Jubjub bird, and shun\n" + "The frumious Bandersnatch."; public static void main(String[] args) { Matcher m = Pattern.compile( "(?m)(\\S+)\\s+((\\S+)\\s+(\\S+))$") .matcher(POEM); while(m.find()) { for(int j = 0; j <= m.groupCount(); j++) System.out.print("[" + m.group(j) + "]"); System.out.println(); } } } /* Output: [the slithy toves][the][slithy toves][slithy][toves] [in the wabe.][in][the wabe.][the][wabe.] [were the borogoves,][were][the borogoves,][the][borogoves,] [mome raths outgrabe.][mome][raths outgrabe.][raths][outgrabe.] [Jabberwock, my son,][Jabberwock,][my son,][my][son,] [claws that catch.][claws][that catch.][that][catch.] [bird, and shun][bird,][and shun][and][shun] [The frumious Bandersnatch.][The][frumious Bandersnatch.][frumious][Bandersnatch.] */ OnJava8-Examples-1.0/strings/Hex.java000066400000000000000000000025631374004044700174650ustar00rootroot00000000000000// strings/Hex.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {java onjava.Hex} package onjava; import java.io.*; import java.nio.file.*; public class Hex { public static String format(byte[] data) { StringBuilder result = new StringBuilder(); int n = 0; for(byte b : data) { if(n % 16 == 0) result.append(String.format("%05X: ", n)); result.append(String.format("%02X ", b)); n++; if(n % 16 == 0) result.append("\n"); } result.append("\n"); return result.toString(); } public static void main(String[] args) throws Exception { if(args.length == 0) // Test by displaying this class file: System.out.println(format( Files.readAllBytes(Paths.get( "build/classes/java/main/onjava/Hex.class")))); else System.out.println(format( Files.readAllBytes(Paths.get(args[0])))); } } /* Output: (First 6 Lines) 00000: CA FE BA BE 00 00 00 34 00 61 0A 00 05 00 31 07 00010: 00 32 0A 00 02 00 31 08 00 33 07 00 34 0A 00 35 00020: 00 36 0A 00 0F 00 37 0A 00 02 00 38 08 00 39 0A 00030: 00 3A 00 3B 08 00 3C 0A 00 02 00 3D 09 00 3E 00 00040: 3F 08 00 40 07 00 41 0A 00 42 00 43 0A 00 44 00 00050: 45 0A 00 14 00 46 0A 00 47 00 48 07 00 49 01 00 ... */ OnJava8-Examples-1.0/strings/Immutable.java000066400000000000000000000010211374004044700206440ustar00rootroot00000000000000// strings/Immutable.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Immutable { public static String upcase(String s) { return s.toUpperCase(); } public static void main(String[] args) { String q = "howdy"; System.out.println(q); // howdy String qq = upcase(q); System.out.println(qq); // HOWDY System.out.println(q); // howdy } } /* Output: howdy HOWDY howdy */ OnJava8-Examples-1.0/strings/InfiniteRecursion.java000066400000000000000000000011671374004044700223770ustar00rootroot00000000000000// strings/InfiniteRecursion.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Accidental recursion // {ThrowsException} // {VisuallyInspectOutput} Throws very long exception import java.util.*; import java.util.stream.*; public class InfiniteRecursion { @Override public String toString() { return " InfiniteRecursion address: " + this + "\n"; } public static void main(String[] args) { Stream.generate(InfiniteRecursion::new) .limit(10) .forEach(System.out::println); } } OnJava8-Examples-1.0/strings/IntegerMatch.java000066400000000000000000000007771374004044700213200ustar00rootroot00000000000000// strings/IntegerMatch.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class IntegerMatch { public static void main(String[] args) { System.out.println("-1234".matches("-?\\d+")); System.out.println("5678".matches("-?\\d+")); System.out.println("+911".matches("-?\\d+")); System.out.println("+911".matches("(-|\\+)?\\d+")); } } /* Output: true true false true */ OnJava8-Examples-1.0/strings/JGrep.java000066400000000000000000000017101374004044700177410ustar00rootroot00000000000000// strings/JGrep.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // A very simple version of the "grep" program // {java JGrep // WhitherStringBuilder.java 'return|for|String'} import java.util.regex.*; import java.nio.file.*; import java.util.stream.*; public class JGrep { public static void main(String[] args) throws Exception { if(args.length < 2) { System.out.println( "Usage: java JGrep file regex"); System.exit(0); } Pattern p = Pattern.compile(args[1]); // Iterate through the lines of the input file: int index = 0; Matcher m = p.matcher(""); for(String line : Files.readAllLines(Paths.get(args[0]))) { m.reset(line); while(m.find()) System.out.println(index++ + ": " + m.group() + ": " + m.start()); } } } /* Output: 0: for: 4 1: for: 4 */ OnJava8-Examples-1.0/strings/ReFlags.java000066400000000000000000000011671374004044700202630ustar00rootroot00000000000000// strings/ReFlags.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; public class ReFlags { public static void main(String[] args) { Pattern p = Pattern.compile("^java", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE); Matcher m = p.matcher( "java has regex\nJava has regex\n" + "JAVA has pretty good regular expressions\n" + "Regular expressions are in Java"); while(m.find()) System.out.println(m.group()); } } /* Output: java Java JAVA */ OnJava8-Examples-1.0/strings/ReceiptBuilder.java000066400000000000000000000027231374004044700216410ustar00rootroot00000000000000// strings/ReceiptBuilder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ReceiptBuilder { private double total = 0; private Formatter f = new Formatter(new StringBuilder()); public ReceiptBuilder() { f.format( "%-15s %5s %10s%n", "Item", "Qty", "Price"); f.format( "%-15s %5s %10s%n", "----", "---", "-----"); } public void add(String name, int qty, double price) { f.format("%-15.15s %5d %10.2f%n", name, qty, price); total += price * qty; } public String build() { f.format("%-15s %5s %10.2f%n", "Tax", "", total * 0.06); f.format("%-15s %5s %10s%n", "", "", "-----"); f.format("%-15s %5s %10.2f%n", "Total", "", total * 1.06); return f.toString(); } public static void main(String[] args) { ReceiptBuilder receiptBuilder = new ReceiptBuilder(); receiptBuilder.add("Jack's Magic Beans", 4, 4.25); receiptBuilder.add("Princess Peas", 3, 5.1); receiptBuilder.add( "Three Bears Porridge", 1, 14.29); System.out.println(receiptBuilder.build()); } } /* Output: Item Qty Price ---- --- ----- Jack's Magic Be 4 4.25 Princess Peas 3 5.10 Three Bears Por 1 14.29 Tax 2.80 ----- Total 49.39 */ OnJava8-Examples-1.0/strings/Replacing.java000066400000000000000000000012611374004044700206370ustar00rootroot00000000000000// strings/Replacing.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Replacing { static String s = Splitting.knights; public static void main(String[] args) { System.out.println( s.replaceFirst("f\\w+", "located")); System.out.println( s.replaceAll("shrubbery|tree|herring","banana")); } } /* Output: Then, when you have located the shrubbery, you must cut down the mightiest tree in the forest...with... a herring! Then, when you have found the banana, you must cut down the mightiest banana in the forest...with... a banana! */ OnJava8-Examples-1.0/strings/ReplacingStringTokenizer.java000066400000000000000000000015311374004044700237210ustar00rootroot00000000000000// strings/ReplacingStringTokenizer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ReplacingStringTokenizer { public static void main(String[] args) { String input = "But I'm not dead yet! I feel happy!"; StringTokenizer stoke = new StringTokenizer(input); while(stoke.hasMoreElements()) System.out.print(stoke.nextToken() + " "); System.out.println(); System.out.println( Arrays.toString(input.split(" "))); Scanner scanner = new Scanner(input); while(scanner.hasNext()) System.out.print(scanner.next() + " "); } } /* Output: But I'm not dead yet! I feel happy! [But, I'm, not, dead, yet!, I, feel, happy!] But I'm not dead yet! I feel happy! */ OnJava8-Examples-1.0/strings/Resetting.java000066400000000000000000000011571374004044700207030ustar00rootroot00000000000000// strings/Resetting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; public class Resetting { public static void main(String[] args) throws Exception { Matcher m = Pattern.compile("[frb][aiu][gx]") .matcher("fix the rug with bags"); while(m.find()) System.out.print(m.group() + " "); System.out.println(); m.reset("fix the rig with rags"); while(m.find()) System.out.print(m.group() + " "); } } /* Output: fix rug bag fix rig rag */ OnJava8-Examples-1.0/strings/Rudolph.java000066400000000000000000000007241374004044700203530ustar00rootroot00000000000000// strings/Rudolph.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class Rudolph { public static void main(String[] args) { for(String pattern : new String[]{ "Rudolph", "[rR]udolph", "[rR][aeiou][a-z]ol.*", "R.*" }) System.out.println("Rudolph".matches(pattern)); } } /* Output: true true true true */ OnJava8-Examples-1.0/strings/ScannerDelimiter.java000066400000000000000000000007631374004044700221710ustar00rootroot00000000000000// strings/ScannerDelimiter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class ScannerDelimiter { public static void main(String[] args) { Scanner scanner = new Scanner("12, 42, 78, 99, 42"); scanner.useDelimiter("\\s*,\\s*"); while(scanner.hasNextInt()) System.out.println(scanner.nextInt()); } } /* Output: 12 42 78 99 42 */ OnJava8-Examples-1.0/strings/SimpleFormat.java000066400000000000000000000011131374004044700213310ustar00rootroot00000000000000// strings/SimpleFormat.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class SimpleFormat { public static void main(String[] args) { int x = 5; double y = 5.332542; // The old way: System.out.println("Row 1: [" + x + " " + y + "]"); // The new way: System.out.format("Row 1: [%d %f]%n", x, y); // or System.out.printf("Row 1: [%d %f]%n", x, y); } } /* Output: Row 1: [5 5.332542] Row 1: [5 5.332542] Row 1: [5 5.332542] */ OnJava8-Examples-1.0/strings/SimpleRead.java000066400000000000000000000025601374004044700207630ustar00rootroot00000000000000// strings/SimpleRead.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; public class SimpleRead { public static BufferedReader input = new BufferedReader(new StringReader( "Sir Robin of Camelot\n22 1.61803")); public static void main(String[] args) { try { System.out.println("What is your name?"); String name = input.readLine(); System.out.println(name); System.out.println("How old are you? " + "What is your favorite double?"); System.out.println("(input: )"); String numbers = input.readLine(); System.out.println(numbers); String[] numArray = numbers.split(" "); int age = Integer.parseInt(numArray[0]); double favorite = Double.parseDouble(numArray[1]); System.out.format("Hi %s.%n", name); System.out.format("In 5 years you will be %d.%n", age + 5); System.out.format("My favorite double is %f.", favorite / 2); } catch(IOException e) { System.err.println("I/O exception"); } } } /* Output: What is your name? Sir Robin of Camelot How old are you? What is your favorite double? (input: ) 22 1.61803 Hi Sir Robin of Camelot. In 5 years you will be 27. My favorite double is 0.809015. */ OnJava8-Examples-1.0/strings/SplitDemo.java000066400000000000000000000012541374004044700206350ustar00rootroot00000000000000// strings/SplitDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; import java.util.*; public class SplitDemo { public static void main(String[] args) { String input = "This!!unusual use!!of exclamation!!points"; System.out.println(Arrays.toString( Pattern.compile("!!").split(input))); // Only do the first three: System.out.println(Arrays.toString( Pattern.compile("!!").split(input, 3))); } } /* Output: [This, unusual use, of exclamation, points] [This, unusual use, of exclamation!!points] */ OnJava8-Examples-1.0/strings/Splitting.java000066400000000000000000000021201374004044700207030ustar00rootroot00000000000000// strings/Splitting.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class Splitting { public static String knights = "Then, when you have found the shrubbery, " + "you must cut down the mightiest tree in the " + "forest...with... a herring!"; public static void split(String regex) { System.out.println( Arrays.toString(knights.split(regex))); } public static void main(String[] args) { split(" "); // Doesn't have to contain regex chars split("\\W+"); // Non-word characters split("n\\W+"); // 'n' followed by non-words } } /* Output: [Then,, when, you, have, found, the, shrubbery,, you, must, cut, down, the, mightiest, tree, in, the, forest...with..., a, herring!] [Then, when, you, have, found, the, shrubbery, you, must, cut, down, the, mightiest, tree, in, the, forest, with, a, herring] [The, whe, you have found the shrubbery, you must cut dow, the mightiest tree i, the forest...with... a herring!] */ OnJava8-Examples-1.0/strings/StartEnd.java000066400000000000000000000047741374004044700204730ustar00rootroot00000000000000// strings/StartEnd.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; public class StartEnd { public static String input = "As long as there is injustice, whenever a\n" + "Targathian baby cries out, wherever a distress\n" + "signal sounds among the stars " + "... We'll be there.\n"+ "This fine ship, and this fine crew ...\n" + "Never give up! Never surrender!"; private static class Display { private boolean regexPrinted = false; private String regex; Display(String regex) { this.regex = regex; } void display(String message) { if(!regexPrinted) { System.out.println(regex); regexPrinted = true; } System.out.println(message); } } static void examine(String s, String regex) { Display d = new Display(regex); Pattern p = Pattern.compile(regex); Matcher m = p.matcher(s); while(m.find()) d.display("find() '" + m.group() + "' start = "+ m.start() + " end = " + m.end()); if(m.lookingAt()) // No reset() necessary d.display("lookingAt() start = " + m.start() + " end = " + m.end()); if(m.matches()) // No reset() necessary d.display("matches() start = " + m.start() + " end = " + m.end()); } public static void main(String[] args) { for(String in : input.split("\n")) { System.out.println("input : " + in); for(String regex : new String[]{"\\w*ere\\w*", "\\w*ever", "T\\w+", "Never.*?!"}) examine(in, regex); } } } /* Output: input : As long as there is injustice, whenever a \w*ere\w* find() 'there' start = 11 end = 16 \w*ever find() 'whenever' start = 31 end = 39 input : Targathian baby cries out, wherever a distress \w*ere\w* find() 'wherever' start = 27 end = 35 \w*ever find() 'wherever' start = 27 end = 35 T\w+ find() 'Targathian' start = 0 end = 10 lookingAt() start = 0 end = 10 input : signal sounds among the stars ... We'll be there. \w*ere\w* find() 'there' start = 43 end = 48 input : This fine ship, and this fine crew ... T\w+ find() 'This' start = 0 end = 4 lookingAt() start = 0 end = 4 input : Never give up! Never surrender! \w*ever find() 'Never' start = 0 end = 5 find() 'Never' start = 15 end = 20 lookingAt() start = 0 end = 5 Never.*?! find() 'Never give up!' start = 0 end = 14 find() 'Never surrender!' start = 15 end = 31 lookingAt() start = 0 end = 14 matches() start = 0 end = 31 */ OnJava8-Examples-1.0/strings/TestRegularExpression.java000066400000000000000000000025211374004044700232540ustar00rootroot00000000000000// strings/TestRegularExpression.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple regular expression demonstration // {java TestRegularExpression // abcabcabcdefabc "abc+" "(abc)+" } import java.util.regex.*; public class TestRegularExpression { public static void main(String[] args) { if(args.length < 2) { System.out.println( "Usage:\njava TestRegularExpression " + "characterSequence regularExpression+"); System.exit(0); } System.out.println("Input: \"" + args[0] + "\""); for(String arg : args) { System.out.println( "Regular expression: \"" + arg + "\""); Pattern p = Pattern.compile(arg); Matcher m = p.matcher(args[0]); while(m.find()) { System.out.println( "Match \"" + m.group() + "\" at positions " + m.start() + "-" + (m.end() - 1)); } } } } /* Output: Input: "abcabcabcdefabc" Regular expression: "abcabcabcdefabc" Match "abcabcabcdefabc" at positions 0-14 Regular expression: "abc+" Match "abc" at positions 0-2 Match "abc" at positions 3-5 Match "abc" at positions 6-8 Match "abc" at positions 12-14 Regular expression: "(abc)+" Match "abcabcabc" at positions 0-8 Match "abc" at positions 12-14 */ OnJava8-Examples-1.0/strings/TheReplacements.java000066400000000000000000000037301374004044700220210ustar00rootroot00000000000000// strings/TheReplacements.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; import java.nio.file.*; import java.util.stream.*; /*! Here's a block of text to use as input to the regular expression matcher. Note that we first extract the block of text by looking for the special delimiters, then process the extracted block. !*/ public class TheReplacements { public static void main(String[] args) throws Exception { String s = Files.lines( Paths.get("TheReplacements.java")) .collect(Collectors.joining("\n")); // Match specially commented block of text above: Matcher mInput = Pattern.compile( "/\\*!(.*)!\\*/", Pattern.DOTALL).matcher(s); if(mInput.find()) s = mInput.group(1); // Captured by parentheses // Replace two or more spaces with a single space: s = s.replaceAll(" {2,}", " "); // Replace 1+ spaces at the beginning of each // line with no spaces. Must enable MULTILINE mode: s = s.replaceAll("(?m)^ +", ""); System.out.println(s); s = s.replaceFirst("[aeiou]", "(VOWEL1)"); StringBuffer sbuf = new StringBuffer(); Pattern p = Pattern.compile("[aeiou]"); Matcher m = p.matcher(s); // Process the find information as you // perform the replacements: while(m.find()) m.appendReplacement( sbuf, m.group().toUpperCase()); // Put in the remainder of the text: m.appendTail(sbuf); System.out.println(sbuf); } } /* Output: Here's a block of text to use as input to the regular expression matcher. Note that we first extract the block of text by looking for the special delimiters, then process the extracted block. H(VOWEL1)rE's A blOck Of tExt tO UsE As InpUt tO thE rEgUlAr ExprEssIOn mAtchEr. NOtE thAt wE fIrst ExtrAct thE blOck Of tExt by lOOkIng fOr thE spEcIAl dElImItErs, thEn prOcEss thE ExtrActEd blOck. */ OnJava8-Examples-1.0/strings/ThreatAnalyzer.java000066400000000000000000000022221374004044700216660ustar00rootroot00000000000000// strings/ThreatAnalyzer.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.regex.*; import java.util.*; public class ThreatAnalyzer { static String threatData = "58.27.82.161@08/10/2015\n" + "204.45.234.40@08/11/2015\n" + "58.27.82.161@08/11/2015\n" + "58.27.82.161@08/12/2015\n" + "58.27.82.161@08/12/2015\n" + "[Next log section with different data format]"; public static void main(String[] args) { Scanner scanner = new Scanner(threatData); String pattern = "(\\d+[.]\\d+[.]\\d+[.]\\d+)@" + "(\\d{2}/\\d{2}/\\d{4})"; while(scanner.hasNext(pattern)) { scanner.next(pattern); MatchResult match = scanner.match(); String ip = match.group(1); String date = match.group(2); System.out.format( "Threat on %s from %s%n", date,ip); } } } /* Output: Threat on 08/10/2015 from 58.27.82.161 Threat on 08/11/2015 from 204.45.234.40 Threat on 08/11/2015 from 58.27.82.161 Threat on 08/12/2015 from 58.27.82.161 Threat on 08/12/2015 from 58.27.82.161 */ OnJava8-Examples-1.0/strings/Turtle.java000066400000000000000000000020041374004044700202060ustar00rootroot00000000000000// strings/Turtle.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.io.*; import java.util.*; public class Turtle { private String name; private Formatter f; public Turtle(String name, Formatter f) { this.name = name; this.f = f; } public void move(int x, int y) { f.format("%s The Turtle is at (%d,%d)%n", name, x, y); } public static void main(String[] args) { PrintStream outAlias = System.out; Turtle tommy = new Turtle("Tommy", new Formatter(System.out)); Turtle terry = new Turtle("Terry", new Formatter(outAlias)); tommy.move(0,0); terry.move(4,8); tommy.move(3,4); terry.move(2,5); tommy.move(3,3); terry.move(3,3); } } /* Output: Tommy The Turtle is at (0,0) Terry The Turtle is at (4,8) Tommy The Turtle is at (3,4) Terry The Turtle is at (2,5) Tommy The Turtle is at (3,3) Terry The Turtle is at (3,3) */ OnJava8-Examples-1.0/strings/UsingStringBuilder.java000066400000000000000000000022001374004044700225100ustar00rootroot00000000000000// strings/UsingStringBuilder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; import java.util.stream.*; public class UsingStringBuilder { public static String string1() { Random rand = new Random(47); StringBuilder result = new StringBuilder("["); for(int i = 0; i < 25; i++) { result.append(rand.nextInt(100)); result.append(", "); } result.delete(result.length()-2, result.length()); result.append("]"); return result.toString(); } public static String string2() { String result = new Random(47) .ints(25, 0, 100) .mapToObj(Integer::toString) .collect(Collectors.joining(", ")); return "[" + result + "]"; } public static void main(String[] args) { System.out.println(string1()); System.out.println(string2()); } } /* Output: [58, 55, 93, 61, 61, 29, 68, 0, 22, 7, 88, 28, 51, 89, 9, 78, 98, 61, 20, 58, 16, 40, 11, 22, 4] [58, 55, 93, 61, 61, 29, 68, 0, 22, 7, 88, 28, 51, 89, 9, 78, 98, 61, 20, 58, 16, 40, 11, 22, 4] */ OnJava8-Examples-1.0/strings/WhitherStringBuilder.java000066400000000000000000000011101374004044700230340ustar00rootroot00000000000000// strings/WhitherStringBuilder.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class WhitherStringBuilder { public String implicit(String[] fields) { String result = ""; for(String field : fields) { result += field; } return result; } public String explicit(String[] fields) { StringBuilder result = new StringBuilder(); for(String field : fields) { result.append(field); } return result.toString(); } } OnJava8-Examples-1.0/typeinfo/000077500000000000000000000000001374004044700162345ustar00rootroot00000000000000OnJava8-Examples-1.0/typeinfo/AnonymousImplementation.java000066400000000000000000000024301374004044700237740ustar00rootroot00000000000000// typeinfo/AnonymousImplementation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Anonymous inner classes can't hide from reflection import typeinfo.interfacea.*; class AnonymousA { public static A makeA() { return new A() { public void f() { System.out.println("public C.f()"); } public void g() { System.out.println("public C.g()"); } void u() { System.out.println("package C.u()"); } protected void v() { System.out.println("protected C.v()"); } private void w() { System.out.println("private C.w()"); } }; } } public class AnonymousImplementation { public static void main(String[] args) throws Exception { A a = AnonymousA.makeA(); a.f(); System.out.println(a.getClass().getName()); // Reflection still gets into the anonymous class: HiddenImplementation.callHiddenMethod(a, "g"); HiddenImplementation.callHiddenMethod(a, "u"); HiddenImplementation.callHiddenMethod(a, "v"); HiddenImplementation.callHiddenMethod(a, "w"); } } /* Output: public C.f() AnonymousA$1 public C.g() package C.u() protected C.v() private C.w() */ OnJava8-Examples-1.0/typeinfo/BoundedClassReferences.java000066400000000000000000000006701374004044700234520ustar00rootroot00000000000000// typeinfo/BoundedClassReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class BoundedClassReferences { public static void main(String[] args) { Class bounded = int.class; bounded = double.class; bounded = Number.class; // Or anything else derived from Number. } } OnJava8-Examples-1.0/typeinfo/ClassCasts.java000066400000000000000000000007201374004044700211410ustar00rootroot00000000000000// typeinfo/ClassCasts.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. class Building {} class House extends Building {} public class ClassCasts { public static void main(String[] args) { Building b = new House(); Class houseType = House.class; House h = houseType.cast(b); h = (House)b; // ... or just do this. } } OnJava8-Examples-1.0/typeinfo/ClassInitialization.java000066400000000000000000000026751374004044700230660ustar00rootroot00000000000000// typeinfo/ClassInitialization.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class Initable { static final int STATIC_FINAL = 47; static final int STATIC_FINAL2 = ClassInitialization.rand.nextInt(1000); static { System.out.println("Initializing Initable"); } } class Initable2 { static int staticNonFinal = 147; static { System.out.println("Initializing Initable2"); } } class Initable3 { static int staticNonFinal = 74; static { System.out.println("Initializing Initable3"); } } public class ClassInitialization { public static Random rand = new Random(47); public static void main(String[] args) throws Exception { Class initable = Initable.class; System.out.println("After creating Initable ref"); // Does not trigger initialization: System.out.println(Initable.STATIC_FINAL); // Does trigger initialization: System.out.println(Initable.STATIC_FINAL2); // Does trigger initialization: System.out.println(Initable2.staticNonFinal); Class initable3 = Class.forName("Initable3"); System.out.println("After creating Initable3 ref"); System.out.println(Initable3.staticNonFinal); } } /* Output: After creating Initable ref 47 Initializing Initable 258 Initializing Initable2 147 Initializing Initable3 After creating Initable3 ref 74 */ OnJava8-Examples-1.0/typeinfo/DynamicSupplier.java000066400000000000000000000016731374004044700222160ustar00rootroot00000000000000// typeinfo/DynamicSupplier.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; import java.util.stream.*; class CountedInteger { private static long counter; private final long id = counter++; @Override public String toString() { return Long.toString(id); } } public class DynamicSupplier implements Supplier { private Class type; public DynamicSupplier(Class type) { this.type = type; } @SuppressWarnings("deprecation") public T get() { try { return type.newInstance(); } catch(Exception e) { throw new RuntimeException(e); } } public static void main(String[] args) { Stream.generate( new DynamicSupplier<>(CountedInteger.class)) .skip(10) .limit(5) .forEach(System.out::println); } } /* Output: 10 11 12 13 14 */ OnJava8-Examples-1.0/typeinfo/FamilyVsExactType.java000066400000000000000000000036071374004044700224660ustar00rootroot00000000000000// typeinfo/FamilyVsExactType.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // The difference between instanceof and class // {java typeinfo.FamilyVsExactType} package typeinfo; class Base {} class Derived extends Base {} public class FamilyVsExactType { static void test(Object x) { System.out.println( "Testing x of type " + x.getClass()); System.out.println( "x instanceof Base " + (x instanceof Base)); System.out.println( "x instanceof Derived " + (x instanceof Derived)); System.out.println( "Base.isInstance(x) " + Base.class.isInstance(x)); System.out.println( "Derived.isInstance(x) " + Derived.class.isInstance(x)); System.out.println( "x.getClass() == Base.class " + (x.getClass() == Base.class)); System.out.println( "x.getClass() == Derived.class " + (x.getClass() == Derived.class)); System.out.println( "x.getClass().equals(Base.class)) "+ (x.getClass().equals(Base.class))); System.out.println( "x.getClass().equals(Derived.class)) " + (x.getClass().equals(Derived.class))); } public static void main(String[] args) { test(new Base()); test(new Derived()); } } /* Output: Testing x of type class typeinfo.Base x instanceof Base true x instanceof Derived false Base.isInstance(x) true Derived.isInstance(x) false x.getClass() == Base.class true x.getClass() == Derived.class false x.getClass().equals(Base.class)) true x.getClass().equals(Derived.class)) false Testing x of type class typeinfo.Derived x instanceof Base true x instanceof Derived true Base.isInstance(x) true Derived.isInstance(x) true x.getClass() == Base.class false x.getClass() == Derived.class true x.getClass().equals(Base.class)) false x.getClass().equals(Derived.class)) true */ OnJava8-Examples-1.0/typeinfo/GenericClassReferences.java000066400000000000000000000007641374004044700234520ustar00rootroot00000000000000// typeinfo/GenericClassReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class GenericClassReferences { public static void main(String[] args) { Class intClass = int.class; Class genericIntClass = int.class; genericIntClass = Integer.class; // Same thing intClass = double.class; // genericIntClass = double.class; // Illegal } } OnJava8-Examples-1.0/typeinfo/HiddenImplementation.java000066400000000000000000000021751374004044700232050ustar00rootroot00000000000000// typeinfo/HiddenImplementation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Sneaking around package hiding import typeinfo.interfacea.*; import typeinfo.packageaccess.*; import java.lang.reflect.*; public class HiddenImplementation { public static void main(String[] args) throws Exception { A a = HiddenC.makeA(); a.f(); System.out.println(a.getClass().getName()); // Compile error: cannot find symbol 'C': /* if(a instanceof C) { C c = (C)a; c.g(); } */ // Oops! Reflection still allows us to call g(): callHiddenMethod(a, "g"); // And even less accessible methods! callHiddenMethod(a, "u"); callHiddenMethod(a, "v"); callHiddenMethod(a, "w"); } static void callHiddenMethod(Object a, String methodName) throws Exception { Method g = a.getClass().getDeclaredMethod(methodName); g.setAccessible(true); g.invoke(a); } } /* Output: public C.f() typeinfo.packageaccess.C public C.g() package C.u() protected C.v() private C.w() */ OnJava8-Examples-1.0/typeinfo/InnerImplementation.java000066400000000000000000000024001374004044700230540ustar00rootroot00000000000000// typeinfo/InnerImplementation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Private inner classes can't hide from reflection import typeinfo.interfacea.*; class InnerA { private static class C implements A { public void f() { System.out.println("public C.f()"); } public void g() { System.out.println("public C.g()"); } void u() { System.out.println("package C.u()"); } protected void v() { System.out.println("protected C.v()"); } private void w() { System.out.println("private C.w()"); } } public static A makeA() { return new C(); } } public class InnerImplementation { public static void main(String[] args) throws Exception { A a = InnerA.makeA(); a.f(); System.out.println(a.getClass().getName()); // Reflection still gets into the private class: HiddenImplementation.callHiddenMethod(a, "g"); HiddenImplementation.callHiddenMethod(a, "u"); HiddenImplementation.callHiddenMethod(a, "v"); HiddenImplementation.callHiddenMethod(a, "w"); } } /* Output: public C.f() InnerA$C public C.g() package C.u() protected C.v() private C.w() */ OnJava8-Examples-1.0/typeinfo/InterfaceViolation.java000066400000000000000000000011271374004044700226650ustar00rootroot00000000000000// typeinfo/InterfaceViolation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Sneaking around an interface import typeinfo.interfacea.*; class B implements A { public void f() {} public void g() {} } public class InterfaceViolation { public static void main(String[] args) { A a = new B(); a.f(); // a.g(); // Compile error System.out.println(a.getClass().getName()); if(a instanceof B) { B b = (B)a; b.g(); } } } /* Output: B */ OnJava8-Examples-1.0/typeinfo/ModifyingPrivateFields.java000066400000000000000000000026561374004044700235170ustar00rootroot00000000000000// typeinfo/ModifyingPrivateFields.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.reflect.*; class WithPrivateFinalField { private int i = 1; private final String s = "I'm totally safe"; private String s2 = "Am I safe?"; @Override public String toString() { return "i = " + i + ", " + s + ", " + s2; } } public class ModifyingPrivateFields { public static void main(String[] args) throws Exception { WithPrivateFinalField pf = new WithPrivateFinalField(); System.out.println(pf); Field f = pf.getClass().getDeclaredField("i"); f.setAccessible(true); System.out.println( "f.getInt(pf): " + f.getInt(pf)); f.setInt(pf, 47); System.out.println(pf); f = pf.getClass().getDeclaredField("s"); f.setAccessible(true); System.out.println("f.get(pf): " + f.get(pf)); f.set(pf, "No, you're not!"); System.out.println(pf); f = pf.getClass().getDeclaredField("s2"); f.setAccessible(true); System.out.println("f.get(pf): " + f.get(pf)); f.set(pf, "No, you're not!"); System.out.println(pf); } } /* Output: i = 1, I'm totally safe, Am I safe? f.getInt(pf): 1 i = 47, I'm totally safe, Am I safe? f.get(pf): I'm totally safe i = 47, I'm totally safe, Am I safe? f.get(pf): Am I safe? i = 47, I'm totally safe, No, you're not! */ OnJava8-Examples-1.0/typeinfo/NullRobot.java000066400000000000000000000032731374004044700210240ustar00rootroot00000000000000// typeinfo/NullRobot.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using a dynamic proxy to create an Optional import java.lang.reflect.*; import java.util.*; import java.util.stream.*; import onjava.*; class NullRobotProxyHandler implements InvocationHandler { private String nullName; private Robot proxied = new NRobot(); NullRobotProxyHandler(Class type) { nullName = type.getSimpleName() + " NullRobot"; } private class NRobot implements Null, Robot { @Override public String name() { return nullName; } @Override public String model() { return nullName; } @Override public List operations() { return Collections.emptyList(); } } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return method.invoke(proxied, args); } } public class NullRobot { public static Robot newNullRobot(Class type) { return (Robot)Proxy.newProxyInstance( NullRobot.class.getClassLoader(), new Class[]{ Null.class, Robot.class }, new NullRobotProxyHandler(type)); } public static void main(String[] args) { Stream.of( new SnowRemovalRobot("SnowBee"), newNullRobot(SnowRemovalRobot.class) ).forEach(Robot::test); } } /* Output: Robot name: SnowBee Robot model: SnowBot Series 11 SnowBee can shovel snow SnowBee shoveling snow SnowBee can chip ice SnowBee chipping ice SnowBee can clear the roof SnowBee clearing roof [Null Robot] Robot name: SnowRemovalRobot NullRobot Robot model: SnowRemovalRobot NullRobot */ OnJava8-Examples-1.0/typeinfo/Operation.java000066400000000000000000000006611374004044700210420ustar00rootroot00000000000000// typeinfo/Operation.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.function.*; public class Operation { public final Supplier description; public final Runnable command; public Operation(Supplier descr, Runnable cmd) { description = descr; command = cmd; } } OnJava8-Examples-1.0/typeinfo/Person.java000066400000000000000000000026521374004044700203520ustar00rootroot00000000000000// typeinfo/Person.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using Optional with regular classes import onjava.*; import java.util.*; class Person { public final Optional first; public final Optional last; public final Optional address; // etc. public final boolean empty; Person(String first, String last, String address) { this.first = Optional.ofNullable(first); this.last = Optional.ofNullable(last); this.address = Optional.ofNullable(address); empty = !this.first.isPresent() && !this.last.isPresent() && !this.address.isPresent(); } Person(String first, String last) { this(first, last, null); } Person(String last) { this(null, last, null); } Person() { this(null, null, null); } @Override public String toString() { if(empty) return ""; return (first.orElse("") + " " + last.orElse("") + " " + address.orElse("")).trim(); } public static void main(String[] args) { System.out.println(new Person()); System.out.println(new Person("Smith")); System.out.println(new Person("Bob", "Smith")); System.out.println(new Person("Bob", "Smith", "11 Degree Lane, Frostbite Falls, MN")); } } /* Output: Smith Bob Smith Bob Smith 11 Degree Lane, Frostbite Falls, MN */ OnJava8-Examples-1.0/typeinfo/PetCount.java000066400000000000000000000036011374004044700206400ustar00rootroot00000000000000// typeinfo/PetCount.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using instanceof import typeinfo.pets.*; import java.util.*; public class PetCount { static class Counter extends HashMap { public void count(String type) { Integer quantity = get(type); if(quantity == null) put(type, 1); else put(type, quantity + 1); } } public static void countPets(PetCreator creator) { Counter counter = new Counter(); for(Pet pet : Pets.array(20)) { // List each individual pet: System.out.print( pet.getClass().getSimpleName() + " "); if(pet instanceof Pet) counter.count("Pet"); if(pet instanceof Dog) counter.count("Dog"); if(pet instanceof Mutt) counter.count("Mutt"); if(pet instanceof Pug) counter.count("Pug"); if(pet instanceof Cat) counter.count("Cat"); if(pet instanceof EgyptianMau) counter.count("EgyptianMau"); if(pet instanceof Manx) counter.count("Manx"); if(pet instanceof Cymric) counter.count("Cymric"); if(pet instanceof Rodent) counter.count("Rodent"); if(pet instanceof Rat) counter.count("Rat"); if(pet instanceof Mouse) counter.count("Mouse"); if(pet instanceof Hamster) counter.count("Hamster"); } // Show the counts: System.out.println(); System.out.println(counter); } public static void main(String[] args) { countPets(new ForNameCreator()); } } /* Output: Rat Manx Cymric Mutt Pug Cymric Pug Manx Cymric Rat EgyptianMau Hamster EgyptianMau Mutt Mutt Cymric Mouse Pug Mouse Cymric {EgyptianMau=2, Pug=3, Rat=2, Cymric=5, Mouse=2, Cat=9, Manx=7, Rodent=5, Mutt=3, Dog=6, Pet=20, Hamster=1} */ OnJava8-Examples-1.0/typeinfo/PetCount2.java000066400000000000000000000010741374004044700207240ustar00rootroot00000000000000// typeinfo/PetCount2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; public class PetCount2 { public static void main(String[] args) { PetCount.countPets(Pets.CREATOR); } } /* Output: Rat Manx Cymric Mutt Pug Cymric Pug Manx Cymric Rat EgyptianMau Hamster EgyptianMau Mutt Mutt Cymric Mouse Pug Mouse Cymric {EgyptianMau=2, Pug=3, Rat=2, Cymric=5, Mouse=2, Cat=9, Manx=7, Rodent=5, Mutt=3, Dog=6, Pet=20, Hamster=1} */ OnJava8-Examples-1.0/typeinfo/PetCount3.java000066400000000000000000000031551374004044700207270ustar00rootroot00000000000000// typeinfo/PetCount3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using isInstance() import java.util.*; import java.util.stream.*; import onjava.*; import typeinfo.pets.*; public class PetCount3 { static class Counter extends LinkedHashMap, Integer> { Counter() { super(LiteralPetCreator.ALL_TYPES.stream() .map(lpc -> Pair.make(lpc, 0)) .collect( Collectors.toMap(Pair::key, Pair::value))); } public void count(Pet pet) { // Class.isInstance() eliminates instanceofs: entrySet().stream() .filter(pair -> pair.getKey().isInstance(pet)) .forEach(pair -> put(pair.getKey(), pair.getValue() + 1)); } @Override public String toString() { String result = entrySet().stream() .map(pair -> String.format("%s=%s", pair.getKey().getSimpleName(), pair.getValue())) .collect(Collectors.joining(", ")); return "{" + result + "}"; } } public static void main(String[] args) { Counter petCount = new Counter(); Pets.stream() .limit(20) .peek(petCount::count) .forEach(p -> System.out.print( p.getClass().getSimpleName() + " ")); System.out.println("\n" + petCount); } } /* Output: Rat Manx Cymric Mutt Pug Cymric Pug Manx Cymric Rat EgyptianMau Hamster EgyptianMau Mutt Mutt Cymric Mouse Pug Mouse Cymric {Rat=2, Pug=3, Mutt=3, Mouse=2, Cat=9, Dog=6, Cymric=5, EgyptianMau=2, Rodent=5, Hamster=1, Manx=7, Pet=20} */ OnJava8-Examples-1.0/typeinfo/PetCount4.java000066400000000000000000000014301374004044700207220ustar00rootroot00000000000000// typeinfo/PetCount4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import typeinfo.pets.*; import onjava.*; public class PetCount4 { public static void main(String[] args) { TypeCounter counter = new TypeCounter(Pet.class); Pets.stream() .limit(20) .peek(counter::count) .forEach(p -> System.out.print( p.getClass().getSimpleName() + " ")); System.out.println("\n" + counter); } } /* Output: Rat Manx Cymric Mutt Pug Cymric Pug Manx Cymric Rat EgyptianMau Hamster EgyptianMau Mutt Mutt Cymric Mouse Pug Mouse Cymric {Dog=6, Manx=7, Cat=9, Rodent=5, Hamster=1, Rat=2, Pug=3, Mutt=3, Cymric=5, EgyptianMau=2, Pet=20, Mouse=2} */ OnJava8-Examples-1.0/typeinfo/Position.java000066400000000000000000000026771374004044700207170ustar00rootroot00000000000000// typeinfo/Position.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; class EmptyTitleException extends RuntimeException {} class Position { private String title; private Person person; Position(String jobTitle, Person employee) { setTitle(jobTitle); setPerson(employee); } Position(String jobTitle) { this(jobTitle, null); } public String getTitle() { return title; } public void setTitle(String newTitle) { // Throws EmptyTitleException if newTitle is null: title = Optional.ofNullable(newTitle) .orElseThrow(EmptyTitleException::new); } public Person getPerson() { return person; } public void setPerson(Person newPerson) { // Uses empty Person if newPerson is null: person = Optional.ofNullable(newPerson) .orElse(new Person()); } @Override public String toString() { return "Position: " + title + ", Employee: " + person; } public static void main(String[] args) { System.out.println(new Position("CEO")); System.out.println(new Position("Programmer", new Person("Arthur", "Fonzarelli"))); try { new Position(null); } catch(Exception e) { System.out.println("caught " + e); } } } /* Output: Position: CEO, Employee: Position: Programmer, Employee: Arthur Fonzarelli caught EmptyTitleException */ OnJava8-Examples-1.0/typeinfo/RegisteredFactories.java000066400000000000000000000037271374004044700230450ustar00rootroot00000000000000// typeinfo/RegisteredFactories.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Registering Factories in the base class import java.util.*; import java.util.function.*; import java.util.stream.*; class Part implements Supplier { @Override public String toString() { return getClass().getSimpleName(); } static List> prototypes = Arrays.asList( new FuelFilter(), new AirFilter(), new CabinAirFilter(), new OilFilter(), new FanBelt(), new PowerSteeringBelt(), new GeneratorBelt() ); private static Random rand = new Random(47); public Part get() { int n = rand.nextInt(prototypes.size()); return prototypes.get(n).get(); } } class Filter extends Part {} class FuelFilter extends Filter { @Override public FuelFilter get() { return new FuelFilter(); } } class AirFilter extends Filter { @Override public AirFilter get() { return new AirFilter(); } } class CabinAirFilter extends Filter { @Override public CabinAirFilter get() { return new CabinAirFilter(); } } class OilFilter extends Filter { @Override public OilFilter get() { return new OilFilter(); } } class Belt extends Part {} class FanBelt extends Belt { @Override public FanBelt get() { return new FanBelt(); } } class GeneratorBelt extends Belt { @Override public GeneratorBelt get() { return new GeneratorBelt(); } } class PowerSteeringBelt extends Belt { @Override public PowerSteeringBelt get() { return new PowerSteeringBelt(); } } public class RegisteredFactories { public static void main(String[] args) { Stream.generate(new Part()) .limit(10) .forEach(System.out::println); } } /* Output: GeneratorBelt CabinAirFilter GeneratorBelt AirFilter PowerSteeringBelt CabinAirFilter FuelFilter PowerSteeringBelt PowerSteeringBelt FuelFilter */ OnJava8-Examples-1.0/typeinfo/Robot.java000066400000000000000000000012271374004044700201660ustar00rootroot00000000000000// typeinfo/Robot.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import onjava.*; import java.util.*; public interface Robot { String name(); String model(); List operations(); static void test(Robot r) { if(r instanceof Null) System.out.println("[Null Robot]"); System.out.println("Robot name: " + r.name()); System.out.println("Robot model: " + r.model()); for(Operation operation : r.operations()) { System.out.println(operation.description.get()); operation.command.run(); } } } OnJava8-Examples-1.0/typeinfo/SelectingMethods.java000066400000000000000000000031741374004044700223450ustar00rootroot00000000000000// typeinfo/SelectingMethods.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Looking for particular methods in a dynamic proxy import java.lang.reflect.*; class MethodSelector implements InvocationHandler { private Object proxied; MethodSelector(Object proxied) { this.proxied = proxied; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if(method.getName().equals("interesting")) System.out.println( "Proxy detected the interesting method"); return method.invoke(proxied, args); } } interface SomeMethods { void boring1(); void boring2(); void interesting(String arg); void boring3(); } class Implementation implements SomeMethods { @Override public void boring1() { System.out.println("boring1"); } @Override public void boring2() { System.out.println("boring2"); } @Override public void interesting(String arg) { System.out.println("interesting " + arg); } @Override public void boring3() { System.out.println("boring3"); } } class SelectingMethods { public static void main(String[] args) { SomeMethods proxy = (SomeMethods)Proxy.newProxyInstance( SomeMethods.class.getClassLoader(), new Class[]{ SomeMethods.class }, new MethodSelector(new Implementation())); proxy.boring1(); proxy.boring2(); proxy.interesting("bonobo"); proxy.boring3(); } } /* Output: boring1 boring2 Proxy detected the interesting method interesting bonobo boring3 */ OnJava8-Examples-1.0/typeinfo/Shapes.java000066400000000000000000000015201374004044700203200ustar00rootroot00000000000000// typeinfo/Shapes.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.stream.*; abstract class Shape { void draw() { System.out.println(this + ".draw()"); } @Override public abstract String toString(); } class Circle extends Shape { @Override public String toString() { return "Circle"; } } class Square extends Shape { @Override public String toString() { return "Square"; } } class Triangle extends Shape { @Override public String toString() { return "Triangle"; } } public class Shapes { public static void main(String[] args) { Stream.of( new Circle(), new Square(), new Triangle()) .forEach(Shape::draw); } } /* Output: Circle.draw() Square.draw() Triangle.draw() */ OnJava8-Examples-1.0/typeinfo/ShowMethods.java000066400000000000000000000044221374004044700213450ustar00rootroot00000000000000// typeinfo/ShowMethods.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using reflection to show all the methods of a class, // even if the methods are defined in the base class // {java ShowMethods ShowMethods} import java.lang.reflect.*; import java.util.regex.*; public class ShowMethods { private static String usage = "usage:\n" + "ShowMethods qualified.class.name\n" + "To show all methods in class or:\n" + "ShowMethods qualified.class.name word\n" + "To search for methods involving 'word'"; private static Pattern p = Pattern.compile("\\w+\\."); public static void main(String[] args) { if(args.length < 1) { System.out.println(usage); System.exit(0); } int lines = 0; try { Class c = Class.forName(args[0]); Method[] methods = c.getMethods(); Constructor[] ctors = c.getConstructors(); if(args.length == 1) { for(Method method : methods) System.out.println( p.matcher( method.toString()).replaceAll("")); for(Constructor ctor : ctors) System.out.println( p.matcher(ctor.toString()).replaceAll("")); lines = methods.length + ctors.length; } else { for(Method method : methods) if(method.toString().contains(args[1])) { System.out.println(p.matcher( method.toString()).replaceAll("")); lines++; } for(Constructor ctor : ctors) if(ctor.toString().contains(args[1])) { System.out.println(p.matcher( ctor.toString()).replaceAll("")); lines++; } } } catch(ClassNotFoundException e) { System.out.println("No such class: " + e); } } } /* Output: public static void main(String[]) public final void wait() throws InterruptedException public final void wait(long,int) throws InterruptedException public final native void wait(long) throws InterruptedException public boolean equals(Object) public String toString() public native int hashCode() public final native Class getClass() public final native void notify() public final native void notifyAll() public ShowMethods() */ OnJava8-Examples-1.0/typeinfo/SimpleDynamicProxy.java000066400000000000000000000027761374004044700227130ustar00rootroot00000000000000// typeinfo/SimpleDynamicProxy.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.lang.reflect.*; class DynamicProxyHandler implements InvocationHandler { private Object proxied; DynamicProxyHandler(Object proxied) { this.proxied = proxied; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println( "**** proxy: " + proxy.getClass() + ", method: " + method + ", args: " + args); if(args != null) for(Object arg : args) System.out.println(" " + arg); return method.invoke(proxied, args); } } class SimpleDynamicProxy { public static void consumer(Interface iface) { iface.doSomething(); iface.somethingElse("bonobo"); } public static void main(String[] args) { RealObject real = new RealObject(); consumer(real); // Insert a proxy and call again: Interface proxy = (Interface)Proxy.newProxyInstance( Interface.class.getClassLoader(), new Class[]{ Interface.class }, new DynamicProxyHandler(real)); consumer(proxy); } } /* Output: doSomething somethingElse bonobo **** proxy: class $Proxy0, method: public abstract void Interface.doSomething(), args: null doSomething **** proxy: class $Proxy0, method: public abstract void Interface.somethingElse(java.lang.String), args: [Ljava.lang.Object;@6bc7c054 bonobo somethingElse bonobo */ OnJava8-Examples-1.0/typeinfo/SimpleProxyDemo.java000066400000000000000000000024701374004044700222020ustar00rootroot00000000000000// typeinfo/SimpleProxyDemo.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. interface Interface { void doSomething(); void somethingElse(String arg); } class RealObject implements Interface { @Override public void doSomething() { System.out.println("doSomething"); } @Override public void somethingElse(String arg) { System.out.println("somethingElse " + arg); } } class SimpleProxy implements Interface { private Interface proxied; SimpleProxy(Interface proxied) { this.proxied = proxied; } @Override public void doSomething() { System.out.println("SimpleProxy doSomething"); proxied.doSomething(); } @Override public void somethingElse(String arg) { System.out.println( "SimpleProxy somethingElse " + arg); proxied.somethingElse(arg); } } class SimpleProxyDemo { public static void consumer(Interface iface) { iface.doSomething(); iface.somethingElse("bonobo"); } public static void main(String[] args) { consumer(new RealObject()); consumer(new SimpleProxy(new RealObject())); } } /* Output: doSomething somethingElse bonobo SimpleProxy doSomething doSomething SimpleProxy somethingElse bonobo somethingElse bonobo */ OnJava8-Examples-1.0/typeinfo/SnowRemovalRobot.java000066400000000000000000000023351374004044700223640ustar00rootroot00000000000000// typeinfo/SnowRemovalRobot.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class SnowRemovalRobot implements Robot { private String name; public SnowRemovalRobot(String name) { this.name = name; } @Override public String name() { return name; } @Override public String model() { return "SnowBot Series 11"; } private List ops = Arrays.asList( new Operation( () -> name + " can shovel snow", () -> System.out.println( name + " shoveling snow")), new Operation( () -> name + " can chip ice", () -> System.out.println(name + " chipping ice")), new Operation( () -> name + " can clear the roof", () -> System.out.println( name + " clearing roof"))); public List operations() { return ops; } public static void main(String[] args) { Robot.test(new SnowRemovalRobot("Slusher")); } } /* Output: Robot name: Slusher Robot model: SnowBot Series 11 Slusher can shovel snow Slusher shoveling snow Slusher can chip ice Slusher chipping ice Slusher can clear the roof Slusher clearing roof */ OnJava8-Examples-1.0/typeinfo/Staff.java000066400000000000000000000043461374004044700201510ustar00rootroot00000000000000// typeinfo/Staff.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import java.util.*; public class Staff extends ArrayList { public void add(String title, Person person) { add(new Position(title, person)); } public void add(String... titles) { for(String title : titles) add(new Position(title)); } public Staff(String... titles) { add(titles); } public boolean positionAvailable(String title) { for(Position position : this) if(position.getTitle().equals(title) && position.getPerson().empty) return true; return false; } public void fillPosition(String title, Person hire) { for(Position position : this) if(position.getTitle().equals(title) && position.getPerson().empty) { position.setPerson(hire); return; } throw new RuntimeException( "Position " + title + " not available"); } public static void main(String[] args) { Staff staff = new Staff("President", "CTO", "Marketing Manager", "Product Manager", "Project Lead", "Software Engineer", "Software Engineer", "Software Engineer", "Software Engineer", "Test Engineer", "Technical Writer"); staff.fillPosition("President", new Person("Me", "Last", "The Top, Lonely At")); staff.fillPosition("Project Lead", new Person("Janet", "Planner", "The Burbs")); if(staff.positionAvailable("Software Engineer")) staff.fillPosition("Software Engineer", new Person( "Bob", "Coder", "Bright Light City")); System.out.println(staff); } } /* Output: [Position: President, Employee: Me Last The Top, Lonely At, Position: CTO, Employee: , Position: Marketing Manager, Employee: , Position: Product Manager, Employee: , Position: Project Lead, Employee: Janet Planner The Burbs, Position: Software Engineer, Employee: Bob Coder Bright Light City, Position: Software Engineer, Employee: , Position: Software Engineer, Employee: , Position: Software Engineer, Employee: , Position: Test Engineer, Employee: , Position: Technical Writer, Employee: ] */ OnJava8-Examples-1.0/typeinfo/SweetShop.java000066400000000000000000000017571374004044700210320ustar00rootroot00000000000000// typeinfo/SweetShop.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Examination of the way the class loader works class Cookie { static { System.out.println("Loading Cookie"); } } class Gum { static { System.out.println("Loading Gum"); } } class Candy { static { System.out.println("Loading Candy"); } } public class SweetShop { public static void main(String[] args) { System.out.println("inside main"); new Candy(); System.out.println("After creating Candy"); try { Class.forName("Gum"); } catch(ClassNotFoundException e) { System.out.println("Couldn't find Gum"); } System.out.println("After Class.forName(\"Gum\")"); new Cookie(); System.out.println("After creating Cookie"); } } /* Output: inside main Loading Candy After creating Candy Loading Gum After Class.forName("Gum") Loading Cookie After creating Cookie */ OnJava8-Examples-1.0/typeinfo/WildcardClassReferences.java000066400000000000000000000005441374004044700236230ustar00rootroot00000000000000// typeinfo/WildcardClassReferences.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. public class WildcardClassReferences { public static void main(String[] args) { Class intClass = int.class; intClass = double.class; } } OnJava8-Examples-1.0/typeinfo/interfacea/000077500000000000000000000000001374004044700203355ustar00rootroot00000000000000OnJava8-Examples-1.0/typeinfo/interfacea/A.java000066400000000000000000000004011374004044700213530ustar00rootroot00000000000000// typeinfo/interfacea/A.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.interfacea; public interface A { void f(); } OnJava8-Examples-1.0/typeinfo/packageaccess/000077500000000000000000000000001374004044700210115ustar00rootroot00000000000000OnJava8-Examples-1.0/typeinfo/packageaccess/HiddenC.java000066400000000000000000000012671374004044700231600ustar00rootroot00000000000000// typeinfo/packageaccess/HiddenC.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.packageaccess; import typeinfo.interfacea.*; class C implements A { @Override public void f() { System.out.println("public C.f()"); } public void g() { System.out.println("public C.g()"); } void u() { System.out.println("package C.u()"); } protected void v() { System.out.println("protected C.v()"); } private void w() { System.out.println("private C.w()"); } } public class HiddenC { public static A makeA() { return new C(); } } OnJava8-Examples-1.0/typeinfo/pets/000077500000000000000000000000001374004044700172075ustar00rootroot00000000000000OnJava8-Examples-1.0/typeinfo/pets/Cat.java000066400000000000000000000004741374004044700205660ustar00rootroot00000000000000// typeinfo/pets/Cat.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Cat extends Pet { public Cat(String name) { super(name); } public Cat() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Cymric.java000066400000000000000000000005111374004044700212750ustar00rootroot00000000000000// typeinfo/pets/Cymric.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Cymric extends Manx { public Cymric(String name) { super(name); } public Cymric() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Dog.java000066400000000000000000000004741374004044700205700ustar00rootroot00000000000000// typeinfo/pets/Dog.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Dog extends Pet { public Dog(String name) { super(name); } public Dog() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/EgyptianMau.java000066400000000000000000000005341374004044700222770ustar00rootroot00000000000000// typeinfo/pets/EgyptianMau.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class EgyptianMau extends Cat { public EgyptianMau(String name) { super(name); } public EgyptianMau() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/ForNameCreator.java000066400000000000000000000020241374004044700227170ustar00rootroot00000000000000// typeinfo/pets/ForNameCreator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; import java.util.*; public class ForNameCreator extends PetCreator { private static List> types = new ArrayList<>(); // Types you want randomly created: private static String[] typeNames = { "typeinfo.pets.Mutt", "typeinfo.pets.Pug", "typeinfo.pets.EgyptianMau", "typeinfo.pets.Manx", "typeinfo.pets.Cymric", "typeinfo.pets.Rat", "typeinfo.pets.Mouse", "typeinfo.pets.Hamster" }; @SuppressWarnings("unchecked") private static void loader() { try { for(String name : typeNames) types.add( (Class)Class.forName(name)); } catch(ClassNotFoundException e) { throw new RuntimeException(e); } } static { loader(); } @Override public List> types() { return types; } } OnJava8-Examples-1.0/typeinfo/pets/Hamster.java000066400000000000000000000005171374004044700214600ustar00rootroot00000000000000// typeinfo/pets/Hamster.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Hamster extends Rodent { public Hamster(String name) { super(name); } public Hamster() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Individual.java000066400000000000000000000025521374004044700221460ustar00rootroot00000000000000// typeinfo/pets/Individual.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; import java.util.*; public class Individual implements Comparable { private static long counter = 0; private final long id = counter++; private String name; public Individual(String name) { this.name = name; } // 'name' is optional: public Individual() {} @Override public String toString() { return getClass().getSimpleName() + (name == null ? "" : " " + name); } public long id() { return id; } @Override public boolean equals(Object o) { return o instanceof Individual && Objects.equals(id, ((Individual)o).id); } @Override public int hashCode() { return Objects.hash(name, id); } @Override public int compareTo(Individual arg) { // Compare by class name first: String first = getClass().getSimpleName(); String argFirst = arg.getClass().getSimpleName(); int firstCompare = first.compareTo(argFirst); if(firstCompare != 0) return firstCompare; if(name != null && arg.name != null) { int secondCompare = name.compareTo(arg.name); if(secondCompare != 0) return secondCompare; } return (arg.id < id ? -1 : (arg.id == id ? 0 : 1)); } } OnJava8-Examples-1.0/typeinfo/pets/LiteralPetCreator.java000066400000000000000000000023761374004044700234470ustar00rootroot00000000000000// typeinfo/pets/LiteralPetCreator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using class literals // {java typeinfo.pets.LiteralPetCreator} package typeinfo.pets; import java.util.*; public class LiteralPetCreator extends PetCreator { // No try block needed. @SuppressWarnings("unchecked") public static final List> ALL_TYPES = Collections.unmodifiableList(Arrays.asList( Pet.class, Dog.class, Cat.class, Rodent.class, Mutt.class, Pug.class, EgyptianMau.class, Manx.class, Cymric.class, Rat.class, Mouse.class, Hamster.class)); // Types for random creation: private static final List> TYPES = ALL_TYPES.subList(ALL_TYPES.indexOf(Mutt.class), ALL_TYPES.size()); @Override public List> types() { return TYPES; } public static void main(String[] args) { System.out.println(TYPES); } } /* Output: [class typeinfo.pets.Mutt, class typeinfo.pets.Pug, class typeinfo.pets.EgyptianMau, class typeinfo.pets.Manx, class typeinfo.pets.Cymric, class typeinfo.pets.Rat, class typeinfo.pets.Mouse, class typeinfo.pets.Hamster] */ OnJava8-Examples-1.0/typeinfo/pets/Manx.java000066400000000000000000000005001374004044700207500ustar00rootroot00000000000000// typeinfo/pets/Manx.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Manx extends Cat { public Manx(String name) { super(name); } public Manx() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Mouse.java000066400000000000000000000005071374004044700211440ustar00rootroot00000000000000// typeinfo/pets/Mouse.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Mouse extends Rodent { public Mouse(String name) { super(name); } public Mouse() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Mutt.java000066400000000000000000000005001374004044700207760ustar00rootroot00000000000000// typeinfo/pets/Mutt.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Mutt extends Dog { public Mutt(String name) { super(name); } public Mutt() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Person.java000066400000000000000000000004601374004044700213200ustar00rootroot00000000000000// typeinfo/pets/Person.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Person extends Individual { public Person(String name) { super(name); } } OnJava8-Examples-1.0/typeinfo/pets/Pet.java000066400000000000000000000005031374004044700206000ustar00rootroot00000000000000// typeinfo/pets/Pet.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Pet extends Individual { public Pet(String name) { super(name); } public Pet() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/PetCreator.java000066400000000000000000000016531374004044700221270ustar00rootroot00000000000000// typeinfo/pets/PetCreator.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Creates random sequences of Pets package typeinfo.pets; import java.util.*; import java.util.function.*; import java.lang.reflect.InvocationTargetException; public abstract class PetCreator implements Supplier { private Random rand = new Random(47); // The List of the different types of Pet to create: public abstract List> types(); public Pet get() { // Create one random Pet int n = rand.nextInt(types().size()); try { return types().get(n) .getConstructor().newInstance(); } catch(InstantiationException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) { throw new RuntimeException(e); } } } OnJava8-Examples-1.0/typeinfo/pets/Pets.java000066400000000000000000000015231374004044700207660ustar00rootroot00000000000000// typeinfo/pets/Pets.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Facade to produce a default PetCreator package typeinfo.pets; import java.util.*; import java.util.stream.*; public class Pets { public static final PetCreator CREATOR = new LiteralPetCreator(); public static Pet get() { return CREATOR.get(); } public static Pet[] array(int size) { Pet[] result = new Pet[size]; for(int i = 0; i < size; i++) result[i] = CREATOR.get(); return result; } public static List list(int size) { List result = new ArrayList<>(); Collections.addAll(result, array(size)); return result; } public static Stream stream() { return Stream.generate(CREATOR); } } OnJava8-Examples-1.0/typeinfo/pets/Pug.java000066400000000000000000000004741374004044700206120ustar00rootroot00000000000000// typeinfo/pets/Pug.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Pug extends Dog { public Pug(String name) { super(name); } public Pug() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Rat.java000066400000000000000000000004771374004044700206100ustar00rootroot00000000000000// typeinfo/pets/Rat.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Rat extends Rodent { public Rat(String name) { super(name); } public Rat() { super(); } } OnJava8-Examples-1.0/typeinfo/pets/Rodent.java000066400000000000000000000005101374004044700213010ustar00rootroot00000000000000// typeinfo/pets/Rodent.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package typeinfo.pets; public class Rodent extends Pet { public Rodent(String name) { super(name); } public Rodent() { super(); } } OnJava8-Examples-1.0/typeinfo/toys/000077500000000000000000000000001374004044700172325ustar00rootroot00000000000000OnJava8-Examples-1.0/typeinfo/toys/GenericToyTest.java000066400000000000000000000013471374004044700230120ustar00rootroot00000000000000// typeinfo/toys/GenericToyTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Testing class Class // {java typeinfo.toys.GenericToyTest} package typeinfo.toys; public class GenericToyTest { @SuppressWarnings("deprecation") public static void main(String[] args) throws Exception { Class ftClass = FancyToy.class; // Produces exact type: FancyToy fancyToy = ftClass.newInstance(); Class up = ftClass.getSuperclass(); // This won't compile: // Class up2 = ftClass.getSuperclass(); // Only produces Object: Object obj = up.newInstance(); } } OnJava8-Examples-1.0/typeinfo/toys/ToyTest.java000066400000000000000000000041631374004044700215140ustar00rootroot00000000000000// typeinfo/toys/ToyTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Testing class Class // {java typeinfo.toys.ToyTest} package typeinfo.toys; import java.lang.reflect.InvocationTargetException; interface HasBatteries {} interface Waterproof {} interface Shoots {} class Toy { // Comment out the following no-arg // constructor to see NoSuchMethodError Toy() {} Toy(int i) {} } class FancyToy extends Toy implements HasBatteries, Waterproof, Shoots { FancyToy() { super(1); } } public class ToyTest { static void printInfo(Class cc) { System.out.println("Class name: " + cc.getName() + " is interface? [" + cc.isInterface() + "]"); System.out.println( "Simple name: " + cc.getSimpleName()); System.out.println( "Canonical name : " + cc.getCanonicalName()); } @SuppressWarnings("deprecation") public static void main(String[] args) { Class c = null; try { c = Class.forName("typeinfo.toys.FancyToy"); } catch(ClassNotFoundException e) { System.out.println("Can't find FancyToy"); System.exit(1); } printInfo(c); for(Class face : c.getInterfaces()) printInfo(face); Class up = c.getSuperclass(); Object obj = null; try { // Requires no-arg constructor: obj = up.newInstance(); } catch(Exception e) { throw new RuntimeException("Cannot instantiate"); } printInfo(obj.getClass()); } } /* Output: Class name: typeinfo.toys.FancyToy is interface? [false] Simple name: FancyToy Canonical name : typeinfo.toys.FancyToy Class name: typeinfo.toys.HasBatteries is interface? [true] Simple name: HasBatteries Canonical name : typeinfo.toys.HasBatteries Class name: typeinfo.toys.Waterproof is interface? [true] Simple name: Waterproof Canonical name : typeinfo.toys.Waterproof Class name: typeinfo.toys.Shoots is interface? [true] Simple name: Shoots Canonical name : typeinfo.toys.Shoots Class name: typeinfo.toys.Toy is interface? [false] Simple name: Toy Canonical name : typeinfo.toys.Toy */ OnJava8-Examples-1.0/validating/000077500000000000000000000000001374004044700165215ustar00rootroot00000000000000OnJava8-Examples-1.0/validating/Assert1.java000066400000000000000000000010031374004044700207000ustar00rootroot00000000000000// validating/Assert1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Non-informative style of assert // Must run using -ea flag: // {java -ea Assert1} // {ThrowsException} public class Assert1 { public static void main(String[] args) { assert false; } } /* Output: ___[ Error Output ]___ Exception in thread "main" java.lang.AssertionError at Assert1.main(Assert1.java:9) */ OnJava8-Examples-1.0/validating/Assert2.java000066400000000000000000000011031374004044700207020ustar00rootroot00000000000000// validating/Assert2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Assert with an information-expression // {java Assert2 -ea} // {ThrowsException} public class Assert2 { public static void main(String[] args) { assert false: "Here's a message saying what happened"; } } /* Output: ___[ Error Output ]___ Exception in thread "main" java.lang.AssertionError: Here's a message saying what happened at Assert2.main(Assert2.java:8) */ OnJava8-Examples-1.0/validating/BadMicroBenchmark.java000066400000000000000000000015311374004044700226570ustar00rootroot00000000000000// validating/BadMicroBenchmark.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ExcludeFromTravisCI} import java.util.*; import onjava.Timer; public class BadMicroBenchmark { static final int SIZE = 250_000_000; public static void main(String[] args) { try { // For machines with insufficient memory long[] la = new long[SIZE]; System.out.println("setAll: " + Timer.duration(() -> Arrays.setAll(la, n -> n))); System.out.println("parallelSetAll: " + Timer.duration(() -> Arrays.parallelSetAll(la, n -> n))); } catch(OutOfMemoryError e) { System.out.println("Insufficient memory"); System.exit(0); } } } /* Output: setAll: 272 parallelSetAll: 301 */ OnJava8-Examples-1.0/validating/BadMicroBenchmark2.java000066400000000000000000000021151374004044700227400ustar00rootroot00000000000000// validating/BadMicroBenchmark2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Relying on a common resource import java.util.*; import onjava.Timer; public class BadMicroBenchmark2 { // SIZE reduced to make it run faster: static final int SIZE = 5_000_000; public static void main(String[] args) { long[] la = new long[SIZE]; Random r = new Random(); System.out.println("parallelSetAll: " + Timer.duration(() -> Arrays.parallelSetAll(la, n -> r.nextLong()))); System.out.println("setAll: " + Timer.duration(() -> Arrays.setAll(la, n -> r.nextLong()))); SplittableRandom sr = new SplittableRandom(); System.out.println("parallelSetAll: " + Timer.duration(() -> Arrays.parallelSetAll(la, n -> sr.nextLong()))); System.out.println("setAll: " + Timer.duration(() -> Arrays.setAll(la, n -> sr.nextLong()))); } } /* Output: parallelSetAll: 1147 setAll: 174 parallelSetAll: 86 setAll: 39 */ OnJava8-Examples-1.0/validating/CircularQueue.java000066400000000000000000000051271374004044700221420ustar00rootroot00000000000000// validating/CircularQueue.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstration of Design by Contract (DbC) package validating; import java.util.*; public class CircularQueue { private Object[] data; private int in = 0, // Next available storage space out = 0; // Next gettable object // Has it wrapped around the circular queue? private boolean wrapped = false; public CircularQueue(int size) { data = new Object[size]; // Must be true after construction: assert invariant(); } public boolean empty() { return !wrapped && in == out; } public boolean full() { return wrapped && in == out; } public boolean isWrapped() { return wrapped; } public void put(Object item) { precondition(item != null, "put() null item"); precondition(!full(), "put() into full CircularQueue"); assert invariant(); data[in++] = item; if(in >= data.length) { in = 0; wrapped = true; } assert invariant(); } public Object get() { precondition(!empty(), "get() from empty CircularQueue"); assert invariant(); Object returnVal = data[out]; data[out] = null; out++; if(out >= data.length) { out = 0; wrapped = false; } assert postcondition( returnVal != null, "Null item in CircularQueue"); assert invariant(); return returnVal; } // Design-by-contract support methods: private static void precondition(boolean cond, String msg) { if(!cond) throw new CircularQueueException(msg); } private static boolean postcondition(boolean cond, String msg) { if(!cond) throw new CircularQueueException(msg); return true; } private boolean invariant() { // Guarantee that no null values are in the // region of 'data' that holds objects: for(int i = out; i != in; i = (i + 1) % data.length) if(data[i] == null) throw new CircularQueueException( "null in CircularQueue"); // Guarantee that only null values are outside the // region of 'data' that holds objects: if(full()) return true; for(int i = in; i != out; i = (i + 1) % data.length) if(data[i] != null) throw new CircularQueueException( "non-null outside of CircularQueue range: " + dump()); return true; } public String dump() { return "in = " + in + ", out = " + out + ", full() = " + full() + ", empty() = " + empty() + ", CircularQueue = " + Arrays.asList(data); } } OnJava8-Examples-1.0/validating/CircularQueueException.java000066400000000000000000000005441374004044700240170ustar00rootroot00000000000000// validating/CircularQueueException.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; public class CircularQueueException extends RuntimeException { public CircularQueueException(String why) { super(why); } } OnJava8-Examples-1.0/validating/CountedList.java000066400000000000000000000010021374004044700216120ustar00rootroot00000000000000// validating/CountedList.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Keeps track of how many of itself are created. package validating; import java.util.*; public class CountedList extends ArrayList { private static int counter = 0; private int id = counter++; public CountedList() { System.out.println("CountedList #" + id); } public int getId() { return id; } } OnJava8-Examples-1.0/validating/GuavaAssertions.java000066400000000000000000000023551374004044700225070ustar00rootroot00000000000000// validating/GuavaAssertions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Assertions that are always enabled. import com.google.common.base.*; import static com.google.common.base.Verify.*; public class GuavaAssertions { public static void main(String[] args) { verify(2 + 2 == 4); try { verify(1 + 2 == 4); } catch(VerifyException e) { System.out.println(e); } try { verify(1 + 2 == 4, "Bad math"); } catch(VerifyException e) { System.out.println(e.getMessage()); } try { verify(1 + 2 == 4, "Bad math: %s", "not 4"); } catch(VerifyException e) { System.out.println(e.getMessage()); } String s = ""; s = verifyNotNull(s); s = null; try { verifyNotNull(s); } catch(VerifyException e) { System.out.println(e.getMessage()); } try { verifyNotNull( s, "Shouldn't be null: %s", "arg s"); } catch(VerifyException e) { System.out.println(e.getMessage()); } } } /* Output: com.google.common.base.VerifyException Bad math Bad math: not 4 expected a non-null reference Shouldn't be null: arg s */ OnJava8-Examples-1.0/validating/GuavaPreconditions.java000066400000000000000000000062731374004044700232000ustar00rootroot00000000000000// validating/GuavaPreconditions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Demonstrating Guava Preconditions import java.util.function.*; import static com.google.common.base.Preconditions.*; public class GuavaPreconditions { static void test(Consumer c, String s) { try { System.out.println(s); c.accept(s); System.out.println("Success"); } catch(Exception e) { String type = e.getClass().getSimpleName(); String msg = e.getMessage(); System.out.println(type + (msg == null ? "" : ": " + msg)); } } public static void main(String[] args) { test(s -> s = checkNotNull(s), "X"); test(s -> s = checkNotNull(s), null); test(s -> s = checkNotNull(s, "s was null"), null); test(s -> s = checkNotNull( s, "s was null, %s %s", "arg2", "arg3"), null); test(s -> checkArgument(s == "Fozzie"), "Fozzie"); test(s -> checkArgument(s == "Fozzie"), "X"); test(s -> checkArgument(s == "Fozzie"), null); test(s -> checkArgument( s == "Fozzie", "Bear Left!"), null); test(s -> checkArgument( s == "Fozzie", "Bear Left! %s Right!", "Frog"), null); test(s -> checkState(s.length() > 6), "Mortimer"); test(s -> checkState(s.length() > 6), "Mort"); test(s -> checkState(s.length() > 6), null); test(s -> checkElementIndex(6, s.length()), "Robert"); test(s -> checkElementIndex(6, s.length()), "Bob"); test(s -> checkElementIndex(6, s.length()), null); test(s -> checkPositionIndex(6, s.length()), "Robert"); test(s -> checkPositionIndex(6, s.length()), "Bob"); test(s -> checkPositionIndex(6, s.length()), null); test(s -> checkPositionIndexes( 0, 6, s.length()), "Hieronymus"); test(s -> checkPositionIndexes( 0, 10, s.length()), "Hieronymus"); test(s -> checkPositionIndexes( 0, 11, s.length()), "Hieronymus"); test(s -> checkPositionIndexes( -1, 6, s.length()), "Hieronymus"); test(s -> checkPositionIndexes( 7, 6, s.length()), "Hieronymus"); test(s -> checkPositionIndexes( 0, 6, s.length()), null); } } /* Output: X Success null NullPointerException null NullPointerException: s was null null NullPointerException: s was null, arg2 arg3 Fozzie Success X IllegalArgumentException null IllegalArgumentException null IllegalArgumentException: Bear Left! null IllegalArgumentException: Bear Left! Frog Right! Mortimer Success Mort IllegalStateException null NullPointerException Robert IndexOutOfBoundsException: index (6) must be less than size (6) Bob IndexOutOfBoundsException: index (6) must be less than size (3) null NullPointerException Robert Success Bob IndexOutOfBoundsException: index (6) must not be greater than size (3) null NullPointerException Hieronymus Success Hieronymus Success Hieronymus IndexOutOfBoundsException: end index (11) must not be greater than size (10) Hieronymus IndexOutOfBoundsException: start index (-1) must not be negative Hieronymus IndexOutOfBoundsException: end index (6) must not be less than start index (7) null NullPointerException */ OnJava8-Examples-1.0/validating/Inverter1.java000066400000000000000000000004741374004044700212500ustar00rootroot00000000000000// validating/Inverter1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; public class Inverter1 implements StringInverter { public String invert(String str) { return str; } } OnJava8-Examples-1.0/validating/Inverter2.java000066400000000000000000000010641374004044700212450ustar00rootroot00000000000000// validating/Inverter2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; import static java.lang.Character.*; public class Inverter2 implements StringInverter { public String invert(String str) { String result = ""; for(int i = 0; i < str.length(); i++) { char c = str.charAt(i); result += isUpperCase(c) ? toLowerCase(c) : toUpperCase(c); } return result; } } OnJava8-Examples-1.0/validating/Inverter3.java000066400000000000000000000012061374004044700212440ustar00rootroot00000000000000// validating/Inverter3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; import static java.lang.Character.*; public class Inverter3 implements StringInverter { public String invert(String str) { if(str.length() > 30) throw new RuntimeException("argument too long!"); String result = ""; for(int i = 0; i < str.length(); i++) { char c = str.charAt(i); result += isUpperCase(c) ? toLowerCase(c) : toUpperCase(c); } return result; } } OnJava8-Examples-1.0/validating/Inverter4.java000066400000000000000000000015111374004044700212440ustar00rootroot00000000000000// validating/Inverter4.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; import static java.lang.Character.*; public class Inverter4 implements StringInverter { static final String ALLOWED = "abcdefghijklmnopqrstuvwxyz ,." + "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; public String invert(String str) { if(str.length() > 30) throw new RuntimeException("argument too long!"); String result = ""; for(int i = 0; i < str.length(); i++) { char c = str.charAt(i); if(ALLOWED.indexOf(c) == -1) throw new RuntimeException(c + " Not allowed"); result += isUpperCase(c) ? toLowerCase(c) : toUpperCase(c); } return result; } } OnJava8-Examples-1.0/validating/LoaderAssertions.java000066400000000000000000000013351374004044700226470ustar00rootroot00000000000000// validating/LoaderAssertions.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Using the class loader to enable assertions // {ThrowsException} public class LoaderAssertions { public static void main(String[] args) { ClassLoader.getSystemClassLoader() .setDefaultAssertionStatus(true); new Loaded().go(); } } class Loaded { public void go() { assert false: "Loaded.go()"; } } /* Output: ___[ Error Output ]___ Exception in thread "main" java.lang.AssertionError: Loaded.go() at Loaded.go(LoaderAssertions.java:15) at LoaderAssertions.main(LoaderAssertions.java:9) */ OnJava8-Examples-1.0/validating/NonNullConstruction.java000066400000000000000000000010661374004044700233670ustar00rootroot00000000000000// validating/NonNullConstruction.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import static com.google.common.base.Preconditions.*; public class NonNullConstruction { private Integer n; private String s; NonNullConstruction(Integer n, String s) { this.n = checkNotNull(n); this.s = checkNotNull(s); } public static void main(String[] args) { NonNullConstruction nnc = new NonNullConstruction(3, "Trousers"); } } OnJava8-Examples-1.0/validating/SLF4JLevels.java000066400000000000000000000014371374004044700213660ustar00rootroot00000000000000// validating/SLF4JLevels.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import org.slf4j.*; public class SLF4JLevels { private static Logger log = LoggerFactory.getLogger(SLF4JLevels.class); public static void main(String[] args) { log.trace("Hello"); log.debug("Logging"); log.info("Using"); log.warn("the SLF4J"); log.error("Facade"); } } /* Output: 2017-05-09T06:07:52.846 [main] TRACE SLF4JLevels - Hello 2017-05-09T06:07:52.849 [main] DEBUG SLF4JLevels - Logging 2017-05-09T06:07:52.849 [main] INFO SLF4JLevels - Using 2017-05-09T06:07:52.850 [main] WARN SLF4JLevels - the SLF4J 2017-05-09T06:07:52.851 [main] ERROR SLF4JLevels - Facade */ OnJava8-Examples-1.0/validating/SLF4JLogging.java000066400000000000000000000007421374004044700215200ustar00rootroot00000000000000// validating/SLF4JLogging.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. import org.slf4j.*; public class SLF4JLogging { private static Logger log = LoggerFactory.getLogger(SLF4JLogging.class); public static void main(String[] args) { log.info("hello logging"); } } /* Output: 2017-05-09T06:07:53.418 [main] INFO SLF4JLogging - hello logging */ OnJava8-Examples-1.0/validating/SimpleDebugging.java000066400000000000000000000016601374004044700224340ustar00rootroot00000000000000// validating/SimpleDebugging.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // {ThrowsException} public class SimpleDebugging { private static void foo1() { System.out.println("In foo1"); foo2(); } private static void foo2() { System.out.println("In foo2"); foo3(); } private static void foo3() { System.out.println("In foo3"); int j = 1; j--; int i = 5 / j; } public static void main(String[] args) { foo1(); } } /* Output: In foo1 In foo2 In foo3 ___[ Error Output ]___ Exception in thread "main" java.lang.ArithmeticException: / by zero at SimpleDebugging.foo3(SimpleDebugging.java:17) at SimpleDebugging.foo2(SimpleDebugging.java:11) at SimpleDebugging.foo1(SimpleDebugging.java:7) at SimpleDebugging.main(SimpleDebugging.java:20) */ OnJava8-Examples-1.0/validating/StringInverter.java000066400000000000000000000004231374004044700223500ustar00rootroot00000000000000// validating/StringInverter.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; interface StringInverter { String invert(String str); } OnJava8-Examples-1.0/validating/jmh/000077500000000000000000000000001374004044700172775ustar00rootroot00000000000000OnJava8-Examples-1.0/validating/jmh/JMH1.java000066400000000000000000000014171374004044700206440ustar00rootroot00000000000000// validating/jmh/JMH1.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating.jmh; import java.util.*; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @State(Scope.Thread) @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) // Increase these three for more accuracy: @Warmup(iterations = 5) @Measurement(iterations = 5) @Fork(1) public class JMH1 { private long[] la; @Setup public void setup() { la = new long[250_000_000]; } @Benchmark public void setAll() { Arrays.setAll(la, n -> n); } @Benchmark public void parallelSetAll() { Arrays.parallelSetAll(la, n -> n); } } OnJava8-Examples-1.0/validating/jmh/JMH2.java000066400000000000000000000015771374004044700206540ustar00rootroot00000000000000// validating/jmh/JMH2.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating.jmh; import java.util.*; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @State(Scope.Thread) @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) @Warmup(iterations = 5) @Measurement(iterations = 5) @Fork(1) public class JMH2 { private long[] la; @Param({ "1", "10", "100", "1000", "10000", "100000", "1000000", "10000000", "100000000", "250000000" }) int size; @Setup public void setup() { la = new long[size]; } @Benchmark public void setAll() { Arrays.setAll(la, n -> n); } @Benchmark public void parallelSetAll() { Arrays.parallelSetAll(la, n -> n); } } OnJava8-Examples-1.0/validating/jmh/JMH3.java000066400000000000000000000020131374004044700206370ustar00rootroot00000000000000// validating/jmh/JMH3.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating.jmh; import java.util.*; import org.openjdk.jmh.annotations.*; import java.util.concurrent.TimeUnit; @State(Scope.Thread) @BenchmarkMode(Mode.AverageTime) @OutputTimeUnit(TimeUnit.MICROSECONDS) @Warmup(iterations = 5) @Measurement(iterations = 5) @Fork(1) public class JMH3 { private long[] la; @Param({ "1", "10", "100", "1000", "10000", "100000", "1000000", "10000000", "100000000", "250000000" }) int size; @Setup public void setup() { la = new long[size]; } public static long f(long x) { long quadratic = 42 * x * x + 19 * x + 47; return Long.divideUnsigned(quadratic, x + 1); } @Benchmark public void setAll() { Arrays.setAll(la, n -> f(n)); } @Benchmark public void parallelSetAll() { Arrays.parallelSetAll(la, n -> f(n)); } } OnJava8-Examples-1.0/validating/logback.xml000066400000000000000000000005431374004044700206470ustar00rootroot00000000000000 %d{yyyy-MM-dd'T'HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n OnJava8-Examples-1.0/validating/tests/000077500000000000000000000000001374004044700176635ustar00rootroot00000000000000OnJava8-Examples-1.0/validating/tests/CircularQueueTest.java000066400000000000000000000065451374004044700241510ustar00rootroot00000000000000// validating/tests/CircularQueueTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; public class CircularQueueTest { private CircularQueue queue = new CircularQueue(10); private int i = 0; @BeforeEach public void initialize() { while(i < 5) // Pre-load with some data queue.put(Integer.toString(i++)); } // Support methods: private void showFullness() { assertTrue(queue.full()); assertFalse(queue.empty()); System.out.println(queue.dump()); } private void showEmptiness() { assertFalse(queue.full()); assertTrue(queue.empty()); System.out.println(queue.dump()); } @Test public void full() { System.out.println("testFull"); System.out.println(queue.dump()); System.out.println(queue.get()); System.out.println(queue.get()); while(!queue.full()) queue.put(Integer.toString(i++)); String msg = ""; try { queue.put(""); } catch(CircularQueueException e) { msg = e.getMessage(); System.out.println(msg); } assertEquals(msg, "put() into full CircularQueue"); showFullness(); } @Test public void empty() { System.out.println("testEmpty"); while(!queue.empty()) System.out.println(queue.get()); String msg = ""; try { queue.get(); } catch(CircularQueueException e) { msg = e.getMessage(); System.out.println(msg); } assertEquals(msg, "get() from empty CircularQueue"); showEmptiness(); } @Test public void nullPut() { System.out.println("testNullPut"); String msg = ""; try { queue.put(null); } catch(CircularQueueException e) { msg = e.getMessage(); System.out.println(msg); } assertEquals(msg, "put() null item"); } @Test public void circularity() { System.out.println("testCircularity"); while(!queue.full()) queue.put(Integer.toString(i++)); showFullness(); assertTrue(queue.isWrapped()); while(!queue.empty()) System.out.println(queue.get()); showEmptiness(); while(!queue.full()) queue.put(Integer.toString(i++)); showFullness(); while(!queue.empty()) System.out.println(queue.get()); showEmptiness(); } } /* Output: testNullPut put() null item testCircularity in = 0, out = 0, full() = true, empty() = false, CircularQueue = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 0 1 2 3 4 5 6 7 8 9 in = 0, out = 0, full() = false, empty() = true, CircularQueue = [null, null, null, null, null, null, null, null, null, null] in = 0, out = 0, full() = true, empty() = false, CircularQueue = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 10 11 12 13 14 15 16 17 18 19 in = 0, out = 0, full() = false, empty() = true, CircularQueue = [null, null, null, null, null, null, null, null, null, null] testFull in = 5, out = 0, full() = false, empty() = false, CircularQueue = [0, 1, 2, 3, 4, null, null, null, null, null] 0 1 put() into full CircularQueue in = 2, out = 2, full() = true, empty() = false, CircularQueue = [10, 11, 2, 3, 4, 5, 6, 7, 8, 9] testEmpty 0 1 2 3 4 get() from empty CircularQueue in = 5, out = 5, full() = false, empty() = true, CircularQueue = [null, null, null, null, null, null, null, null, null, null] */ OnJava8-Examples-1.0/validating/tests/CountedListTest.java000066400000000000000000000051571374004044700236330ustar00rootroot00000000000000// validating/tests/CountedListTest.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. // Simple use of JUnit to test CountedList. package validating; import java.util.*; import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; public class CountedListTest { private CountedList list; @BeforeAll static void beforeAllMsg() { System.out.println(">>> Starting CountedListTest"); } @AfterAll static void afterAllMsg() { System.out.println(">>> Finished CountedListTest"); } @BeforeEach public void initialize() { list = new CountedList(); System.out.println("Set up for " + list.getId()); for(int i = 0; i < 3; i++) list.add(Integer.toString(i)); } @AfterEach public void cleanup() { System.out.println("Cleaning up " + list.getId()); } @Test public void insert() { System.out.println("Running testInsert()"); assertEquals(list.size(), 3); list.add(1, "Insert"); assertEquals(list.size(), 4); assertEquals(list.get(1), "Insert"); } @Test public void replace() { System.out.println("Running testReplace()"); assertEquals(list.size(), 3); list.set(1, "Replace"); assertEquals(list.size(), 3); assertEquals(list.get(1), "Replace"); } // A helper method to simplify the code. As // long as it's not annotated with @Test, it will // not be automatically executed by JUnit. private void compare(List lst, String[] strs) { assertArrayEquals(lst.toArray(new String[0]), strs); } @Test public void order() { System.out.println("Running testOrder()"); compare(list, new String[] { "0", "1", "2" }); } @Test public void remove() { System.out.println("Running testRemove()"); assertEquals(list.size(), 3); list.remove(1); assertEquals(list.size(), 2); compare(list, new String[] { "0", "2" }); } @Test public void addAll() { System.out.println("Running testAddAll()"); list.addAll(Arrays.asList(new String[] { "An", "African", "Swallow"})); assertEquals(list.size(), 6); compare(list, new String[] { "0", "1", "2", "An", "African", "Swallow" }); } } /* Output: >>> Starting CountedListTest CountedList #0 Set up for 0 Running testRemove() Cleaning up 0 CountedList #1 Set up for 1 Running testReplace() Cleaning up 1 CountedList #2 Set up for 2 Running testAddAll() Cleaning up 2 CountedList #3 Set up for 3 Running testInsert() Cleaning up 3 CountedList #4 Set up for 4 Running testOrder() Cleaning up 4 >>> Finished CountedListTest */ OnJava8-Examples-1.0/validating/tests/DynamicStringInverterTests.java000066400000000000000000000072531374004044700260520ustar00rootroot00000000000000// validating/tests/DynamicStringInverterTests.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; import java.util.*; import java.util.function.*; import java.util.stream.*; import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; import static org.junit.jupiter.api.DynamicTest.*; class DynamicStringInverterTests { // Combine operations to prevent code duplication: Stream testVersions(String id, Function test) { List versions = Arrays.asList( new Inverter1(), new Inverter2(), new Inverter3(), new Inverter4()); return DynamicTest.stream( versions.iterator(), inverter -> inverter.getClass().getSimpleName(), inverter -> { System.out.println( inverter.getClass().getSimpleName() + ": " + id); try { if(test.apply(inverter) != "fail") System.out.println("Success"); } catch(Exception | Error e) { System.out.println( "Exception: " + e.getMessage()); } } ); } String isEqual(String lval, String rval) { if(lval.equals(rval)) return "success"; System.out.println("FAIL: " + lval + " != " + rval); return "fail"; } @BeforeAll static void startMsg() { System.out.println( ">>> Starting DynamicStringInverterTests <<<"); } @AfterAll static void endMsg() { System.out.println( ">>> Finished DynamicStringInverterTests <<<"); } @TestFactory Stream basicInversion1() { String in = "Exit, Pursued by a Bear."; String out = "eXIT, pURSUED BY A bEAR."; return testVersions( "Basic inversion (should succeed)", inverter -> isEqual(inverter.invert(in), out) ); } @TestFactory Stream basicInversion2() { return testVersions( "Basic inversion (should fail)", inverter -> isEqual(inverter.invert("X"), "X")); } @TestFactory Stream disallowedCharacters() { String disallowed = ";-_()*&^%$#@!~`0123456789"; return testVersions( "Disallowed characters", inverter -> { String result = disallowed.chars() .mapToObj(c -> { String cc = Character.toString((char)c); try { inverter.invert(cc); return ""; } catch(RuntimeException e) { return cc; } }).collect(Collectors.joining("")); if(result.length() == 0) return "success"; System.out.println("Bad characters: " + result); return "fail"; } ); } @TestFactory Stream allowedCharacters() { String lowcase = "abcdefghijklmnopqrstuvwxyz ,."; String upcase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ,."; return testVersions( "Allowed characters (should succeed)", inverter -> { assertEquals(inverter.invert(lowcase), upcase); assertEquals(inverter.invert(upcase), lowcase); return "success"; } ); } @TestFactory Stream lengthNoGreaterThan30() { String str = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; assertTrue(str.length() > 30); return testVersions( "Length must be less than 31 (throws exception)", inverter -> inverter.invert(str) ); } @TestFactory Stream lengthLessThan31() { String str = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; assertTrue(str.length() < 31); return testVersions( "Length must be less than 31 (should succeed)", inverter -> inverter.invert(str) ); } } OnJava8-Examples-1.0/validating/tests/StringInverterTests.java000066400000000000000000000035371374004044700245460ustar00rootroot00000000000000// validating/tests/StringInverterTests.java // (c)2020 MindView LLC: see Copyright.txt // We make no guarantees that this code is fit for any purpose. // Visit http://OnJava8.com for more book information. package validating; import java.util.*; import java.util.stream.*; import org.junit.jupiter.api.*; import static org.junit.jupiter.api.Assertions.*; public class StringInverterTests { StringInverter inverter = new Inverter4(); @BeforeAll static void startMsg() { System.out.println(">>> StringInverterTests <<<"); } @Test void basicInversion1() { String in = "Exit, Pursued by a Bear."; String out = "eXIT, pURSUED BY A bEAR."; assertEquals(inverter.invert(in), out); } @Test void basicInversion2() { assertThrows(Error.class, () -> { assertEquals(inverter.invert("X"), "X"); }); } @Test void disallowedCharacters() { String disallowed = ";-_()*&^%$#@!~`0123456789"; String result = disallowed.chars() .mapToObj(c -> { String cc = Character.toString((char)c); try { inverter.invert(cc); return ""; } catch(RuntimeException e) { return cc; } }).collect(Collectors.joining("")); assertEquals(result, disallowed); } @Test void allowedCharacters() { String lowcase = "abcdefghijklmnopqrstuvwxyz ,."; String upcase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ ,."; assertEquals(inverter.invert(lowcase), upcase); assertEquals(inverter.invert(upcase), lowcase); } @Test void lengthNoGreaterThan30() { String str = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; assertTrue(str.length() > 30); assertThrows(RuntimeException.class, () -> { inverter.invert(str); }); } @Test void lengthLessThan31() { String str = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; assertTrue(str.length() < 31); inverter.invert(str); } }