// Méthodes pour accès séquentiel
SequencedCollection<String> list = new ArrayList<>();
list.addFirst("first");
list.addLast("last");
String first = list.getFirst();
String last = list.getLast();

// Maps séquentielles
SequencedMap<String, Integer> map = new LinkedHashMap<>();
map.putFirst("one", 1);
map.putLast("two", 2);

record Person(String name, int age) {
    // Constructeur avec validation
    public Person {
        if (age < 0) throw new IllegalArgumentException("Age must be positive");
        if (name == null) throw new IllegalArgumentException("Name required");
    }
    
    // Méthode statique
    public static Person of(String name, int age) {
        return new Person(name, age);
    }
    
    // Méthode d'instance additionnelle
    public boolean isAdult() {
        return age >= 18;
    }
}

Person.of("Pierre", -1);

record Dog(int id, String name) {};
record User(int id, String firstname) {};

Dog d1 = new Dog(1, "Rex");

User u1= new User(1,"Pierre");

public String check(Object obj) {
    return switch (obj) {
                case User u -> "I'm a user named "+u.firstname();
                case Dog d -> "I'm a dog named "+d.name();
                case null -> "NULL !";
                default -> "A simple object: "+obj;
    };
}

System.out.println("-->"+check(d1));
System.out.println("-->"+check(u1));
System.out.println("-->"+check(null));
System.out.println("-->"+check(new Integer(12)));

/**
 * Interface générique définissant un contrat pour exécuter une action sur un type T.
 * Introduit des fonctionnalités Java 8+ (méthodes default) et Java 9+ (méthodes statiques).
 * @param <T> le type des éléments sur lesquels l'action sera exécutée
 */
public interface ActionClass<T> {
    // Méthode statique introduite en Java 9
    // Fournit une description de l'interface
    static String getInterfaceDescription() {
        return "Une interface qui impose de définir une action et permet de l'exécuter une liste de <T>";
    }
    
    /**
     * Méthode abstraite définissant l'action à exécuter sur un élément
     * @param t l'élément sur lequel exécuter l'action
     */
    void action(T t);
    
    /**
     * Méthode default (Java 8+) fournissant une implémentation par défaut
     * pour exécuter l'action sur une liste d'éléments
     * Utilise la méthode action(T) pour chaque élément
     * @param list la liste d'éléments à traiter
     */
    default void action(List<T> list) {
        for(T t:list) action(t);
    }
}

//Une classe qui affiche une String en majuscule et s'applique automatiquement à une liste de String
public class UpperCaser implements ActionClass<String> {
    public void action(String s) {System.out.println(s.toUpperCase());}
}
//Une classe qui affiche la concaténation du nom et du prénom d'une personne et s'applique automatiquement à une liste de Personne
public class PersonFullname implements ActionClass<Person> {
    public void action(Person p) {System.out.println(p.prenom()+" "+p.nom());}
}

//La factory .of() est apparue dans Java9 pour créer des Collections non mutables.
new UpperCaser().action(List.of("abc","def"));

new PersonFullname().action(personnes);

System.out.println(ActionClass.getInterfaceDescription());

public @interface MyAnnotation { }

import java.util.function.BiFunction;
BiFunction<String,String,String> f1 = (s1, s2) -> s1 + s2;

BiFunction<String,String,String> f2 = (@MyAnnotation var s1, @MyAnnotation var s2) -> s1 + s2;

// 1. Information basique des processus
ProcessHandle current = ProcessHandle.current();
System.out.printf("Process ID: %d%n", current.pid());
System.out.printf("Parent PID: %d%n", 
    current.parent().map(ProcessHandle::pid).orElse(-1L));

// 2. Surveillance des processus enfants
current.children().forEach(child -> {
    System.out.printf("Child process: %d%n", child.pid());
    child.onExit().thenAccept(ph -> 
        System.out.printf("Child %d terminated%n", ph.pid()));
});

// 2. Monitoring système
ProcessHandle.allProcesses()
    .filter(ph -> ph.info().totalCpuDuration().isPresent())
    .sorted(Comparator.comparing(ph -> 
        ph.info().totalCpuDuration().get()))
    .limit(5)
    .forEach(ph -> {
        ProcessHandle.Info info = ph.info();
        System.out.printf("PID: %d%n", ph.pid());
        System.out.printf("Command: %s%n", 
            info.command().orElse("?"));
        System.out.printf("CPU time: %s%n", 
            info.totalCpuDuration().get());
        System.out.println("---");
    });

// 3. Gestion avancée des processus
ProcessBuilder pb = new ProcessBuilder("ls", "-l")
    .redirectOutput(ProcessBuilder.Redirect.PIPE);

Process process = pb.start();
ProcessHandle handle = process.toHandle();

// Gestion asynchrone
CompletableFuture<ProcessHandle> onExit = handle.onExit();
onExit.thenAccept(ph -> {
    System.out.println("Process completed: " + ph.pid());
    System.out.println("Exit code: " + process.exitValue());
});

String str2 = "value2";
Optional<String> optional2 = Optional.ofNullable(str2);
optional2.orElseThrow();

String str3 = null;
Optional<String> optional3 = Optional.ofNullable(str3);
optional3.orElseThrow();

