jdk 23 features

Author: saurabh.kumar

JavaCon/Java25Features/src/main/java/com/saurabh/java/MarkdownDoc.java

@@ -0,0 +1,69 @@
+package com.saurabh.java;
+
+public class MarkdownDoc {
+
+    /// Returns a hash code value for the object. This method is
+    /// supported for the benefit of hash tables such as those provided by
+    /// [java.util.HashMap].
+    ///
+    /// The general contract of `hashCode` is:
+    ///
+    ///   - Whenever it is invoked on the same object more than once during
+    ///     an execution of a Java application, the `hashCode` method
+    ///     must consistently return the same integer, provided no information
+    ///     used in `equals` comparisons on the object is modified.
+    ///     This integer need not remain consistent from one execution of an
+    ///     application to another execution of the same application.
+    ///   - If two objects are equal according to the
+    ///     [equals][#equals(Object)] method, then calling the
+    ///     `hashCode` method on each of the two objects must produce the
+    ///     same integer result.
+    ///   - It is _not_ required that if two objects are unequal
+    ///     according to the [equals][#equals(Object)] method, then
+    ///     calling the `hashCode` method on each of the two objects
+    ///     must produce distinct integer results.  However, the programmer
+    ///     should be aware that producing distinct integer results for
+    ///     unequal objects may improve the performance of hash tables.
+    ///
+    /// @return a hash code value for this object.
+    /// @implSpec As far as is reasonably practical, the `hashCode` method defined
+    /// by class `Object` returns distinct integers for distinct objects.
+    /// @see java.lang.Object#equals(java.lang.Object)
+    /// @see java.lang.System#identityHashCode
+    void md() {
+    }
+
+    /**
+     * Returns a hash code value for the object. This method is
+     * supported for the benefit of hash tables such as those provided by
+     * {@link java.util.HashMap}.
+     * <p>
+     * The general contract of {@code hashCode} is:
+     * <ul>
+     * <li>Whenever it is invoked on the same object more than once during
+     *     an execution of a Java application, the {@code hashCode} method
+     *     must consistently return the same integer, provided no information
+     *     used in {@code equals} comparisons on the object is modified.
+     *     This integer need not remain consistent from one execution of an
+     *     application to another execution of the same application.
+     * <li>If two objects are equal according to the {@link
+     *     #equals(Object) equals} method, then calling the {@code
+     *     hashCode} method on each of the two objects must produce the
+     *     same integer result.
+     * <li>It is <em>not</em> required that if two objects are unequal
+     *     according to the {@link #equals(Object) equals} method, then
+     *     calling the {@code hashCode} method on each of the two objects
+     *     must produce distinct integer results.  However, the programmer
+     *     should be aware that producing distinct integer results for
+     *     unequal objects may improve the performance of hash tables.
+     * </ul>
+     *
+     * @return a hash code value for this object.
+     * @implSpec As far as is reasonably practical, the {@code hashCode} method defined
+     * by class {@code Object} returns distinct integers for distinct objects.
+     * @see java.lang.Object#equals(java.lang.Object)
+     * @see java.lang.System#identityHashCode
+     */
+    void javadoc() {
+    }
+}

JavaCon/Java25Features/src/main/java/com/saurabh/java/ModuleImport.java

@@ -0,0 +1,13 @@
+package com.saurabh.java;
+
+import static java.io.IO.*;
+import module java.base;
+
+class ModuleImport {
+    void main() {
+        final var authors = List.of("James", "Bill", "Guy", "Alex", "Dan", "Gavin");
+        for (var name : authors) {
+            println(name + ": " + name.length());
+        }
+    }
+}

JavaCon/Java25Features/src/main/java/com/saurabh/java/StreamGatherers22.java

@@ -0,0 +1,75 @@
+package com.saurabh.java;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.Arrays;
+import java.util.stream.Gatherers;
+import java.util.stream.Stream;
+
+import static java.util.Arrays.asList;
+
+/**
+ * https://cr.openjdk.org/~vklang/Gatherers.html
+ * https://www.infoworld.com/article/2510405/stream-gatherers-a-new-way-to-manipulate-java-streams-2.html
+ */
+@SuppressWarnings({"java:S3655", "java:S2629", "all"})
+public class StreamGatherers22 {
+
+    private static final Logger LOG = LoggerFactory.getLogger(StreamGatherers22.class);
+
+    public static void main(String[] args) {
+
+        final var numbers = asList(1, 2, 3, 4, 5, 6);
+        LOG.info("{}", Arrays.toString(numbers.stream().filter(number -> number % 2 == 0).toArray())); // result: { 2, 4, 6 }
+
+        // windowFixed method is a simpler way to gather your windowed elements into buckets
+        LOG.info(
+            "\nGather WindowFixed\n{}", Stream.iterate(0, i -> i + 1)
+                .gather(Gatherers.windowFixed(2))
+                .limit(5)
+                .toList()
+        );
+
+        // Scan is something like windowFixed but it accumulates the elements into a single element instead of an array
+        LOG.info(
+            "\nGather Scan\n{}", Stream.of(1, 2, 3, 4, 5, 6, 7, 8, 9)
+                .gather(
+                    Gatherers.scan(() -> "", (string, number) -> string + number)
+                )
+                .toList()
+        );
+
+        //  windowSliding works like windowFixed() except each window starts on the next element in the source array
+        LOG.info(
+            "\nGather WindowSliding\n{}", Stream.iterate(0, i -> i + 1)
+                .gather(Gatherers.windowSliding(2))
+                .limit(5)
+                .toList()
+        );
+
+        // Folding is a generalization of reduction. With reduction, the result type is the same as the element type, the combiner is associative,
+        // and the initial value is an identity for the combiner. For a fold, these conditions are not required, though we give up parallelizability.
+        LOG.info(
+            "\nGather fold\n{}\nStream Reduce\n{}", Stream.of("hello", "world", "how", "are", "you?")
+                .gather(
+                    Gatherers.fold(
+                        () -> "",
+                        (acc, element) -> acc.isEmpty() ? element : acc + "," + element
+                    )
+                )
+                .findFirst()
+                .orElseThrow(),
+            Stream.of("hello", "world", "how", "are", "you?")
+                .reduce("", (acc, element) -> acc.isEmpty() ? element : acc + "," + element)
+        );
+
+        //  mapConcurrent can specify a maximum number of threads to use concurrently in running the map function provided. Virtual threads will be used.
+        LOG.info(
+            "\nGather MapConcurrent\n{}", Stream.of(1, 2, 3, 4, 5)
+                .gather(Gatherers.mapConcurrent(4, x -> x * x)).toList()
+        );
+
+    }
+
+}