ブログ

public class RecordPattern
{
    public static void main(String[] args)
    {
        Object obj = new String("Hello World");
        if(obj instanceof String str)
        {
            System.out.println(str);
        }
        else
        {
            System.out.println("It's not a instance of String");
        }
    }
}

import java.lang.foreign.Linker;
import java.lang.foreign.FunctionDescriptor;
import java.lang.foreign.MemorySegment;
import java.lang.foreign.MemorySession;
import java.lang.foreign.SegmentAllocator;
import java.lang.foreign.SymbolLookup;
import java.lang.foreign.ValueLayout;
import java.lang.invoke.MethodHandle;

public class ForeignFunction
{
    public static void main(String[] args) throws Throwable
    {
        Linker linker = Linker.nativeLinker();
        SymbolLookup stdlib = linker.defaultLookup();
        FunctionDescriptor functionDescriptor = FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS);
        MethodHandle strlen = linker.downcallHandle(stdlib.lookup("strlen").get(), functionDescriptor);
        String javaStrings   = "Hello from Java 19";
        long len = -1L;
        try(MemorySession session = MemorySession.openConfined())
        {
            MemorySegment cString = MemorySegment.allocateNative(javaStrings.length() + 1, session);
            cString.setUtf8String(0, javaStrings);
            len = (long)strlen.invoke(cString);
        }
        System.out.printf("strlen()=%d\n", len);
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.stream.IntStream;

public class VirtualTrhead
{
    public static void main(String[] args) throws Exception
    {
        try(ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor())
        {
            IntStream.range(0, 10).forEach(i -> { executor.submit(new ExampleTask(i)); });
        }
    }
    static class ExampleTask implements Callable<Integer>
    {
        private int number;
        public ExampleTask(int arg)
        {
            number = arg;
        }
        @Override
        public Integer call() throws Exception
        {
            IntStream.range(0, 10).forEach(i -> System.out.printf("Hello %d\n", number));
            return number;
        }
    }
}

import java.util.Arrays;
import jdk.incubator.vector.DoubleVector;
import jdk.incubator.vector.VectorMask;
import jdk.incubator.vector.VectorSpecies;

public class VectorAPI
{
    private static final VectorSpecies<Double> SPECIES = DoubleVector.SPECIES_PREFERRED;
    public static void main(String[] args)
    {
        VectorAPI instance = new VectorAPI();
        double[] array = new double[] { 1.0d, 2.0d, 3.0d };
        double[] result = new double[array.length];
        instance.calculate_by_vector(array, array, result);
        Arrays.stream(result).forEach(f -> System.out.print(f));
    }
    private void calculate_by_vector(double[] array1, double[] array2, double[] result)
    {
        for(int i = 0; i < array1.length; i+= SPECIES.length())
        {
            VectorMask<Double> mask = SPECIES.indexInRange(i, array1.length);
            DoubleVector vector1 = DoubleVector.fromArray(SPECIES, array1, i, mask);
            DoubleVector vector2 = DoubleVector.fromArray(SPECIES, array2, i, mask);
            DoubleVector resultVector = vector1.mul(vector1).add(vector2.mul(vector2)).neg();
            resultVector.intoArray(result, i, mask);
        }
    }
}

import java.util.ArrayList;
import java.util.List;

public class SwitchPatternMatch
{
    public static void main(String[] args)
    {
        List<Object> list = makeList();
        for(Object obj : list)
        {
            System.out.printf("%s\t", (obj == null) ? "null" : obj.getClass().getName());
            switch(obj)
            {
                case null -> System.out.println("[A] null");
                case Integer i when i < 5 -> System.out.printf("[B] (%d)\n", i);
                case Integer i -> System.out.printf("[C] (%d)\n", i);
                case String s -> System.out.printf("[D] (\"%s\")\n", s);
                default -> System.out.printf("[E] (%s) \n", obj.toString());
            }
        }
    }
    private static List<Object> makeList()
    {
        List<Object> list = new ArrayList<>();
        list.add(null);
        list.add(0);
        list.add(1);
        list.add(10);
        list.add(20d);
        list.add(new String("Hello"));
        list.add(Boolean.TRUE);
        list.add(list);
        return list;
    }
}

import java.util.concurrent.Callable;
import jdk.incubator.concurrent.StructuredTaskScope;
import jdk.incubator.concurrent.StructuredTaskScope.ShutdownOnSuccess;
import jdk.incubator.concurrent.StructuredTaskScope.ShutdownOnFailure;

public class StructuredTaskAPI
{
    public static void main(String[] args) throws Exception
    {
        successExample();
        try
        {
            failExample();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }
    private static void successExample() throws InterruptedException
    {
        try(StructuredTaskScope.ShutdownOnSuccess<String> scope = new StructuredTaskScope.ShutdownOnSuccess<>())
        {
            scope.fork(() -> { return "Hello World";});
            scope.fork(() -> { return "Bye";});
            scope.join();
            String result = scope.result(e -> new RuntimeException("発生しないはず"));
            System.out.println(result);
        }
    }
    private static void failExample() throws Exception
    {
        try(StructuredTaskScope.ShutdownOnFailure scope = new StructuredTaskScope.ShutdownOnFailure())
        {
            scope.fork(new Callable<String>() {
                @Override
                public String call() throws InterruptedException
                { 
                    Thread.sleep(30); 
                    return "Hello World";
                }
            });
            scope.fork(new Callable<Integer>() {
                @Override
                public Integer call() throws InterruptedException
                {
                    throw new RuntimeException("ダミーのエラー");
                }
            });
            scope.join();
            scope.throwIfFailed();
        }
    }
}

private void(Object arg) {
    switch(arg) {
        case String s -> System.out.println("String");
        case int[] a -> System.out.println("Integer Array");
}