合并 Java -11 版本

core-java-modules/core-java-11/README.md

@@ -14,4 +14,11 @@ This module contains articles about Java 11 core features
 - [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
 - [Benchmark JDK Collections vs Eclipse Collections](https://www.baeldung.com/jdk-collections-vs-eclipse-collections)
 - [Pre-compile Regex Patterns Into Pattern Objects](https://www.baeldung.com/java-regex-pre-compile)
+- [Guide to Java Reflection](http://www.baeldung.com/java-reflection)
+- [Guide to Java 8’s Collectors](https://www.baeldung.com/java-8-collectors)
+- [New Features in Java 11](https://www.baeldung.com/java-11-new-features)
+- [Getting the Java Version at Runtime](https://www.baeldung.com/get-java-version-runtime)
+- [Invoking a SOAP Web Service in Java](https://www.baeldung.com/java-soap-web-service)
+- [Java HTTPS Client Certificate Authentication](https://www.baeldung.com/java-https-client-certificate-authentication)
+- [Call Methods at Runtime Using Java Reflection](https://www.baeldung.com/java-method-reflection)
 

core-java-modules/core-java-11/src/main/java/com/ossez/features/MainClass.java

@@ -0,0 +1,17 @@
+package com.ossez.features;
+
+public class MainClass {
+
+    private static boolean mainPrivateMethod() {
+        return true;
+    }
+
+    public static class NestedClass {
+
+        boolean nestedPublicMethod() {
+            return mainPrivateMethod();
+        }
+
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/httpsclientauthentication/SSLScocketClient.java

@@ -0,0 +1,41 @@
+package com.ossez.httpsclientauthentication;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javax.net.SocketFactory;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+
+public class SSLScocketClient {
+
+    static void startClient(String host, int port) throws IOException {
+
+        SocketFactory factory = SSLSocketFactory.getDefault();
+
+        try (SSLSocket socket = (SSLSocket) factory.createSocket(host, port)) {
+            socket.setEnabledCipherSuites(new String[] { "TLS_AES_128_GCM_SHA256" });
+            socket.setEnabledProtocols(new String[] { "TLSv1.3" });
+            InputStream is = new BufferedInputStream(socket.getInputStream());
+            String message = "Hello World Message";
+            System.out.println("sending message: " + message);
+            OutputStream os = new BufferedOutputStream(socket.getOutputStream());
+            os.write(message.getBytes());
+            os.flush();
+            byte[] data = new byte[2048];
+            int len = is.read(data);
+            if (len <= 0) {
+                throw new IOException("no data received");
+            }
+            System.out.printf("client received %d bytes: %s%n", len, new String(data, 0, len));
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+
+        startClient("localhost", 8443);
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/httpsclientauthentication/SSLSocketEchoServer.java

@@ -0,0 +1,46 @@
+package com.ossez.httpsclientauthentication;
+
+import java.io.BufferedInputStream;
+import java.io.BufferedOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import javax.net.ServerSocketFactory;
+import javax.net.ssl.SSLServerSocket;
+import javax.net.ssl.SSLServerSocketFactory;
+
+public class SSLSocketEchoServer {
+
+    static void startServer(int port) throws IOException {
+
+        ServerSocketFactory factory = SSLServerSocketFactory.getDefault();
+
+        try (SSLServerSocket listener = (SSLServerSocket) factory.createServerSocket(port)) {
+            listener.setNeedClientAuth(true);
+            listener.setEnabledCipherSuites(new String[] { "TLS_AES_128_GCM_SHA256" });
+            listener.setEnabledProtocols(new String[] { "TLSv1.3" });
+            System.out.println("listening for messages...");
+            try (Socket socket = listener.accept()) {
+                InputStream is = new BufferedInputStream(socket.getInputStream());
+                OutputStream os = new BufferedOutputStream(socket.getOutputStream());
+                byte[] data = new byte[2048];
+                int len = is.read(data);
+                if (len <= 0) {
+                    throw new IOException("no data received");
+                }
+                String message = new String(data, 0, len);
+                System.out.printf("server received %d bytes: %s%n", len, message);
+                String response = message + " processed by server";
+                os.write(response.getBytes(), 0, response.getBytes().length);
+                os.flush();
+            }
+            System.out.println("message processed, exiting");
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        startServer(8443);
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/optional/Modem.java

@@ -0,0 +1,13 @@
+package com.ossez.optional;
+
+public class Modem {
+    private Double price;
+
+    public Modem(Double price) {
+        this.price = price;
+    }
+
+    public Double getPrice() {
+        return price;
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/optional/Person.java

@@ -0,0 +1,74 @@
+package com.ossez.optional;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+public class Person {
+    private String name;
+    private int age;
+    private String password;
+
+    public Person(String name, int age) {
+        this.name = name;
+        this.age = age;
+    }
+
+    public Optional<String> getName() {
+        return Optional.ofNullable(name);
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Optional<Integer> getAge() {
+        return Optional.of(age);
+    }
+
+    public void setAge(int age) {
+        this.age = age;
+    }
+
+    public void setPassword(String password) {
+        this.password = password;
+    }
+
+    public Optional<String> getPassword() {
+        return Optional.ofNullable(password);
+    }
+
+    public static List<Person> search(List<Person> people, String name, Optional<Integer> age) {
+        // Null checks for people and name
+        return people.stream()
+                .filter(p -> p.getName().equals(name))
+                .filter(p -> p.getAge().get() >= age.orElse(0))
+                .collect(Collectors.toList());
+    }
+
+    public static List<Person> search(List<Person> people, String name, Integer age) {
+        // Null checks for people and name
+        final Integer ageFilter = age != null ? age : 0;
+
+        return people.stream()
+                .filter(p -> p.getName().equals(name))
+                .filter(p -> p.getAge().get() >= ageFilter)
+                .collect(Collectors.toList());
+    }
+
+    public static List<Person> search(List<Person> people, String name) {
+        return doSearch(people, name, 0);
+    }
+
+    public static List<Person> search(List<Person> people, String name, int age) {
+        return doSearch(people, name, age);
+    }
+
+    private static List<Person> doSearch(List<Person> people, String name, int age) {
+        // Null checks for people and name
+        return people.stream()
+                .filter(p -> p.getName().equals(name))
+                .filter(p -> p.getAge().get().intValue() >= age)
+                .collect(Collectors.toList());
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Animal.java

@@ -0,0 +1,23 @@
+package com.ossez.reflection;
+
+public abstract class Animal implements Eating {
+
+    public static final String CATEGORY = "domestic";
+
+    private String name;
+
+    public Animal(String name) {
+        this.name = name;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    protected abstract String getSound();
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Bird.java

@@ -0,0 +1,36 @@
+package com.ossez.reflection;
+
+public class Bird extends Animal {
+    private boolean walks;
+
+    public Bird() {
+        super("bird");
+    }
+
+    public Bird(String name, boolean walks) {
+        super(name);
+        setWalks(walks);
+    }
+
+    public Bird(String name) {
+        super(name);
+    }
+
+    @Override
+    public String eats() {
+        return "grains";
+    }
+
+    @Override
+    protected String getSound() {
+        return "chaps";
+    }
+
+    public boolean walks() {
+        return walks;
+    }
+
+    public void setWalks(boolean walks) {
+        this.walks = walks;
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/DynamicGreeter.java

@@ -0,0 +1,23 @@
+package com.ossez.reflection;
+
+import java.lang.annotation.Annotation;
+
+public class DynamicGreeter implements Greeter {
+    
+    private String greet;
+
+    public DynamicGreeter(String greet) {
+        this.greet = greet;
+    }
+
+    @Override
+    public Class<? extends Annotation> annotationType() {
+        return DynamicGreeter.class;
+    }
+
+    @Override
+    public String greet() {
+        return greet;
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Eating.java

@@ -0,0 +1,5 @@
+package com.ossez.reflection;
+
+public interface Eating {
+    String eats();
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Goat.java

@@ -0,0 +1,24 @@
+package com.ossez.reflection;
+
+public class Goat extends Animal implements Locomotion {
+
+    public Goat(String name) {
+        super(name);
+    }
+
+    @Override
+    protected String getSound() {
+        return "bleat";
+    }
+
+    @Override
+    public String getLocomotion() {
+        return "walks";
+    }
+
+    @Override
+    public String eats() {
+        return "grass";
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Greeter.java

@@ -0,0 +1,10 @@
+package com.ossez.reflection;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Greeter {
+
+    public String greet() default "";
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/GreetingAnnotation.java

@@ -0,0 +1,58 @@
+package com.ossez.reflection;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Map;
+
+public class GreetingAnnotation {
+   
+    private static final String ANNOTATION_METHOD = "annotationData";
+    private static final String ANNOTATION_FIELDS = "declaredAnnotations";
+    private static final String ANNOTATIONS = "annotations";
+
+    public static void main(String ...args) {
+        Greeter greetings = Greetings.class.getAnnotation(Greeter.class);
+        System.err.println("Hello there, " + greetings.greet() + " !!");
+
+        Greeter targetValue = new DynamicGreeter("Good evening");
+        //alterAnnotationValueJDK8(Greetings.class, Greeter.class, targetValue);
+        alterAnnotationValueJDK7(Greetings.class, Greeter.class, targetValue);
+        
+        greetings = Greetings.class.getAnnotation(Greeter.class);
+        System.err.println("Hello there, " + greetings.greet() + " !!");
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void alterAnnotationValueJDK8(Class<?> targetClass, Class<? extends Annotation> targetAnnotation, Annotation targetValue) {
+        try {
+            Method method = Class.class.getDeclaredMethod(ANNOTATION_METHOD, null);
+            method.setAccessible(true);
+
+            Object annotationData = method.invoke(targetClass);
+            
+            Field annotations = annotationData.getClass().getDeclaredField(ANNOTATIONS);
+            annotations.setAccessible(true);
+
+            Map<Class<? extends Annotation>, Annotation> map = (Map<Class<? extends Annotation>, Annotation>) annotations.get(annotationData);
+            map.put(targetAnnotation, targetValue);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    @SuppressWarnings("unchecked")
+    public static void alterAnnotationValueJDK7(Class<?> targetClass, Class<? extends Annotation> targetAnnotation, Annotation targetValue) {
+        try {            
+            Field annotations = Class.class.getDeclaredField(ANNOTATIONS);
+            annotations.setAccessible(true);
+
+            Map<Class<? extends Annotation>, Annotation> map = (Map<Class<? extends Annotation>, Annotation>) annotations.get(targetClass);
+            System.out.println(map);
+            map.put(targetAnnotation, targetValue);
+            System.out.println(map);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Greetings.java

@@ -0,0 +1,6 @@
+package com.ossez.reflection;
+
+@Greeter(greet="Good morning")
+public class Greetings {
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Locomotion.java

@@ -0,0 +1,5 @@
+package com.ossez.reflection;
+
+public interface Locomotion {
+    String getLocomotion();
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Operations.java

@@ -0,0 +1,21 @@
+package com.ossez.reflection;
+
+public class Operations {
+
+    public double publicSum(int a, double b) {
+        return a + b;
+    }
+
+    public static double publicStaticMultiply(float a, long b) {
+        return a * b;
+    }
+
+    private boolean privateAnd(boolean a, boolean b) {
+        return a && b;
+    }
+
+    protected int protectedMax(int a, int b) {
+        return a > b ? a : b;
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/reflection/Person.java

@@ -0,0 +1,6 @@
+package com.ossez.reflection;
+
+public class Person {
+    private String name;
+    private int age;
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/client/generated/Country.java

@@ -0,0 +1,135 @@
+
+package com.ossez.ws.client.generated;
+
+import jakarta.xml.bind.annotation.XmlAccessType;
+import jakarta.xml.bind.annotation.XmlAccessorType;
+import jakarta.xml.bind.annotation.XmlSchemaType;
+import jakarta.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Java class for country complex type.
+ * 
+ * <p>The following schema fragment specifies the expected content contained within this class.
+ * 
+ * <pre>
+ * &lt;complexType name="country"&gt;
+ *   &lt;complexContent&gt;
+ *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType"&gt;
+ *       &lt;sequence&gt;
+ *         &lt;element name="capital" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/&gt;
+ *         &lt;element name="currency" type="{http://server.ws.soap.baeldung.com/}currency" minOccurs="0"/&gt;
+ *         &lt;element name="name" type="{http://www.w3.org/2001/XMLSchema}string" minOccurs="0"/&gt;
+ *         &lt;element name="population" type="{http://www.w3.org/2001/XMLSchema}int"/&gt;
+ *       &lt;/sequence&gt;
+ *     &lt;/restriction&gt;
+ *   &lt;/complexContent&gt;
+ * &lt;/complexType&gt;
+ * </pre>
+ * 
+ * 
+ */
+@XmlAccessorType(XmlAccessType.FIELD)
+@XmlType(name = "country", propOrder = {
+    "capital",
+    "currency",
+    "name",
+    "population"
+})
+public class Country {
+
+    protected String capital;
+    @XmlSchemaType(name = "string")
+    protected Currency currency;
+    protected String name;
+    protected int population;
+
+    /**
+     * Gets the value of the capital property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getCapital() {
+        return capital;
+    }
+
+    /**
+     * Sets the value of the capital property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setCapital(String value) {
+        this.capital = value;
+    }
+
+    /**
+     * Gets the value of the currency property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link Currency }
+     *     
+     */
+    public Currency getCurrency() {
+        return currency;
+    }
+
+    /**
+     * Sets the value of the currency property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link Currency }
+     *     
+     */
+    public void setCurrency(Currency value) {
+        this.currency = value;
+    }
+
+    /**
+     * Gets the value of the name property.
+     * 
+     * @return
+     *     possible object is
+     *     {@link String }
+     *     
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Sets the value of the name property.
+     * 
+     * @param value
+     *     allowed object is
+     *     {@link String }
+     *     
+     */
+    public void setName(String value) {
+        this.name = value;
+    }
+
+    /**
+     * Gets the value of the population property.
+     * 
+     */
+    public int getPopulation() {
+        return population;
+    }
+
+    /**
+     * Sets the value of the population property.
+     * 
+     */
+    public void setPopulation(int value) {
+        this.population = value;
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/client/generated/CountryService.java

@@ -0,0 +1,40 @@
+
+package com.ossez.ws.client.generated;
+
+import jakarta.jws.WebMethod;
+import jakarta.jws.WebParam;
+import jakarta.jws.WebResult;
+import jakarta.jws.WebService;
+import jakarta.jws.soap.SOAPBinding;
+import jakarta.xml.bind.annotation.XmlSeeAlso;
+import jakarta.xml.ws.Action;
+
+
+/**
+ * This class was generated by the JAX-WS RI.
+ * JAX-WS RI 3.0.2
+ * Generated source version: 3.0
+ * 
+ */
+@WebService(name = "CountryService", targetNamespace = "http://server.ws.soap.baeldung.com/")
+@SOAPBinding(style = SOAPBinding.Style.RPC)
+@XmlSeeAlso({
+    ObjectFactory.class
+})
+public interface CountryService {
+
+
+    /**
+     * 
+     * @param arg0
+     * @return
+     *     returns Country
+     */
+    @WebMethod
+    @WebResult(partName = "return")
+    @Action(input = "http://server.ws.soap.baeldung.com/CountryService/findByNameRequest", output = "http://server.ws.soap.baeldung.com/CountryService/findByNameResponse")
+    public Country findByName(
+        @WebParam(name = "arg0", partName = "arg0")
+        String arg0);
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/client/generated/CountryServiceImplService.java

@@ -0,0 +1,94 @@
+
+package com.ossez.ws.client.generated;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import javax.xml.namespace.QName;
+import jakarta.xml.ws.Service;
+import jakarta.xml.ws.WebEndpoint;
+import jakarta.xml.ws.WebServiceClient;
+import jakarta.xml.ws.WebServiceException;
+import jakarta.xml.ws.WebServiceFeature;
+
+
+/**
+ * This class was generated by the JAX-WS RI.
+ * JAX-WS RI 3.0.2
+ * Generated source version: 3.0
+ * 
+ */
+@WebServiceClient(name = "CountryServiceImplService", targetNamespace = "http://server.ws.soap.baeldung.com/", wsdlLocation = "http://localhost:8888/ws/country?wsdl")
+public class CountryServiceImplService
+    extends Service
+{
+
+    private final static URL COUNTRYSERVICEIMPLSERVICE_WSDL_LOCATION;
+    private final static WebServiceException COUNTRYSERVICEIMPLSERVICE_EXCEPTION;
+    private final static QName COUNTRYSERVICEIMPLSERVICE_QNAME = new QName("http://server.ws.soap.baeldung.com/", "CountryServiceImplService");
+
+    static {
+        URL url = null;
+        WebServiceException e = null;
+        try {
+            url = new URL("http://localhost:8888/ws/country?wsdl");
+        } catch (MalformedURLException ex) {
+            e = new WebServiceException(ex);
+        }
+        COUNTRYSERVICEIMPLSERVICE_WSDL_LOCATION = url;
+        COUNTRYSERVICEIMPLSERVICE_EXCEPTION = e;
+    }
+
+    public CountryServiceImplService() {
+        super(__getWsdlLocation(), COUNTRYSERVICEIMPLSERVICE_QNAME);
+    }
+
+    public CountryServiceImplService(WebServiceFeature... features) {
+        super(__getWsdlLocation(), COUNTRYSERVICEIMPLSERVICE_QNAME, features);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation) {
+        super(wsdlLocation, COUNTRYSERVICEIMPLSERVICE_QNAME);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation, WebServiceFeature... features) {
+        super(wsdlLocation, COUNTRYSERVICEIMPLSERVICE_QNAME, features);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation, QName serviceName) {
+        super(wsdlLocation, serviceName);
+    }
+
+    public CountryServiceImplService(URL wsdlLocation, QName serviceName, WebServiceFeature... features) {
+        super(wsdlLocation, serviceName, features);
+    }
+
+    /**
+     * 
+     * @return
+     *     returns CountryService
+     */
+    @WebEndpoint(name = "CountryServiceImplPort")
+    public CountryService getCountryServiceImplPort() {
+        return super.getPort(new QName("http://server.ws.soap.baeldung.com/", "CountryServiceImplPort"), CountryService.class);
+    }
+
+    /**
+     * 
+     * @param features
+     *     A list of {@link jakarta.xml.ws.WebServiceFeature} to configure on the proxy.  Supported features not in the <code>features</code> parameter will have their default values.
+     * @return
+     *     returns CountryService
+     */
+    @WebEndpoint(name = "CountryServiceImplPort")
+    public CountryService getCountryServiceImplPort(WebServiceFeature... features) {
+        return super.getPort(new QName("http://server.ws.soap.baeldung.com/", "CountryServiceImplPort"), CountryService.class, features);
+    }
+
+    private static URL __getWsdlLocation() {
+        if (COUNTRYSERVICEIMPLSERVICE_EXCEPTION!= null) {
+            throw COUNTRYSERVICEIMPLSERVICE_EXCEPTION;
+        }
+        return COUNTRYSERVICEIMPLSERVICE_WSDL_LOCATION;
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/client/generated/Currency.java

@@ -0,0 +1,39 @@
+
+package com.ossez.ws.client.generated;
+
+import jakarta.xml.bind.annotation.XmlEnum;
+import jakarta.xml.bind.annotation.XmlType;
+
+
+/**
+ * <p>Java class for currency.
+ * 
+ * <p>The following schema fragment specifies the expected content contained within this class.
+ * <pre>
+ * &lt;simpleType name="currency"&gt;
+ *   &lt;restriction base="{http://www.w3.org/2001/XMLSchema}string"&gt;
+ *     &lt;enumeration value="EUR"/&gt;
+ *     &lt;enumeration value="INR"/&gt;
+ *     &lt;enumeration value="USD"/&gt;
+ *   &lt;/restriction&gt;
+ * &lt;/simpleType&gt;
+ * </pre>
+ * 
+ */
+@XmlType(name = "currency")
+@XmlEnum
+public enum Currency {
+
+    EUR,
+    INR,
+    USD;
+
+    public String value() {
+        return name();
+    }
+
+    public static Currency fromValue(String v) {
+        return valueOf(v);
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/client/generated/ObjectFactory.java

@@ -0,0 +1,40 @@
+
+package com.ossez.ws.client.generated;
+
+import jakarta.xml.bind.annotation.XmlRegistry;
+
+
+/**
+ * This object contains factory methods for each 
+ * Java content interface and Java element interface 
+ * generated in the com.baeldung.soap.ws.client.generated package. 
+ * <p>An ObjectFactory allows you to programatically 
+ * construct new instances of the Java representation 
+ * for XML content. The Java representation of XML 
+ * content can consist of schema derived interfaces 
+ * and classes representing the binding of schema 
+ * type definitions, element declarations and model 
+ * groups.  Factory methods for each of these are 
+ * provided in this class.
+ * 
+ */
+@XmlRegistry
+public class ObjectFactory {
+
+
+    /**
+     * Create a new ObjectFactory that can be used to create new instances of schema derived classes for package: com.baeldung.soap.ws.client.generated
+     * 
+     */
+    public ObjectFactory() {
+    }
+
+    /**
+     * Create an instance of {@link Country }
+     * 
+     */
+    public Country createCountry() {
+        return new Country();
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/client/generated/package-info.java

@@ -0,0 +1,2 @@
+@jakarta.xml.bind.annotation.XmlSchema(namespace = "http://server.ws.soap.baeldung.com/")
+package com.ossez.ws.client.generated;

core-java-modules/core-java-11/src/main/java/com/ossez/ws/server/Country.java

@@ -0,0 +1,41 @@
+package com.ossez.ws.server;
+
+public class Country {
+    protected String name;
+    protected int population;
+    protected String capital;
+    protected Currency currency;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public int getPopulation() {
+        return population;
+    }
+
+    public void setPopulation(int population) {
+        this.population = population;
+    }
+
+    public String getCapital() {
+        return capital;
+    }
+
+    public void setCapital(String capital) {
+        this.capital = capital;
+    }
+
+    public Currency getCurrency() {
+        return currency;
+    }
+
+    public void setCurrency(Currency currency) {
+        this.currency = currency;
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/server/CountryRepository.java

@@ -0,0 +1,43 @@
+package com.ossez.ws.server;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CountryRepository {
+
+    private static final Map<String, Country> countries = new HashMap<>();
+
+    {
+        initData();
+    }
+
+    private final static void initData() {
+        Country usa = new Country();
+        usa.setName("USA");
+        usa.setCapital("Washington D.C.");
+        usa.setCurrency(Currency.USD);
+        usa.setPopulation(323947000);
+
+        countries.put(usa.getName(), usa);
+
+        Country india = new Country();
+        india.setName("India");
+        india.setCapital("New Delhi");
+        india.setCurrency(Currency.INR);
+        india.setPopulation(1295210000);
+
+        countries.put(india.getName(), india);
+
+        Country france = new Country();
+        france.setName("France");
+        france.setCapital("Paris");
+        france.setCurrency(Currency.EUR);
+        france.setPopulation(66710000);
+
+        countries.put(france.getName(), france);
+    }
+
+    public Country findCountry(String name) {
+        return countries.get(name);
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/server/CountryService.java

@@ -0,0 +1,15 @@
+package com.ossez.ws.server;
+
+import jakarta.jws.WebMethod;
+import jakarta.jws.WebService;
+import jakarta.jws.soap.SOAPBinding;
+import jakarta.jws.soap.SOAPBinding.Style;
+
+@WebService
+@SOAPBinding(style=Style.RPC)
+public interface CountryService {
+    
+    @WebMethod
+    Country findByName(String name);
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/server/CountryServiceImpl.java

@@ -0,0 +1,15 @@
+package com.ossez.ws.server;
+
+import jakarta.jws.WebService;
+
+@WebService(endpointInterface = "com.ossez.ws.server.CountryService")
+public class CountryServiceImpl implements CountryService {
+
+    private CountryRepository countryRepository = new CountryRepository();
+
+    @Override
+    public Country findByName(String name) {
+        return countryRepository.findCountry(name);
+    }
+
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/server/CountryServicePublisher.java

@@ -0,0 +1,19 @@
+package com.ossez.ws.server;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import jakarta.xml.ws.Endpoint;
+
+
+public class CountryServicePublisher {
+    
+    private static final Logger logger = LoggerFactory.getLogger(CountryServicePublisher.class);
+    
+    public static void main(String[] args) {
+        Endpoint endpoint = Endpoint.create(new CountryServiceImpl());
+        endpoint.publish("http://localhost:8888/ws/country");
+        
+        logger.info("Country web service ready to consume requests!");
+    }
+}

core-java-modules/core-java-11/src/main/java/com/ossez/ws/server/Currency.java

@@ -0,0 +1,15 @@
+package com.ossez.ws.server;
+
+public enum Currency {
+
+    EUR, INR, USD;
+
+    public String value() {
+        return name();
+    }
+
+    public static Currency fromValue(String v) {
+        return valueOf(v);
+    }
+
+}

core-java-modules/core-java-11/src/test/java/com/ossez/collectors/Java8CollectorsUnitTest.java

@@ -0,0 +1,237 @@
+package com.ossez.collectors;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Sets;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+
+import static com.google.common.collect.Sets.newHashSet;
+import static java.util.stream.Collectors.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class Java8CollectorsUnitTest {
+
+    private final List<String> givenList = Arrays.asList("a", "bb", "ccc", "dd");
+    private final List<String> listWithDuplicates = Arrays.asList("a", "bb", "c", "d", "bb");
+
+    @Test
+    public void whenCollectingToList_shouldCollectToList() throws Exception {
+        final List<String> result = givenList.stream().collect(toList());
+
+        assertThat(result).containsAll(givenList);
+    }
+
+    @Test
+    public void whenCollectingToUnmodifiableList_shouldCollectToUnmodifiableList() {
+        final List<String> result = givenList.stream().collect(toUnmodifiableList());
+
+        assertThatThrownBy(() -> result.add("foo"))
+          .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    @Test
+    public void whenCollectingToSet_shouldCollectToSet() throws Exception {
+        final Set<String> result = givenList.stream().collect(toSet());
+
+        assertThat(result).containsAll(givenList);
+    }
+
+    @Test
+    public void whenCollectingToUnmodifiableSet_shouldCollectToUnmodifiableSet() {
+        final Set<String> result = givenList.stream().collect(toUnmodifiableSet());
+
+        assertThatThrownBy(() -> result.add("foo"))
+          .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    @Test
+    public void givenContainsDuplicateElements_whenCollectingToSet_shouldAddDuplicateElementsOnlyOnce() throws Exception {
+        final Set<String> result = listWithDuplicates.stream().collect(toSet());
+
+        assertThat(result).hasSize(4);
+    }
+
+    @Test
+    public void whenCollectingToCollection_shouldCollectToCollection() throws Exception {
+        final List<String> result = givenList.stream().collect(toCollection(LinkedList::new));
+
+        assertThat(result).containsAll(givenList).isInstanceOf(LinkedList.class);
+    }
+
+    @Test
+    public void whenCollectingToImmutableCollection_shouldThrowException() throws Exception {
+        assertThatThrownBy(() -> {
+            givenList.stream().collect(toCollection(ImmutableList::of));
+        }).isInstanceOf(UnsupportedOperationException.class);
+
+    }
+
+    @Test
+    public void whenCollectingToMap_shouldCollectToMap() throws Exception {
+        final Map<String, Integer> result = givenList.stream().collect(toMap(Function.identity(), String::length));
+
+        assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("ccc", 3).containsEntry("dd", 2);
+    }
+
+    @Test
+    public void whenCollectingToUnmodifiableMap_shouldCollectToUnmodifiableMap() {
+        final Map<String, Integer> result = givenList.stream()
+          .collect(toUnmodifiableMap(Function.identity(), String::length));
+
+        assertThatThrownBy(() -> result.put("foo", 3))
+                .isInstanceOf(UnsupportedOperationException.class);
+    }
+
+    @Test
+    public void whenCollectingToMapwWithDuplicates_shouldCollectToMapMergingTheIdenticalItems() throws Exception {
+        final Map<String, Integer> result = listWithDuplicates.stream().collect(
+          toMap(
+            Function.identity(),
+            String::length,
+            (item, identicalItem) -> item
+          )
+        );
+
+        assertThat(result).containsEntry("a", 1).containsEntry("bb", 2).containsEntry("c", 1).containsEntry("d", 1);
+    }
+
+    @Test
+    public void givenContainsDuplicateElements_whenCollectingToMap_shouldThrowException() throws Exception {
+        assertThatThrownBy(() -> {
+            listWithDuplicates.stream().collect(toMap(Function.identity(), String::length));
+        }).isInstanceOf(IllegalStateException.class);
+    }
+
+    @Test
+    public void whenCollectingAndThen_shouldCollect() throws Exception {
+        final List<String> result = givenList.stream().collect(collectingAndThen(toList(), ImmutableList::copyOf));
+
+        assertThat(result).containsAll(givenList).isInstanceOf(ImmutableList.class);
+    }
+
+    @Test
+    public void whenJoining_shouldJoin() throws Exception {
+        final String result = givenList.stream().collect(joining());
+
+        assertThat(result).isEqualTo("abbcccdd");
+    }
+
+    @Test
+    public void whenJoiningWithSeparator_shouldJoinWithSeparator() throws Exception {
+        final String result = givenList.stream().collect(joining(" "));
+
+        assertThat(result).isEqualTo("a bb ccc dd");
+    }
+
+    @Test
+    public void whenJoiningWithSeparatorAndPrefixAndPostfix_shouldJoinWithSeparatorPrePost() throws Exception {
+        final String result = givenList.stream().collect(joining(" ", "PRE-", "-POST"));
+
+        assertThat(result).isEqualTo("PRE-a bb ccc dd-POST");
+    }
+
+    @Test
+    public void whenPartitioningBy_shouldPartition() throws Exception {
+        final Map<Boolean, List<String>> result = givenList.stream().collect(partitioningBy(s -> s.length() > 2));
+
+        assertThat(result).containsKeys(true, false).satisfies(booleanListMap -> {
+            assertThat(booleanListMap.get(true)).contains("ccc");
+
+            assertThat(booleanListMap.get(false)).contains("a", "bb", "dd");
+        });
+    }
+
+    @Test
+    public void whenCounting_shouldCount() throws Exception {
+        final Long result = givenList.stream().collect(counting());
+
+        assertThat(result).isEqualTo(4);
+    }
+
+    @Test
+    public void whenSummarizing_shouldSummarize() throws Exception {
+        final DoubleSummaryStatistics result = givenList.stream().collect(summarizingDouble(String::length));
+
+        assertThat(result.getAverage()).isEqualTo(2);
+        assertThat(result.getCount()).isEqualTo(4);
+        assertThat(result.getMax()).isEqualTo(3);
+        assertThat(result.getMin()).isEqualTo(1);
+        assertThat(result.getSum()).isEqualTo(8);
+    }
+
+    @Test
+    public void whenAveraging_shouldAverage() throws Exception {
+        final Double result = givenList.stream().collect(averagingDouble(String::length));
+
+        assertThat(result).isEqualTo(2);
+    }
+
+    @Test
+    public void whenSumming_shouldSum() throws Exception {
+        final Double result = givenList.stream().filter(i -> true).collect(summingDouble(String::length));
+
+        assertThat(result).isEqualTo(8);
+    }
+
+    @Test
+    public void whenMaxingBy_shouldMaxBy() throws Exception {
+        final Optional<String> result = givenList.stream().collect(maxBy(Comparator.naturalOrder()));
+
+        assertThat(result).isPresent().hasValue("dd");
+    }
+
+    @Test
+    public void whenGroupingBy_shouldGroupBy() throws Exception {
+        final Map<Integer, Set<String>> result = givenList.stream().collect(groupingBy(String::length, toSet()));
+
+        assertThat(result).containsEntry(1, newHashSet("a")).containsEntry(2, newHashSet("bb", "dd")).containsEntry(3, newHashSet("ccc"));
+    }
+
+    @Test
+    public void whenCreatingCustomCollector_shouldCollect() throws Exception {
+        final ImmutableSet<String> result = givenList.stream().collect(toImmutableSet());
+
+        assertThat(result).isInstanceOf(ImmutableSet.class).contains("a", "bb", "ccc", "dd");
+
+    }
+
+    private static <T> ImmutableSetCollector<T> toImmutableSet() {
+        return new ImmutableSetCollector<>();
+    }
+
+    private static class ImmutableSetCollector<T> implements Collector<T, ImmutableSet.Builder<T>, ImmutableSet<T>> {
+
+        @Override
+        public Supplier<ImmutableSet.Builder<T>> supplier() {
+            return ImmutableSet::builder;
+        }
+
+        @Override
+        public BiConsumer<ImmutableSet.Builder<T>, T> accumulator() {
+            return ImmutableSet.Builder::add;
+        }
+
+        @Override
+        public BinaryOperator<ImmutableSet.Builder<T>> combiner() {
+            return (left, right) -> left.addAll(right.build());
+        }
+
+        @Override
+        public Function<ImmutableSet.Builder<T>, ImmutableSet<T>> finisher() {
+            return ImmutableSet.Builder::build;
+        }
+
+        @Override
+        public Set<Characteristics> characteristics() {
+            return Sets.immutableEnumSet(Characteristics.UNORDERED);
+        }
+    }
+}