String str3Bis = null;
Optional<String> optional3Bis = Optional.ofNullable(str3Bis);
optional3Bis.orElse("defaultValue3");

String str4 = null;
//String str4 = "value3"; 
String[] values={"a1","b2","c3"};

Optional<String> optional4 = Optional.ofNullable(str4);

optional4.orElseGet( () -> values[new Random().nextInt(values.length)] );

// Import des classes pour l'API Foreign Function & Memory (FFM)
import java.lang.foreign.*;
import java.lang.invoke.MethodHandle;

        // 1. Configuration de l'appel à la fonction C 'strlen'
        // Définition du prototype de la fonction: size_t strlen(const char*)
        FunctionDescriptor strlenDesc = FunctionDescriptor.of(
            ValueLayout.JAVA_LONG,    // Type de retour: long (size_t en C)
            ValueLayout.ADDRESS       // Type du paramètre: pointeur vers char*
        );

        try {
            // 2. Création du linker pour interagir avec le code natif
            Linker linker = Linker.nativeLinker();
            
            // 3. Recherche du symbole 'strlen' dans la bibliothèque standard C
            SymbolLookup stdlib = linker.defaultLookup();
            var strlenSymbol = stdlib.find("strlen")
                .orElseThrow(() -> new RuntimeException("strlen non trouvée"));

            // 4. Création du handle pour appeler strlen
            MethodHandle strlen = linker.downcallHandle(strlenSymbol, strlenDesc);

            // 5. Utilisation avec gestion automatique de la mémoire
            try (Arena arena = Arena.ofConfined()) {  // Arena libère la mémoire automatiquement
                // Allocation et conversion de la chaîne en C-string
                MemorySegment cString = arena.allocateFrom("Hello, World!");
                
                // Appel de strlen
                long length = (long) strlen.invoke(cString);
                System.out.println("Longueur: " + length);  // Affiche: 13

                // Test avec une chaîne différente
                MemorySegment other = arena.allocateFrom("Xin chào thế giới!");
                System.out.println("Longueur UTF-8: " + (long)strlen.invoke(other));
            }
        } catch (Throwable e) {
            System.err.println("Erreur lors de l'appel natif: " + e.getMessage());
            e.printStackTrace();
        }

// Définition
private final ScopedValue<String> USER_ID = ScopedValue.newInstance();
private final ScopedValue<String> ROLE = ScopedValue.newInstance();

private static void processTask() {
    // Les valeurs sont accessibles dans les méthodes appelées
    System.out.println("Processing for: " + USER_ID.get() + 
                     " with role: " + ROLE.get());
}

        // Utilisation avec Virtual Threads
        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // Premier contexte
            executor.submit(() -> 
                ScopedValue.where(USER_ID, "user1")
                          .where(ROLE, "ADMIN")
                          .run(() -> {
                              System.out.println("Thread 1 - User: " + USER_ID.get());
                              System.out.println("Thread 1 - Role: " + ROLE.get());
                              // Sous-tâche hérite des valeurs
                              processTask();
                          })
            );

            // Deuxième contexte (différentes valeurs)
            executor.submit(() -> 
                ScopedValue.where(USER_ID, "user2")
                          .where(ROLE, "USER")
                          .run(() -> {
                              System.out.println("Thread 2 - User: " + USER_ID.get());
                              System.out.println("Thread 2 - Role: " + ROLE.get());
                              processTask();
                          })
            );
        }

public static Person fetchUser() {
    // Simulate fetching user
    return Person.of("John Doe",45);
}

public static String fetchMessage() {
    // Simulate fetching message
    return "Hello, World!";
}

        ExecutorService executor = Executors.newCachedThreadPool();

        try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
            StructuredTaskScope.Subtask<Person> user = scope.fork(() -> fetchUser());
            StructuredTaskScope.Subtask<String> order = scope.fork(() -> fetchMessage());
            scope.join();  // Attend tous les résultats

            // Utilisation des résultats
                System.out.println("User: " + user.get());
                System.out.println("Order: " + order.get());
        } finally {
            executor.shutdown();
        }

class Point {
    private final int x;
    private final int y;
    
    Point(int x, int y) {
        // Bloc de validation avant initialisation
        //AVANT L'APPEL DU SUPER CONSTRUCTEUR
        try {
            validateCoordinates(x, y);
        } catch (Exception e) {
            throw new IllegalArgumentException("Invalid coordinates", e);
        }
        super();
        // Initialisation des champs
        this.x = x;
        this.y = y;
    }
    
    static void validateCoordinates(int x, int y) {
        if (x < 0 || y < 0) throw new IllegalArgumentException();
    }
}

import jdk.incubator.vector.FloatVector;
import jdk.incubator.vector.VectorSpecies;

final VectorSpecies<Float> SPECIES_256 = FloatVector.SPECIES_256;
float[] array1 = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f};
float[] array2 = {8.0f, 7.0f, 6.0f, 5.0f, 4.0f, 3.0f, 2.0f, 1.0f};

var v1 = FloatVector.fromArray(SPECIES_256, array1, 0);
var v2 = FloatVector.fromArray(SPECIES_256, array2, 0);
var v3 = v1.mul(v2);      // Multiplication vectorielle

System.out.println(v3);

Object obj = 123;
if (obj instanceof int i && i > 100) {
    System.out.println("Large number: " + i);
}