Java11-和-12-新特性指南-全-

,

class GarmentFactory { 
    void createShirts() { 
        Shirt redShirtS = new Shirt(Size.SMALL, Color.red); 

abstract record JVMLanguage(String name, int year); 
record Conference(String name, String venue, DateTime when); 

  java -Xshare:dump   

String name = "Java Everywhere"; 
LocalDateTime dateTime = new LocalDateTime.now();

var name = "Java Everywhere";            // variable 'name' inferred as 
                                         // String 
var dateTime = new LocalDateTime.now();  // var 'dateTime' inferred as 
                                         // LocalDateTime 

HashMap<Integer, String> map = new HashMap<Integer, String>(); 

var map = new HashMap<Integer, String>();  

var minAge;                   // uninitialized variable 
var age = null;               // variable assigned a null value  

public class Person { 
    { 
        var name = "Aqua Blue";         // instance initializer block 
    } 

    static { 
        var anotherLocalVar = 19876;    // static initializer block 
    } 

    Person() { 
        var ctr = 10;                   // constructor 
        for (var loopCtr = 0; loopCtr < 10; ++loopCtr) {   // loop -                                                            
                                                           // for
            switch(loopCtr) { 
                case 7 :{ 
                    var probability = ctr / loopCtr;       // switch 
                    System.out.println(probability); 
                    break; 
                } 
            } 
        } 
    } 

    public String readFile() throws IOException { 
        var filePath = "data.txt"; 
        // try with resources
        try (var reader = new BufferedReader(new FileReader(filePath))) {    
            return reader.readLine(); 
        } 
    } 
}  

class Foo {   
    public static void main(String args[]) {   
        try {   
           char[] name = new char[]{'S','t','r','i','n','g'};   
           for (var c : name) {   
               System.out.println(c + ":"   + (c + 1 - 1));   
           }   
        }   
        catch (var e) {   
            //code   
        }   
    }   
}   

var counter = 9_009_998_992_887;       // code doesn't compile 

var counter = 9_009_998_992_887L;       // code compiles 

var aChar = (char)91; 

// type of result inferred as int; 'result' stores 2 
var divResult = 5/2; 

// result of (5/2), that is 2 casted to a double; divResult stores 2.0 
var divResult = (double)(5/ 2); 

// operation of a double and int results in a double; divResult stores 
// 2.5 
var divResult = (double)5/ 2;

byte b1 = 10; 
char c1 = 9; 
var sum = b1 + c1;        // inferred type of sum is int  

byte cupsOfCoffee = 10; 
long population = 10L; 
float weight = 79.8f; 
double distance = 198654.77; 

var total1 = cupsOfCoffee + population;     // inferred type of total1 
                                           // is long 
var total2 = distance + population;        // inferred type of total2 
                                           // is double 
var total3 = weight + population;    // inferred type of total3 is 
                                          // float  

class Parent { 
    void whistle() { 
        System.out.println("Parent-Whistle"); 
    } 
} 
class Child extends Parent { 
    void whistle() { 
        System.out.println("Child-Whistle"); 
    } 
    void stand() { 
        System.out.println("Child-stand"); 
    } 
} 
class Test{ 
    public static void main(String[] args) { 
        var obj = new Child();                             
        obj.whistle(); 
        obj.stand();     // type of obj inferred as Child 
    } 
}

class Parent { 
    void whistle() { 
        System.out.println("Parent-Whistle"); 
    } 
} 

class Child extends Parent { 
    void whistle() { 
        System.out.println("Child-Whistle"); 
    } 
    void stand() { 
        System.out.println("Child-stand"); 
    } 
} 

class Test{ 
    public static Parent getObject(String type) { 
        if (type.equals("Parent")) 
            return new Parent(); 
        else 
            return new Child(); 
    } 

    public static void main(String[] args) { 
        var obj = getObject("Child"); 
        obj.whistle(); 
        obj.stand();              // This line doesn't compile 
    } 
} 

interface MarathonRunner{ 
    default void run() { 
        System.out.println("I'm a marathon runner"); 
    } 
} 

class Child implements MarathonRunner { 
    void whistle() { 
        System.out.println("Child-Whistle"); 
    } 
    void stand() { 
        System.out.println("Child-stand"); 
    } 
}  

class Test{ 
    public static void main(String[] args) { 
        var obj = new Child();              // inferred type of var obj 
                                            // is Child 
        obj.whistle(); 
        obj.stand();                     
        obj.run(); 
    } 
}  

class Test{ 
    public static MarathonRunner getObject() { 
        return new Child(); 
    } 
    public static void main(String[] args) { 
        var obj = getObject();     // inferred type of var obj is 
                                   // MarathonRunner 
        obj.whistle(); 
        obj.stand(); 
        obj.run(); 
    } 
}

char name[] = {'S','t','r','i','n','g'};

var name[] = {'S','t','r','i','n','g'};
var[] name = {'S','t','r','i','n','g'};
var name = {'S','t','r','i','n','g'};

var name = new char[]{'S','t','r','i','n','g'};

List<String> names = new ArrayList<>();  

var names = new ArrayList<>(); 
names.add(1); 
names.add("Mala"); 
names.add(10.9); 
names.add(true); 

var names = new ArrayList<String>(); 

class Pen implements Comparable<Pen> {   
    String name;   
    double price;   
    public Pen(String name, double price) {   
        this.name = name;   
        this.price = price;   
    }   
    public int compareTo(Pen pen) {   
        return ((int)(this.price - pen.price));   
    }   
    public String toString() {   
        return name;   
    }   

    public static void main(String   args[]) {   
        var pen1 = new Pen("Lateral",   219.9);   
        var pen2 = new Pen("Pinker",   19.9);   
        var pen3 = new Pen("Simplie",   159.9);   

        var penList = List.of(pen1, pen2,   pen3);   

        Collections.sort(penList);   
        for (var a : penList)    
            System.out.println(a);   
    }   
}   

interface MarathonRunner { 
    default void run() { 
        System.out.println("I'm a marathon runner"); 
    } 
} 
class Child implements MarathonRunner { 
    void whistle() { 
        System.out.println("Child-Whistle"); 
    } 
    void stand() { 
        System.out.println("Child-stand"); 
    } 
} 
class Marathon { 
    public static void main(String[] args) { 
        var aRunner = new Child();         // Inferred type is Child 
        start(aRunner);                    // ok to pass it to method start 
                                           // (param - MarathonRunner) 
    } 
    public static void start(MarathonRunner runner) { 
        runner.run(); 
    } 
}  

var age = 9;     // type of variable age inferred as int 
age = 10.9;      // can't assign 10.9 to variable of type int 

var query = new StringBuilder("SELECT");         // Type of variable 
                                              // query is StringBuilder 
query = query.toString() + "FROM" + "TABLE";     // won't compile;  
                                                 // can't assign String                                                                                                 
                                                // to variable query

var age = 29;           // inferred type of age is int 

byte age = 29;                // Option 1 - no type inference 
var age = (byte)29;           // Option 2 - explicit casting 

var letter = (char)97;        // inferred type of letter is char 
var debit = (float)17.9;      // inferred type of debit is float  

class Automobile {} 
class Car extends Automobile { 
    void check() {} 
} 
class Test{ 
    public static void main(String[] args) { 
        var obj = (Automobile)new Car();                             
        obj.check();     // Won't compile; type of obj is Automobile 
    } 
} 

var name = (String)null;             // Code compiles 

List<Integer> myListOfIntegers = Collections.<Integer>emptyList(); // 1

 List<Integer> myListOfIntegers = Collections.emptyList(); // 1 

List<String> myThings = new ArrayList<String>(); 

List<String> myThings = new ArrayList<>();  

List<String> myThings = new ArrayList();  

class MyClass<T> { 
   public <X> void print(X x) { 
         System.out.println(x.getClass()); 
   } 
}  

MyClass<String> myClass = new MyClass<>(); 
myClass.<Boolean>deliver(new Boolean("true"));     
myClass.deliver(new Boolean("true")); 

Consumer<String> consumer = (String s) -> System.out.println(s);

Consumer<String> consumer = s -> System.out.print(s);

class var {}          // can't use var as class name
interface var {}      // can't use var as interface name
class Demo {
    int var = 100;               // can't use var as instance variable 
                                 // name
    static long var = 121;       // can't use var as static variable 
                                 // name

    void var() {                 // can't use var as method name
        int var = 10;            // cant use var as the name of a local 
                                 // variable
    }
    void aMethod(String var) {}  // can't use var as the name of method parameter
}

// inferred type java.util.ImmutableCollections$ListN 
var a = List.of(1, "2", new StringBuilder());
var b = List.of(new ArrayList<String>(), LocalTime.now());

var i = getData();             // what does getData() return? Is 'i' a 
                              // good name? 

var database = new URL("http://www.eJavaGuru.com/malagupta.html"); 
var query = con.getConnection(); 

    java -Xshare:dump 

class ConquerWorld { 
    public static void main(String args[]) { 
        System.out.println("Go and conquer the world"); 
    } 
} 

    java -Xlog:class+load:file=myCDSlog.log ConquerWorld  

    Go and conquer the world  

    java -Xshare:off -Xlog:class+load:file=myCDSshareoff.log     
    ConquerWorld  

    -XX:+UseAppCDS

// Contents of Cotton.java 
package com.ejavaguru.appcds; 
public class Cotton {} 

// Contents of Plastic.java 
package com.ejavaguru.appcds; 
public class Plastic {} 

// Contents of PlasticBottle.java 
package com.ejavaguru.appcds; 
public class PlasticBottle extends Plastic {}  

// Contents of Wood.java 
package com.ejavaguru.appcds; 
public class Wood {}

// Contents of class AppCDS.java 
import com.ejavaguru.appcds.*; 
class AppCDS { 
    public static void main(String args[]) { 
        System.out.println(new Plastic()); 
    } 
} 

java -Xshare:off  
     -XX:DumpLoadedClassList=myappCDS.lst 
     -cp appcds.jar 
      AppCDS 

    java -Xshare:dump 
    -XX:+UseAppCDS 
         -XX:SharedClassListFile=myappCDS.lst
    -XX:SharedArchiveFile=appCDS.jsa 
         -cp appcds.jar  

    java -Xshare:on 
    -XX:+UseAppCDS 
    -XX:SharedArchiveFile=appCDS.jsa 
    -cp appcds.jar 
         AppCDS  

import java.io.*; 
import java.awt.image.BufferedImage; 
import javax.imageio.ImageIO; 
public class TriggerG1FullGC { 
    final BufferedImage[] images = new BufferedImage[999999]; 
    final byte[][] imgByte = new byte[999999][]; 

    public TriggerG1FullGC() throws Exception { 
        for (int i = 0; i < 999999; i++) { 
            images[i] = ImageIO.read(new File("img.jpg")); 
        } 
        System.out.println("Images read"); 

        for (int i = 0; i < 999999; i++) { 
            ByteArrayOutputStream baos=new ByteArrayOutputStream(); 
            ImageIO.write(images[i], "jpg", baos ); 
            imgByte[i] = baos.toByteArray(); 
        } 
        System.out.println("Bytes read"); 
    } 
    public static void main(String... args) throws Exception { 
        new TriggerG1FullGC(); 
    } 
} 

    > java -Xlog:gc* -Xlog:gc*:myG1log.log TriggerG1FullGC 

-XX:+UnlockExperimentalVMOptions -XX:+UseJVMCICompiler

$FEATURE.$INTERIM.$UPDATE.$PATCH

(Integer age) -> age > 10;                      // input Integer, 
                                                // return Boolean 
(Integer age) -> age > 10? "Kid" : "Not a Kid"; // input Integer, 
                                                // return String 
(Integer age) -> {System.out.println();};       // input Integer, 
                                                // return void 
() -> {return Math.random() + "Number";};       // input none,
                                                // return String 
(String name, List<Person> list) -> { 
                               return ( 
                                   list.stream() 
                                       .filter(e ->             
                                        e.getName().startsWith(name)) 
                                       .map(Person::getAge) 
                                       .findFirst() 
                                   ); 
                               };               // input name, 
                                                // List<person> 
                                                // return 
                                                // Optional<Integer> 

Predicate<Integer> predicate = (Integer age) -> age > 10; 
Function<Integer, String> function = (Integer age) -> age > 10? "Kid" : 
                                    "Not a Kid"; 
Consumer<Integer> consumer =   (Integer age) -> {  
                                                System.out.println();
                                                }; 
Supplier<String> supplier =    () -> {
                                         return Math.random() + 
                                         "Number";
                                     }; 

BiFunction<String, List<Person>,
 Optional<Integer>> firstElement = (String name, List<Person> list) ->                                                                 { 
                                   return ( 
                                       list.stream() 
                                           .filter(e -> 
                                            e.getName().
                                            startsWith(name)) 
                                           .map(Person::getAge) 
                                          .findFirst() 
                                       ); 
                                   }; 
class Person { 
    int age; 
    String name; 
    String getName() { 
        return name; 
    } 
    Integer getAge() { 
        return age; 
    } 
} 

(age) -> age > 10; 
(age) -> age > 10? "Kid" : "Not a Kid"; 
age -> {System.out.println();}; 
() -> {return Math.random() + "Number";}; 

(name, list) -> { 
                    return ( 
                        list.stream() 
                            .filter(e -> e.getName().startsWith(name)) 
                            .map(Person::getAge) 
                            .findFirst() 
                    ); 
                }; 

(Integer x, y) -> x + y;                 // won't compile

(var age) -> age > 10; 
(var age) -> age > 10? "Kid" : "Not a Kid"; 
(var age) -> {System.out.println();}; 
() -> {return Math.random() + "Number";}; 

(var name, var list) -> { 
                             return ( 
                                 list.stream() 
                                     .filter(e -> 
                                      e.getName().startsWith(name)) 
                                     .map(Person::getAge) 
                                     .findFirst() 
                                 ); 
                             }; 

(var x, y) -> x + y;                         // won't compile 
(var x, Integer y) -> x + y;                 // won't compile 

(int x) -> x > 10;                         // compiles 
(x) -> x > 10;                             // compiles 
x -> x > 10;                               // compiles 
(var x) -> x > 10;                         // compiles 
var x -> x > 10;                           // Won't compile 

(@Nullable var x, @Nonnull Integer y) -> x + y;

class HelloEpsilonGC { 
    public static void main(String[] args) { 
        System.out.println("Hello to Epsilon GC!"); 
    } 
} 

    >java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC 
    HelloEpsilonGC

import java.util.*; 
class EpMap { 
    public static void main(String args[]) { 
        Map<String, String> myMap = new HashMap<String, String>(); 
        int size = 1_000_000; 
        for(int i = 0; i < size; i++) { 
            String java = new String("Java"); 
            String eJavaGuru = new String("eJavaGuru.com"); 
            myMap.put(java, eJavaGuru); 
            myMap.remove(java); 
        } 
    } 
} 

    > java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC -Xlog:gc* 
    -Xmx40M EpMap

import java.util.*; 
class EpMap { 
    public static void main(String args[]) { 
        Map<String, String> myMap = new HashMap<String, String>(); 
        int size = 1_000_000; 
        for(int i = 0; i < size; i++) { 
            String java = "Java";
            String eJavaGuru = "eJavaGuru.com"; 
            myMap.put(java, eJavaGuru); 
            myMap.remove(java); 
        } 
    } 
} 

    > java -XX:+UnlockExperimentalVMOptions -XX:+UseEpsilonGC -Xlog:gc* 
    -Xmx40M EpMap

// basic HttpClient instance 
HttpClient client = HttpClient.newHttpClient();        

// Using builder pattern to get a basic HttpRequest instance with just //the URI 
HttpRequest request = HttpRequest.newBuilder()         
                     .uri(URI.create("http://www.ejavaguru.com/"))   
                     .build();                                       

// response instance not created using a builder. 
// HttpClient sends HttpRequests and makes HttpResponse available 
HttpResponse<String> response = client.send(request,  
                            HttpResponse.BodyHandlers.ofString()); 
System.out.println(response.body()); 

HttpClient client = HttpClient.newHttpClient(); 

HttpClient client = HttpClient.builder(). 
                     .version(Version.HTTP_2) 
                     .build(); 

HttpClient client = HttpClient.builder(). 
                     .version(Version.HTTP_2) 
                     .followRedirects(Redirect.NORMAL), 
                     .build(); 

HttpClient client = HttpClient.newBuilder(). 
                      .version(Version.HTTP_2) 
                      .followRedirects(redirect.NORMAL), 
                      .authenticator(Authenticator.getDefault()) 
                      .build(); 

HttpClient client = HttpClient.newBuilder(). 
                      .version(Version.HTTP_2) 
                      .followRedirects(redirect.NORMAL), 
                      .authenticator(new Authenticator() { 
                        public PasswordAuthentication 
                         getPasswordAuthentication() { 
                          return new PasswordAuthentication( 
                          "admin", "adminPassword".toCharArray()); 
                       }) 
                    .build(); 

HttpRequest request = HttpRequest.newBuilder() 
                        .uri(URI.create("http://www.eJavaGuru.com/")) 
                        .build(); 

HttpRequest request = HttpRequest.newBuilder() 
                        .uri(URI.create("http://www.eJavaGuru.com/")) 
                        .timeout(Duration.ofSeconds(240)) 
                        .build(); 

HttpRequest request = HttpRequest.newBuilder() 
                     .uri(new URI("http://www.eJavaGuru.com/")) 
                     .timeout(Duration.ofSeconds(240)) 
                     .POST(HttpRequest.noBody()) 
                     .build(); 

HttpRequest request = HttpRequest.newBuilder() 
                        .uri(new URI("http://www.eJavaGuru.com/")) 
                        .timeout(Duration.ofSeconds(240)) 
                        .POST(HttpRequest.BodyProcessor 
                        .fromFile(Paths.get("data.txt"))) 
                        .build(); 

HttpRequest request = HttpRequest.newBuilder() 
                        .uri(new URI("http://www.eJavaGuru.com/")) 
                        .timeout(Duration.ofSeconds(240)) 
                        .POST(HttpRequest.BodyProcessor 
                        .fromString("This is sample data")) 
                        .build(); 

HttpRequest request = HttpRequest.newBuilder() 
                        .uri(URI.create("http://www.eJavaGuru.com/")) 
                        .header("Content-Type", "text/plain") 
                        .build();

HttpClient client = HttpClient.newHttpClient();        

HttpRequest request = HttpRequest.newBuilder()         
                       .uri(URI.create("http://google.com/"))   
                       .build();                                       

HttpResponse<String> response = client.send(request, HttpResponse.
                                            BodyHandlers.ofString()); 
System.out.println(response.body()); 

class SyncGetHTML { 
    public static void main(String args[]) throws Exception { 
        HttpClient client = HttpClient.newHttpClient(); 
        HttpRequest request = HttpRequest.newBuilder() 
        .uri(URI.create("https://docs.oracle.com/en/java/javase
        /11/docs/api/java.net.http/java/net/http/HttpClient.html")) 
              .build(); 

        HttpResponse<String> response = 
              client.send(request, BodyHandlers.ofString()); 
        System.out.println(response.body()); 
    } 
} 

<!DOCTYPE HTML> 
<!-- NewPage --> 
<html lang="en"> 
<head> 
<!-- Generated by javadoc --> 
<title>HttpClient (Java SE 11 & JDK 11 )</title> 
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> 
<meta name="keywords" content="java.net.http.HttpClient class"> 

class SyncGetHTMLToFile { 
    public static void main(String args[]) throws Exception { 
        HttpClient client = HttpClient.newHttpClient(); 
        HttpRequest request = HttpRequest.newBuilder() 
        .uri(URI.create("https://docs.oracle.com/en
        /java/javase/11/docs/api/java.net.http/java
        /net/http/HttpClient.html")) 
              .build(); 

        HttpResponse<Path> response = 
           client.send(request, 
           BodyHandlers.ofFile(Paths.get("HttpClient.html"))); 
    } 
} 

class AsyncGetHTMLToFile { 
    public static void main(String args[]) throws Exception { 
        HttpClient client = HttpClient.newHttpClient(); 
        HttpRequest request = HttpRequest.newBuilder() 
        .uri(URI.create("https://docs.oracle.com/en
        /java/javase/11/docs/api/java.net.http/java/net
        /http/HttpClient.html")) 
              .build(); 

        CompletableFuture<Path> response = 
            client.sendAsync(request, 
            BodyHandlers.ofFile(Paths.get("http.html"))) 
            .thenApply(HttpResponse::body); 
        response.get(); 
    } 
} 

class MultipleImageDownload{ 
    public static void main(String args[]) throws Exception { 
        List<URI> imageURIs =  
List.of(  
URI.create("http://ejavaguru.com/images/about/jbcn-actual-2018.jpg"), 
URI.create("http://ejavaguru.com/images/about/iit-delhi.jpg"), 
URI.create("http://ejavaguru.com/images/about/techfluence.jpg")); 

        HttpClient client = HttpClient.newHttpClient(); 

        List<HttpRequest> imgDwnldRequests = imageURIs.stream() 
                                    .map(HttpRequest::newBuilder) 
                                    .map(builder -> builder.build()) 
                                    .collect(Collectors.toList()); 

        CompletableFuture.allOf(imgDwnldRequests.stream() 
            .map(request -> client.sendAsync(request, 
                                 BodyHandlers.ofFile( 
                                 Paths.get(((String)request.uri() 
                                        .getPath()).substring(14) 
                                     ) 
                                 ) 
                            )) 
                           .toArray(CompletableFuture<?>[]::new)) 
                           .join(); 
    } 
} 

public class HttpReqPost { 
    public static void main(String uri[]) throws Exception { 
        String postData = "?
        name='Mala'&email='info@ejavaguru
        @gmail.com'"; 
        HttpClient client = HttpClient.newHttpClient(); 
        HttpRequest request = HttpRequest.newBuilder() 
       .uri(URI.create("http://www.ejavaguru.com/Java11/register.php")) 
            .POST(BodyPublishers.ofString(postData)) 
            .build(); 

        HttpResponse<?> response = client.send(request, 
        BodyHandlers.discarding()); 
        System.out.println(response.statusCode()); 
    } 
} 

.POST(BodyPublishers.ofString(postString)  

$ hg clone http://hg.openjdk.java.net/jdk/jdk
$ cd zgc
$ sh configure --with-jvm-features=zgc
$ make images

g./build/linux-x86_64-normal-server-release/images/jdk  

class HelloZGC { 
    public static void main(String[] args) { 
        System.out.println("Say hello to new low pause GC - ZGC!"); 
    } 
} 

java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC HelloZGC

java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -Xlog:gc HelloZGC

java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -Xlog:gc* HelloZGC

java -XX:+UnlockExperimentalVMOptions -XX:+UseZGC -Xlog:gc:mylog.log* HelloZGC  

-Xmx<size>

-XX:ConcGCThreads=<number> 

-XX:+UseLargePages

-XX:+UseTransparentHugePage

-XX:+UseNUMA

class HelloWorld { 
    public static void main(String[] args) { 
        System.out.println("Hello World - This is being recorded"); 
    } 
} 

  > java -XX:StartFlightRecording,filename=hello.jfr 
     HelloWorld  

class AThread implements Runnable { 
    String name = "default"; 
    private Random numGenerator = new Random(); 
    private ArrayList<Double> list = new ArrayList<Double>(10_00_000); 

    AThread(String name) { 
        this.name = name; 
    } 
    public void run() { 
        for (int i = 0; i < 10_00_000; i++) { 
            list.add(numGenerator.nextDouble()); 
            System.out.println("Allocated : " + name + "[" + i + "]"); 
        } 
    } 
} 
public class TestFlightRecorder { 
    public static void main(String... args) throws Exception { 
        for (int i = 0; i < 500; i++) { 
            new Thread(new AThread("Thread" + i)).start(); 
        } 
    } 
} 

    > java 
    -XX:+UnlockExperimentalVMOptions 
    -XX:+UseEpsilonGC 
    -XX:StartFlightRecording,filename=Epsilon.jfr 
         TestFlightRecorder

class MyEvent extends Event { 
   @Label("EventMessage") 
   String message; 
} 

class AThread implements Runnable { 
    String name = "default"; 
    private Random numGenerator = new Random(); 
    private ArrayList<Double> list = new ArrayList<Double>(1000000); 

    AThread(String name) { 
        this.name = name; 
    } 

    public void run() { 
        MyEvent event; 
        for (int i = 0; i < 1000000; i++) { 
            list.add(numGenerator.nextDouble()); 
            event = new MyEvent(); 
            event.message = "Allocated : " + name + "[" + i + "]"; 
            event.commit(); 
        } 
    } 
} 
public class WithCustomEvents { 
    public static void main(String... args) throws Exception { 
        for (int i = 0; i < 500; i++) { 
            new Thread(new AThread("Thread" + i)).start(); 
        } 
    } 
} 

    > java 
    -XX:StartFlightRecording,filename=CustomEvents.jfr 
         WithCustomEvents

class ReadFRData { 
    public static void main(String args[]) throws Exception { 
        Path p = Paths.get("CustomEvents.jfr"); 
        for (RecordedEvent e : RecordingFile.readAllEvents(p)) { 
           System.out.println(e.getStartTime() +  
                              " : " +  
                              e.getValue("message")); 
        } 
    } 
}

public class Outer { 
    private int outerInt = 20; 
    public class Inner { 
        int innerInt = outerInt;     // Can Inner access outerInt? 
    } 
} 

// Decompiled class Outer 
public class Outer { 
    public class Inner { 
        int innerInt; 
        final Outer this$0; 

        public Inner() { 
            this$0 = Outer.this; 
            super(); 
            innerInt = outerInt; 
        } 
    } 
    public Outer() { 
        outerInt = 20; 
    } 
    private int outerInt; 
} 

public class Outer$Inner { 
    int innerInt; 
    final Outer this$0; 

    public Outer$Inner() { 
        this$0 = Outer.this; 
        super(); 
        innerInt = outerInt; 
    } 
}

    --add-modules

class HelloNoCompilation { 
    public static void main(String[] args) { 
        System.out.println("No compilation! Are you kidding me?"); 
    } 
} 

    > java HelloNoCompilation.java

class HelloNoCompilation { 
    public static void main(String[] args) { 
        System.out.println("No compilation! Are you kidding me?"); 
        EstablishedOrg org = new EstablishedOrg(); 
        org.invite(); 
        System.out.println(new Startup().name); 
    } 
} 
class Startup { 
    String name = "CoolAndExciting"; 
} 
interface Employs { 
    default void invite() { 
        System.out.println("Want to work with us?"); 
    } 
} 
class EstablishedOrg implements Employs { 
    String name = "OldButStable"; 
} 

    > java HelloNoCompilation.java

    No compilation! Are you kidding me?
    Want to work with us?
    CoolAndExciting  

    > javac HelloNoCompilation.java

    > java HelloNoCompilation.java  

    error: class found on application class path: HelloNoCompilation  

enum Size {XS, S, M, L, XL, XXL};          
class Shirt { 
    private int length; 
    public void setSize(Size size) { 
        switch(size) { 
            case XS :   length = 10; 
                        System.out.println(length); 
                        break; 
            case S  :   length = 12; 
                        System.out.println(length); 
                        break; 
            case M  :   length = 14; 
                        System.out.println(length); 
            case L  :   length = 16; 
                        break; 
            case XL :   length = 18; 
                        System.out.println(length); 
                        break; 
            case XXL:   length = 20; 
                        System.out.println(length); 
                        break; 
        } 
    } 
} 

Shirt s = new Shirt(); 
s.setSize(Size.XXL); 
System.out.println(s.length);

20 
20 

Shirt s = new Shirt(); 
s.setSize(Size.M); 
System.out.println(s.length); 

14 
16 

enum SingleUsePlastic {STRAW, BAG, SPOON, FORK, KNIFE, PLATE, BOTTLE}; 

class Planet { 
    private static long damage; 
    public void use(SingleUsePlastic plastic) { 
        switch(plastic) { 
            case STRAW :    damage += 10; 
                            break; 
            case BAG   :    damage += 11; 
                            break; 
            case SPOON :    damage += 7; 
                            break; 
            case FORK  :    damage += 7; 
                            break; 
            case KNIFE :    damage += 7; 
                            break; 
            case PLATE :    damage += 15; 
                            break; 
            case BOTTLE:    damage = 20; 
                            break; 
        } 
    } 
} 

damage += switch(plastic) { 
                case STRAW -> 10; 
                case BAG -> 11; 
                case SPOON, FORK, KNIFE -> 7; 
                case PLATE -> 15; 
                case BOTTLE -> 20; 
          }; 

class Planet { 
    private static long damage; 
    public void use(SingleUsePlastic plastic) { 
        damage += switch(plastic) { 
            case STRAW -> 10; 
            case BAG -> 11; 
            case SPOON, FORK, KNIFE -> 7; 
            case PLATE -> { 
                                int radius = 20;  // Local variable           

                                break (radius < 10 ? 15 : 20); // Using 
                                                    // break to return 
                                                    // a value 
                          } 
            case BOTTLE -> 20; 
        }; 
    } 
} 

class Planet { 
    private static long damage; 
    public void use(SingleUsePlastic plastic) { 
        damage += switch(plastic) { 
            case STRAW : break 10;      // Use colon (:) to start code,  
                                        // Use break to return val 
            case BAG   : break 11; 
            case SPOON, FORK, KNIFE : break 7; 
            case PLATE : int radius = 6;         // no need 
                                                // of using curly brace
                         break (radius < 10 ? 15 : 20); // Using 
                                                       // break to  
                                                      // return a value 
            case BOTTLE : break 20; 
        }; 
    } 
} 

int sum(int x, int y) {                   // return type of method is 
                                         // int 
    int result = x + y; 
    return result;                        // returns int value 
}
void output(List<Integer> list) {         // return type of method is 
                                         // void
    if (list == null)
        return;                           // exit method without 
                                          // returning a value
    else {
        for (Integer i : list)
            System.out.println(i);
    }
    System.out.println("End of method");  // this doesn't execute if 
                                         // list is null
}

class Planet { 
    private static long damage; 
    public void use(SingleUsePlastic plastic) { 
        damage += switch(plastic) { 
            case SPOON, FORK, KNIFE -> 7; 
        }; 
    } 
} 

class Planet { 
    private static long damage; 
    public void use(SingleUsePlastic plastic) { 
        damage += switch(plastic) { 
            case SPOON, FORK, KNIFE -> 7; 
            // Adding (1) or (2), or both will enable the code to 
            // compile
            case PLATE -> 10;     // line number (1)
            default -> 100;       // line number (2)
        }; 
    } 
}

String getBook(String name) {
    String bookName = switch(name) { 
        case "Shreya" -> "Harry Potter";
        case "Paul" -> "Management tips";
        case "Harry" -> "Life of Pi";
        default -> "Design Patters - everyone needs this";   
    };
    return bookName;
} 

 String getBook(String name) {
    String bookName = null;
    switch(name) {                                    // NOT returning 
                                                     // a value
        case "Shreya" -> bookName = "Harry Potter";
        case "Paul" -> bookName = "Management tips";
        case "Harry" -> bookName = "Life of Pi";      // default case 
                                                    // not included
    }
    return bookName;
}

String day = // assign a value here    
switch(day) {                                    
    case "Sun" -> System.out.println("OSS-Jav");
    case "Mon", "Tue" -> {
        // some simple/complex code
    }
    default -> throw new RuntimeException("Running out of projects");
}

class Planet { 
    private static long damage; 
    public void use(SingleUsePlastic plastic) { 
        myLabel:                                           // Label  
            for (...) { 
                damage += switch(plastic) { 
                    case SPOON, FORK, KNIFE : break 7;    
                    case PLATE : continue myLabel;         // NOT 
                                                           // allowed 
                                                           // illegal                                                            
                                                           // jump 
                                                           // through                                                             
                                                           // switch 
                                                          // expression 
                }; 
            } 
    } 
}

jdk/jdk
    .../make/test
    .../test
       .../micro/org/openjdk/bench
           .../java
                .../vm

java -Xshare:dump

enum Size {SMALL, MEDIUM, LARGE}

class Shirt { 
    Size size;              // instance variable of type Size 
    Color color; 

    Shirt(Size size, Color color) {      // Size object with Shirt                                                                     
                                         // instantiation 
        this.size = size; 
        this.color = color; 
    } 
} 

class GarmentFactory { 
    void createShirts() { 
        Shirt redShirtS = new Shirt(Size.SMALL, Color.red); 
        Shirt greenShirtM = new Shirt(Size.MEDIUM, Color.green); 
        Shirt redShirtL = new Shirt(Size.LARGE, Color.red); 
    } 
} 

final class Size extends Enum                 // 'enum' converted to final class  
{ 
    public static final Size SMALL;           // variables to store  
    public static final Size MEDIUM;          // enum constants 
    public static final Size LARGE;           //  

    private static final Size $VALUES[];    // array of all enum 
                                            // constants 

    static 
    {                                       // static initializer 
        SMALL = new Size("SMALL", 0);       // to initialize enum                                                                                             
                                            // constants 
        MEDIUM = new Size("MEDIUM", 1);     // 
        LARGE = new Size("LARGE", 2);       // 
        $VALUES = (new Size[] {             // 
            SMALL, MEDIUM, LARGE            // & populate array of enum                                             
                                            // constants 
        }); 
    } 
    public static Size[] values() 
    { 
                return (Size[])$VALUES.clone();       // Avoiding any                                                                                                          
                                                    // modification to  
    }                                // $VALUES by calling methods 
    public static Size valueOf(String s) 
    { 
        return (Size)Enum.valueOf(Size, s); 
    } 
    private Size(String s, int i) 
    { 
        super(s, i); 
    } 
} 

enum Size { 
    SMALL(36, 19), 
    MEDIUM(32, 20) {               // Constant specific class body  
        int number = 10;                    // variable specific to 
                                            //MEDIUM 
        int getSize() {                     // method specific to 
                                            //MEDIUM 
            return length + width; 
        } 
    }, 
    LARGE(34, 22) { 
        @Override  
        public String toText() {            // overriding method toText 
                                            //for  
            return "LARGE";                 // constant LARGE 
        } 
    }; 

    int length;                             // instance variable 
                                            //accessible 
    int width;                              // to all enum constants 

    Size(int length, int width) {           // enum constructor; 
                                            //accepts length 
        this.length = length;               // and width 
        this.width = width; 
    } 

    int getLength() {                       // method accessible to all 
                                            //enum 
        return length;                      // constants 
    } 

    int getWidth() {                        // method accessible to all 
                                            //enum 
        return width;                       // constants 
    }  

    public String toText() {               // method accessible to all 
                                           //enum 
        return length + " X " + width;     // constants 
    } 
} 

System.out.println(Size.SMALL.toText());  // toString is defined for all constants 

36 X 19 

System.out.println(Size.LARGE.toText()); 

LARGE

System.out.println(Size.MEDIUM.number);          // Doesn't compile 
System.out.println(Size.MEDIUM.getSize());       // Doesn't compile 

enum Size {
    SMALL(36, 19),
    MEDIUM(32, 20),
    LARGE(34, 22);
    int length;                            // instance variable 
                                           //accessible
    int width;                             // to all enum constants
    Size(int length, int width) {          // enum constructor; accepts 
                                            //length
         this.length = length;             // and width
         this.width = width;
    }
    int getSize() {
       if (this == MEDIUM)
         return length + width;
       else                                           // throws runtime 
                                                      // exception
         throw new UnsupportedOperationException();   // if used with 
                                                      // constants
    }                                                 // other than 
                                                      //MEDIUM
}

System.out.println(MEDIUM.getSize());
System.out.println(LARGE.getSize());

52
Exception in thread—java.lang.UnsupportedOperationException

class Measurement {}                      // base class 
class Small extends Measurement {         // derived class 
    String text = "Small";                // state specific to class 
                                          //Small 
} 
class Medium extends Measurement {        // derived class 
    public int getLength() {              // behavior specific to class 
                                          //Medium 
        return 9999; 
    } 
} 
class Large extends Measurement {}        // derived class 

enum Size {                                
    SMALL(new Small()),                // constant created using Small 
                                       //instance 
    MEDIUM(new Medium()),              // constant created using Medium 
                                       //instance 
    LARGE(new Large());                // constant created using Large 
                                       //instance 

    private Measurement mObj;     // Measurement is base class of  
                                  // classes Small, Medium & Large 

    Size(Measurement obj) {     // wraps Measurement instance as an 
                                //Enum instance 
        mObj = obj; 
    } 
    Measurement getMeasurement() { // get the wrapped instance 
        return mObj; 
    } 
}

class Test1 { 
    public static void main(String args[]) { 
        var large = Size.LARGE; 
        System.out.println(large.getMeasurement()
                             .getLength());      // doesn't compile 
                                                 // the type of the                                                     
                                                 // variable used 
                                                 // to wrap the value                                                  
                                                 // of enum  
                                                 // constant is                                                          
                                                 // Measurement  
    } 
} 

enum Size <T extends Measurement> {      // enum with type parameter 
    SMALL(new Small()), 
    MEDIUM(new Medium()), 
    LARGE(new Large()); 

    private T mObj; 

    Size(T obj) { 
        mObj = obj; 
    } 
    T getMeasurement() { 
        return mObj; 
    } 
} 

class Measurement {} 
class Small extends Measurement { 
    String text = "Small"; 
} 
class Medium extends Measurement {} 
class Large extends Measurement { 
    public int getLength() { 
        return 40; 
    } 
}

var large = Size.LARGE; 
System.out.println(large.getMeasurement().getLength());  

public enum Data<T> { 
    NAME<String>,                // constants of generic  
    AGE<Integer>,                // enum Data 
    ADDRESS<Address>; 
} 

public class FormData { 
    public <T> void add(Data<T> type, T value) { 
        //..code 
    } 
}

FormData data = new FormData(); 
data.add(Data.NAME, "Pavni");            // okay; type of NAME and 
                                         // Pavni is String 
data.add(Data.AGE, 22);                  // okay; type of AGE and 22 is 
                                         // Integer 
data.add(Data.ADDRESS, "California");    // Won't compile. "California"  
                                         // is String, not Address 
                                         // instance 

final class Emp { 
    private String name; 
    private int age; 

    public Emp(String name, int age) { 
        this.name = name; 
        this.age = age; 
    } 

    // accessor methods - getName, getAge 
    public String getName() { 
        return name; 
    } 

    public int getAge() { 
        return age; 
    } 

    // mutator methods - setName, setAge 
    public void setName() { 
        this.name = name; 
    } 

    public void setAge() { 
        this.age = age; 
    } 

    public boolean equals(Object obj) { 
        if (obj == null || (!(obj instanceof Emp))) 
            return false; 
        else { 
            if ( ( ((Emp)obj).getName().equals(this.name) && 
                 ( ((Emp)obj).getAge() ) == this.age)) { 
                return true; 
            } 
            else 
                return false; 
        } 
    } 

    public String toString() { 
        return name + ":" + age; 
    } 
    public int hashCode() { 
        // ..code 
    } 
} 

interface EmpDAO { 
    Emp read(); 
    void write(Emp emp); 
    List<Emp> getAllEmp(); 
} 

record Emp(String name, int age) { }      // data class - one liner 
                                          // code 

final class Emp extends java.lang.DataClass {
     final String name; final int age; 
         public Emp(String name, int age) {
         this.name = name; this.age = age; } // deconstructor // public        
        // accessor methods // default implementation of equals,     
       // hashCode, and toString } 

record Emp(String name, int age) { }       

class Size { 
    public final static int SMALL = 1; 
    public final static int MEDIUM = 2; 
    public final static int LARGE = 3; 
}

enum Size {SMALL, MEDIUM, LARGE} 
class SmallTShirt { 
    Size size = Size.SMALL; 
    //..other code 
} 

interface Garment {} 
record Button(float radius, Color color); 
record Shirt(Button button, double price); 
record Trousers(float length, Button button, double price); 
record Cap(..) 

switch (garment) { 
     case Shirt(Button(var a1, var a2), Color a3): ... 
     case Trousers(float a1, Button(var a2, var a3), double a4): ... 
     .... 
}

switch (garment) { 
     case Shirt(Button a1, Color a2): ... 
     case Trousers(float a1, Button a2, double a3): ... 
     .... 
}  

record Emp(String name, int age) { }

final class Emp extends java.lang.DataClass { 
    final String name; 
    final int age; 

    public Emp(String name, int age) { 
        this.name = name; 
        this.age = age; 
    } 

    // deconstructor 
    // public accessor methods 
    // default implementation of equals, hashCode, and toString 
} 

abstract record JVMLanguage(String name, int year); 
record Conference(String name, String venue, DateTime when); 

abstract record Emp(String name, int age); 
record Manager(String name, int age, String country) extends Emp(name, age); 

interface Organizer {} 
interface Speaker { 
   abstract void conferenceTalk(); 
} 

abstract record Emp(String name, int age); 

record Manager(String name, int age, String country)  
   extends Emp(name, age)                    // subclass a record
   implements Organizer;                     // implement one interface

record Programmer(String name, int age, String programmingLang)  
   extends Emp(name, age)                    // subclass a record
   implements Organizer, Speaker {           // implementing multiple 
                                             // interfaces
        public void conferenceTalk() {       // implement abstract 
                                             // method
            //.. code                        // from interface Speaker
        } 
    };

record Emp(String name, int age) { 
    private String style; 
    Emp(String name, int age) { 
        //.. initialize name and age 
        if (age => 15 && age =< 30) style = "COOL"; 
        else if (age >= 31 && age <= 50) style = "SAFE"; 
        else if (age >= 51) style = "ELEGANT"; 
    } 
    public String getStyle() { 
        return style; 
    } 
}

record Emp(String name, int age) { 
    // override default constructor 
    @Override 
    public Emp(String name, int age) { 
        // validate age 
        if (age > 70) 
            throw new IllegalArgumentException("Not employable above 70             
            years"); 
        else { 
            // call default constructor 
            default.this(name, age); 
        } 
    } 
} 

record Emp(String name, int age) { 
    // overloading constructor 
    public Emp(String name, String style) { 
            this.name = name; 
            if (style.equals("COOL") age = 20; 
            else if (style.equals("SAFE") age = 30; 
            else if (style.equals("ELEGANT") age = 50; 
            else age = 70; 
        } 
    } 
    public String fancyOutput() {                 // additional method 
        return "My style is COOL"; 
    } 
} 

String html =  
`<HTML>                                      
    <BODY> 
        <H1>Meaning of life</H1>  
    </BODY> 
</HTML> 
`; 

<HTML> 
   <BODY> 
          <H1>Meaning of life</H1>  
   </BODY> 
</HTML>

String html = "<HTML>\n\t<BODY>\n\t\t<H1>Meaning in life</H1>\n\t</BODY>\n</HTML>"; 

String html =  "<HTML>" + 
"\n\t" + "<BODY>" + 
"\n\t\t" + "<H1>Meaning of life</H1>" + 
"\n\t" + "</BODY>" + 
"\n" + "</HTML>";

String html =  "<HTML>" + 
                    "\n\t" + "<BODY>" + 
                        "\n\t\t" + "<H1>Meaning of life</H1>" + 
                    "\n\t" + "</BODY>" + 
                "\n" + "</HTML>"; 

<HTML> 
   <BODY> 
          <H1>\n - new line, \t - tab</H1>  
   </BODY> 
</HTML> 

String html =  "<HTML>" + 
                    "\n\t" + "<BODY>" + 
                        "\n\t\t" + "<H1>\\n - new line, \\t - tab</H1>" 
                        +  
                    "\n\t" + "</BODY>" + 
                "\n" + "</HTML>";

(\w)(\s+))[\.] 

String patternToMatch = "(\\w)(\\s+)([\\.,])";     // Isn't that a lot 
                                                   // to digest? 
                                                   // Does the regex  
                                                   // pattern has
                                                   // a single 
                                                   // backslash, or,
                                                   // two of them? 

String html =  
`<HTML>                                      
    <BODY> 
        <H1>Meaning of life</H1>  
    </BODY> 
</HTML> 
`; 

RawStringDelimeter {RawStringCharacters} RawStringDelimeter 

String html =  
``<HTML>                                      
    <BODY> 
        <H1>I think I like ` as a delimiter!</H1>  
    </BODY> 
</HTML> 
``; 

String html =  
````<HTML>

    <BODY>

        <H1>I believe I would have liked ```java too(!)</H1>  
    </BODY> 
</HTML> 
````;

```java

If there is a mismatch between the count of backticks in the opening and closing delimiters, the code won't compile.

# Treating escape values

The Unicode and escape sequences are never interpreted in a raw string literal value.

A lexer is a software program that performs **lexical analysis**. Lexical analysis is the process of tokenizing a stream of characters into words and tokens. As you read this line, you are analyzing this string lexically, using the spaces to separate chunks of letters as words.

This analysis is disabled for the raw string literals at the start of the opening backtick. It is re-enabled at the closing backtick.

Don't replace the backtick in your string value with its Unicode escape (that is, `\u0060 in`), for consistency. 

The only exceptions to this rule are `CR` (carriage return—`\u000D`) and `CRLF` (carriage return and line feed—`\u000D\u000A`). Both of these are translated to `LF` (line feed—`\u000A`).

# Raw string literals versus traditional string literals

The introduction of raw string literals will not change the interpretation of the traditional string literal values. This includes their multiline capabilities and how they handle the escape sequences and delimiters. A traditional string can include Unicode escapes (JLS 3.3) or escape sequences (JLS 3.10.6).

A Java class file, that is, the Java bytecode, does not record whether a string constant was created using a traditional string or a raw string. Both traditional and raw string values are stored as instances of the `java.lang.String` class. 

# Interpreting escape sequences

To interpret escape sequences in multiline raw string values, Java will add methods to the `String` class—`unescape()` and `escape()`:

Considering raw string literals at Oracle, work is in progress. Oracle is considering swapping the names of the methods `unescape()` and `escape()`, or even renaming them.

# The unescape() method

By default, the raw string literals don't interpret the escape sequences. However, what if you want them to do so? When used with a raw string, the `unescape()` method will match the sequence of the characters following `\` with the sequence of Unicode escapes and escape sequences, as defined in the **Java Language Specifications** (**JLS**). If a match is found, the escape sequence will not be used as a regular combination of letters; it will be used as an escape sequence.

The following code doesn't interpret `\n` as a newline escape sequence:

The output of the preceding code is as follows:

However, the following code will interpret `\n` as a newline escape sequence:

The output of the preceding code will provide the `eJava` and `Guru` string values on separate lines, as follows:

When interpreted as escape sequences, a combination of letters that is used to represent them, is counted as a control character of the length `1`. The output of the following code will be `1`:

# The escape() method

The `escape()` method will be used to invert the escapes. The following table shows how it will convert the characters:

| **Original character** | **Converted character** |
| Less than `' '` (space) | Unicode or character escape sequences |
| Above `~` (tilde) | Unicode escape sequences |
| `"` (double quotes) | Escape sequence |
| `'` (single quote) | Escape sequence |
| `\` (backslash) | Escape sequence |

The following example doesn't include a newline in the output:

The output of the preceding code is as follows:

Consider the following code:

The output of the preceding code is as follows (`•` is converted to its equivalent escape value):

# Managing margins

Suppose that you have to import multiline text from a file in your Java code. How would you prefer to treat the margins of the imported text? You may have to align or indent the imported text. The text might use a custom newline delimiter (say, `[`), which you might prefer to strip from the text. To work with these requirements, a set of new methods, such as `align()`, `indent()`, and `transform()`, are being added to the `String` class, which we'll cover in the next section.

# The align() method

When you define a multiline string value, you might choose to format the string against the left margin or align it with the indentation used by the code. The string values are stored with the margin intact. The `align()` method will provide incidental indentation support; it will strip off any leading or trailing blank lines, then justify each line, without losing the indentations.

The following is an example:

`one

    of

            my

    favorite

        lang

            feature

from Amber(!)

The output of the preceding code is as follows:

    我的

最爱

    语言

        功能

# The indent(int) method

The `indent(int)` method will enable developers to specify custom indentations for their multiline string values. You can pass a positive number, `i`, to `indent(int)`, to add `i` spaces (`U+0020`) to your text, or you can pass a negative number, to remove a given number of whitespaces from each line of your multiline text.

An example is as follows:

`one

    of

            我的

    最爱

        语言

            功能

from Amber(!)

The output of the preceding code is as follows:

            of

                    我的

            最爱

                语言

                    功能

        from Amber(!)

The `indent(int)` method can be used to add or remove whitespaces from each line in a multitext value. By passing a positive number, you can add whitespaces, and you can remove them by passing negative values.

# The overloaded align(int) method

The `align(int)` method will first align the rows of a multistring value, and will then indent it with the specified spaces. The following is an example:

`one

    of

            我的

    最爱

        语言

            功能

from Amber(!)

The output of the preceding code is as follows (the text on each line is preceded by fifteen spaces):

            of

                    我的

            最爱

                语言

                    功能

        from Amber(!)

# The detab(int) and entab methods

A tab (`U+0009`) usually represents four whitespaces (`U+0020`). However, not all of the applications convert between tabs and whitespaces when they use text that includes a mix of whitespaces and tabs. To combat this challenge with the multiline text, the `String` class will include two methods, `detab(int)` and `entab(int)`, which will convert a tab to whitespaces, and vice versa:

Let's modify the preceding example, so that the content includes tabs instead of whitespaces, as follows:

    `one

of

        我的

    最爱

        语言

功能

from Amber(!)

The output of the preceding code is as follows (each tab is converted to one whitespace):

# The transform() method

Suppose that a file includes the following text, using `[` at the beginning of a new line:

Now, suppose that you must remove the delimiter, `[`, used at the beginning of all lines. You can use the `transform()` method to customize the margin management, adding the `String` class:

The following is an example that uses the method `transform()` to remove the custom margin characters from the multiline text:

                [ 讲座 - Java11, Amber, CleanCode

                [ 海洋 - 濒临灭绝，人类冷漠，塑料

                污染

            `.transform({

                multiLineText.stream()

                    .map(e -> e.map(String::strip)

                    .map(s -> s.startsWith("[  ") ?

                        s.substring("[  ".length())

                        : s)

                    .collect(Collectors.joining("\n", "", "\n"));

            });

The next section will include some common cases where using raw string literals over traditional strings will benefit you tremendously.

# Common examples

If you have used stored JSON, XML data, database queries, or file paths as string literals, you know it is difficult to write and read such code. This section will highlight examples of how a traditional raw string will improve the readability of your code when working with these types of data.

# JSON data

Suppose that you have the following JSON data to be stored as a Java string:

"item": [

{"value": "Water Bottle", "replaceWith": "Steel Bottle()"},

{"value": "Straw", "replaceWith": "Ban Straws"},

{"value": "Spoon", "replaceWith": "Steel Spoon"}

]

The following code shows how you would perform this action with the traditional `String` class, escaping the double quotes within the data by using `\` and adding a newline escape sequence:

"\"item\": [ \n" +

"{\"value\": \"Water Bottle\", \"replaceWith\": \"Steel

    Bottle()\"}, \n" +

"{\"value\": \"Straw\", \"replaceWith\": \"Ban Straws\"}, \n" +

"{\"value\": \"Spoon\", \"replaceWith\": \"Steel Spoon\"} \n" +

"] \n" +

To be honest, it took me quite a while to write the preceding code, escaping the double quotes with the backslash. As you can see, this code is not readable.

The following example shows how you can code the same JSON data using raw string literals, without giving up the code readability:

  "id": "98751", 
  "singleuse": { 
    "item": [ 
      {"value": "Water Bottle", "replaceWith": "Steel Bottle()"}, 
      {"value": "Straw", "replaceWith": "Ban Straws"}, 
      {"value": "Spoon", "replaceWith": "Steel Spoon"} 
    ] 
  } 
}}```;

```java

# XML data

The following code is an example of XML data that you might need to store using a Java string:

<item value="Water Bottle" replaceWith="Steel bottle" />

<item value="Straw" replaceWith="Ban Straws" />

<item value="spoon" replaceWith="Steel Spoon" />

The following code shows how you can define the preceding data as a `String` literal by using the appropriate escape sequences:

"<item value=\"Water Bottle\" replaceWith=\"Steel bottle\" />\n" +

"<item value=\"Straw\" replaceWith=\"Ban Straws\" />\n" +

"<item value=\"spoon\" replaceWith=\"Steel Spoon\" />\n" +

Again, the escape sequences added to the preceding code (`\` to escape `"` and `\n` to add newline) make it very difficult to read and understand the code. The following example shows how you can drop the programming-specific details from the data by using raw string literals:

<plastic id="98751"> 
  <singleuse> 
    <item value="Water Bottle" replaceWith="Steel bottle" /> 
    <item value="Straw" replaceWith="Ban Straws" /> 
    <item value="spoon" replaceWith="Steel Spoon" /> 
  </singleuse> 
</plastic> 
```;

```java

# File paths

The file paths on Windows OS use a backslash to separate the directories and their subdirectories. For instance, `C:\Mala\eJavaGuru` refers to the `eJavaGuru` subdirectory in the `Mala` directory in the `C:` drive. Here's how you can store this path by using a traditional string literal:

With raw string literals, you can store the same file path as follows (changes are highlighted in bold):

# Database queries

Suppose that you have to create an SQL query that includes the column names, table names, and literal values. The following code shows how you would typically write it, using traditional strings:

        "FROM   talks, speakers " +

        "WHERE  talks.speaker_id = speakers.speaker_id " +

        "AND    talks.duration > 50 ";

You can also write the code as follows, using quotes around the column or table names, depending on the target database management system:

        "FROM   'talks', 'speakers' " +

        "WHERE  'talks.speaker_id' = 'speakers.speaker_id' " +

        "AND    'talks.duration' > 50 ";

The raw string literal values are much more readable, as shown in the following code:

   FROM   'talks', 'speakers'  
   WHERE  'talks.speaker_id' = 'speakers.speaker_id' 
   AND    'talks.duration' > 50  
```;

BiFunction<Integer, String, Boolean> calc = (age, _) -> age > 10;

// Approach 1
// Pass null to the unused parameter
BiFunction<Boolean, Integer, String> calc = (age, null) -> age > 10;

// Approach 2
// Pass empty string to the unused parameter
BiFunction<Boolean, Integer, String> calc = (age, "") -> age > 10;

// Approach 3
// Pass ANY String value to the unused parameter -
// - doesn't matter, since it is not used
BiFunction<Boolean, Integer, String> calc = 
                       (age, "Ban plastic straws") -> age > 10;

// Approach 4
// Pass any variable (of the same type) to the unused parameter -
// - doesn't matter, since it is not used
BiFunction<Boolean, Integer, String> calc = (age, name) -> age > 10;

key -> key.uppercase();           // single lambda parameter

(int x, int y) -> x > y? x : y;   // two lambda parameters

(a, b, c, d) -> a + b + c + d;    // four lambda parameters

List<String> talks = List.of("Kubernetes", "Docker", "Java 11");
talks.stream()
        .map(key -> key.toUpperCase())
        .forEach(System.out::prinltn);

1\. void process() {
2\.     List<String> talks = List.of("Kubernetes", "Docker", "Java 11");
3\.     String key = "Docker"; // local variable key
4\.     talks.stream()
5\.         .map(key -> key.toUpperCase())       // WON'T compile: 'key' 
            redefined
6\.         .forEach(System.out::prinltn);
7\. }

1\. String key = "Docker"; // local variable key
2\. talks.stream()
3\.     .map(key -> key.toUpperCase())         // WON'T compile : 'key' 
                                              // redefined
4\.     .forEach(System.out::println);

1\. String key = "Docker"; // local variable key
2\. talks.stream()
3\.     .map(key -> key.concat(key))            
4\.     .forEach(System.out::prinltn);

interface Swimmer {
    boolean test(String lap);
}
interface Diver {
    String dive(int height);
}

class SwimmingMeet {
    static void evaluate(Swimmer swimmer) {   // code compiles

        System.out.println("evaluate swimmer");
    }
    static void evaluate(Diver diver) {      // code compiles

        System.out.println("evaluate diver");
    }
}

class FunctionalDisambiguation {
    public static void main(String args[]) {
        SwimmingMeet.evaluate(a -> false); // This code WON'T compile
    }
}

a -> false                               // this is an implicit lambda

SwimmingMeet.evaluate((String a) -> false);         // This compiles!!

interface Swimmer {                            // test METHOD IS 
                                               // MODIFIED
    boolean test(int lap);      // String lap changed to int lap

}
interface Diver {
    String dive(int height);
}
class SwimmingMeet {
    static void evaluate(Swimmer swimmer) {          // code compiles

        System.out.println("evaluate swimmer");
    }
    static void evaluate(Diver diver) {               // code compiles
        System.out.println("evaluate diver");
    }
}

1\. SwimmingMeet.evaluate(a -> false);
2\. SwimmingMeet.evaluate((int a) -> false);

class Championship {
    static boolean reward(Integer lapTime) {
        return(lapTime < 60);
    }
    static boolean reward(String lap) {
        return(lap.equalsIgnoreCase("final ");
    }
}

someMethod(Chamionship::reward);                     // ambiguous call

Object obj = new Ocean();                         // variable type - Object 
if (obj instanceof Ocean) {                         // check instance type 
    System.out.println(((Ocean)obj).getBottles());  // cast & extract value 
} 
// A basic class - Ocean  
class Ocean { 
   private long bottles; 
   public long getBottles() { 
         return bottles; 
   } 
}

void dyingFish(Object obj) { 
    if (obj instanceof Ocean) {                          // test 
        System.out.println(((Ocean)obj).getBottles());   // cast & 
                                                         // destruct 
    } 
    else if (obj instanceof Sea) {                       // test 
        System.out.println(((Sea)obj).getDeadFish()); 
    } 
    else if (obj instanceof River) {                     // test 
        if ( ((Ocean)obj).getPlasticBags() > 100) {      // cast & 
                                                        // destruct 
            System.out.println("Say no to plastic bags. Fish are dying!"); 
        } 
    } 
} 
class Ocean { .. } 
class Sea { .. } 
class River { .. } 

Object obj = new Ocean();                         // variable type - Object 
if (obj matches Ocean o) {                        // check & bind  
    System.out.println(o.getBottles());           // extract  
} 

void dyingFish(Object obj) { 
    if (obj matches Ocean o) {                          // check & bind 
        System.out.println(o.getBottles());             // extract 
    } 
    else if (obj matches Sea sea) {                       // test 
        System.out.println(sea.getDeadFish()); 
    } 
    else if (obj matches River riv) {                     // test 
        if (riv.getPlasticBags() > 100) {      // cast & destruct 
            System.out.println("Say no to plastic bags. Fish are 
            dying!"); 
        } 
    } 
} 
class Ocean { .. } 
class Sea { .. } 
class River { .. } 

void dyingFish(Object obj) { 
    switch (obj) { 
        case Ocean o:   System.out.println(o.getBottles()); 
                        break; 
        case Sea sea:   System.out.println(sea.getDeadFish()); 
                        break; 
        case River riv: if (riv.getPlasticBags() > 100) { 
                            System.out.println("Humans enjoy! Fish die!"); 
                        } 
                        break; 
    } 
} 

JEP No.	Scope	Description
296	实现	将 JDK 森林合并为一个单一存储库
312	JDK	线程局部握手
313	JDK	移除原生头生成工具(`javah`)
314	SE	额外的 Unicode 语言标记扩展
316	JDK	在替代内存设备上进行堆分配
317	JDK	基于实验性 Java 的 JIT 编译器
319	JDK	根证书
322	SE	基于时间的发布版本号

枚举值	描述
`ALWAYS`	总是重定向
`NEVER`	永不重定向
`NORMAL`	总是重定向，除了 HTTPS URL 重定向到 HTTP URL

方法返回类型	方法名称	方法描述
`抽象 Optional<Authenticator>`	`authenticator()`	返回包含在此客户端上设置的 `Authenticator` 实例的 `Optional`
`抽象 Optional<Executor>`	`executor()`	返回包含此客户端的 `Executor` 的 `Optional`
`抽象 HttpClient.Redirect`	`followRedirects()`	返回此客户端的 `followRedirects` 策略
`静态 HttpClient.Builder`	`newBuilder()`	创建一个新的 `HttpClient` 构建器
`静态 HttpClient`	`newHttpClient()`	返回一个具有默认设置的新的 `HttpClient`
`WebSocket.Builder`	`newWebSocketBuilder()`	创建一个新的 `WebSocket` 构建器（可选操作）
`抽象 Optional<ProxySelector>`	`proxy()`	返回包含此客户端提供的 `ProxySelector` 实例的 `Optional`
`抽象 <T> HttpResponse<T>`	`send (HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler)`	使用此客户端发送给定的请求，如果需要，则阻塞以获取响应
`抽象 <T> CompletableFuture<HttpResponse<T>>`	`sendAsync (HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler)`	以异步方式发送给定的请求，使用此客户端和给定的响应体处理器
`抽象 <T> CompletableFuture<HttpResponse<T>>`	`sendAsync (HttpRequest request, HttpResponse.BodyHandler<T> responseBodyHandler, HttpResponse.PushPromiseHandler<T> pushPromiseHandler)`	以异步方式发送给定的请求，使用此客户端和给定的响应体处理器以及推送承诺处理器
`抽象 SSLContext`	`sslContext()`	返回此客户端的 `SSLContext`
`抽象 SSLParameters`	`sslParameters()`	返回此客户端的 `SSLParameters` 的副本
`抽象 HttpClient.Version`	`version()`	返回此客户端首选的 HTTP 协议版本

方法返回类型	方法名称	方法描述
`abstract Optional<HttpRequest.BodyPublisher>`	`bodyPublisher()`	返回包含在此请求上设置的 `HttpRequest.BodyPublisher` 实例的 `Optional`
`abstract boolean`	`expectContinue()`	返回请求继续设置
`abstract HttpHeaders`	`headers()`	返回此请求（或将要发送的）请求头（用户可访问的）
`abstract String`	`method()`	返回此请求的请求方法
`static HttpRequest.Builder`	`newBuilder()`	创建 `HttpRequest` 构建器
`static HttpRequest.Builder`	`newBuilder (URI uri)`	使用给定的 URI 创建 `HttpRequest` 构建器
`abstract Optional<Duration>`	`timeout()`	返回包含此请求的超时持续时间的 `Optional`
`abstract URI`	`uri()`	返回此请求的 URI
`abstract Optional<HttpClient.Version>`	`version()`	返回包含将为此 `HttpRequest` 请求的 HTTP 协议版本的 `Optional`

方法返回类型	方法名称	方法描述
`T`	`body()`	返回正文
`HttpHeaders`	`headers()`	返回接收到的响应头
`Optional<HttpResponse<T>>`	`previousResponse()`	返回包含前一个中间响应的 `Optional`，如果已接收
`HttpRequest`	`request()`	返回与该响应对应的 `HttpRequest` 实例
`Optional<SSLSession>`	`sslSession()`	返回包含此响应中有效 `SSLSession` 实例的 `Optional`
`int`	`statusCode()`	返回此响应的状态码
`URI`	`uri()`	返回接收响应的 URI
`HttpClient.Version`	`version()`	返回用于此响应的 HTTP 协议版本

JEP	范围	描述
181	SE	基于嵌套的访问控制
309	SE	动态类文件常量
315	实现	改进 AArch64 内联函数
320	SE	移除 Java EE 和 CORBA 模块
324	SE	基于 Curve25519 和 Curve448 的密钥协商
327	SE	Unicode 10
329	SE	ChaCha20 和 Poly1305 密码学算法
330	JDK	启动单个文件源代码程序
332	SE	TLS 1.3
335	JDK	废弃 Nashorn JavaScript 引擎
336	SE	废弃 pack200 工具和 API

JEP	范围	描述
189	实现	Shenandoah – 一种低暂停时间的垃圾回收器
230	JDK	微基准测试套件
334	SE	JVM 常量 API
340	JDK	一个 AArch64 端口，而不是两个
341	JDK	默认 CDS 归档
344	实现	G1 可中止的混合收集
346	实现	G1 及时返回未使用的已提交内存

龙哥盟

掠夺·扩张·投机·博弈

Java11 和 12 新特性指南（全）

前言

本书面向对象

本书涵盖内容

为了充分利用这本书

下载示例代码文件

下载彩色图像

使用的约定

联系我们

评论

第一部分：JDK 10

第一章：类型推断

什么是类型推断？

使用var进行类型推断

强制非空初始化

局部变量

代码检查 – 第一部分

使用 var 与原始数据类型

派生类的类型推断

接口的类型推断

使用 var 与数组

泛型的类型推断

代码检查 – 第二部分

将推断变量传递给方法

重新分配推断变量的值

推断变量的显式转换

使用显式类型转换赋值 null

Java 先前版本中的类型推断

Java 5 中的类型推断

Java 7 中的类型推断

Java 8 中的类型推断

挑战

限制失败假设的范围

破坏现有代码

不可表示类型

有意义的变量名

代码重构

类型推断与动态绑定

摘要

第二章：AppCDS

技术要求

什么是 CDS？

共享归档文件的存放位置

手动创建 classes.jsa

CDS 的使用

AppCDS

AppCDS 的好处

启用应用程序类数据存档

哪些应用程序类需要存档

创建应用程序共享归档文件

使用共享应用程序归档文件

摘要

第三章：垃圾收集器优化

技术要求

GC 接口

利益

驱动因素

影响

G1 的并行完全 GC（JEP 307）

G1 GC 的设计目标

G1 内存

示例代码

理解 G1 GC 日志

摘要

第四章：JDK 10 的其他改进

技术要求

将 JDK 10 功能与范围和 JEP 关联

将 JDK 森林合并为一个单一存储库

Thread-local handshakes

移除 Native-Header 生成工具（javah）

额外的 Unicode 语言标签扩展

在替代内存设备上的堆分配

实验性的基于 Java 的 JIT 编译器

根证书

基于时间的发布版本控制

摘要

第二部分：JDK 11

使用`var`进行类型推断

使用 `var` 与原始数据类型

使用 `var` 与数组

`HttpClient` 类

基于巢的控制的影响