Workshop Java SE en 2025 : les nouvelles API

  private static void gererNull() {
    List<Object> liste1 = Stream.of(null,null).collect(Collectors.toList());
    System.out.println("liste1 : " + liste1);

    try {
      List<Object> liste2 = Stream.of(null,null).collect(Collectors.toUnmodifiableList());
      System.out.println("liste2 : " + liste2);
    } catch (NullPointerException npe) {
      npe.printStackTrace(System.out);
    }

    List<Object> liste3 = Stream.of(null,null).toList();
    System.out.println("liste3 : " + liste3);
  }

  private static void gererPolymorphisme() {
    // Compile sans erreur
    List<CharSequence> couleursOk = Stream.of("rouge", "vert", "bleu").collect(Collectors.toList());
    List<Number> nombresOk = Stream.of(1, 2, 3).collect(Collectors.toList());

    // Erreur de compilation
    List<CharSequence> couleurs = Stream.of("rouge", "vert", "bleu").toList();
    List<Number> nombres = Stream.of(1, 2, 3).toList();

    System.out.println(couleurs);
    System.out.println(nombres);
  }

  private static void gererPolymorphisme() {
    // Compile sans erreur
    List<CharSequence> couleursOk = Stream.of("rouge", "vert", "bleu").collect(Collectors.toList());
    List<Number> nombresOk = Stream.of(1, 2, 3).collect(Collectors.toList());

    // Erreur de compilation
    // List<CharSequence> couleurs = Stream.of("rouge", "vert", "bleu").toList();
    // List<Number> nombres = Stream.of(1, 2, 3).toList();
    List<? extends CharSequence> couleurs = Stream.of("rouge", "vert", "bleu").toList();
    List<Number> nombres = Stream.of(1, 2, 3).map(Number.class::cast).toList();

    System.out.println(couleurs);
    System.out.println(nombres);
  }

  private static void transformer1a1() {
    System.out.println("Fruits en maj : ");
    fruits.stream()
          .mapMulti((fruit, mapper) -> {
            mapper.accept(fruit.toUpperCase());
          })
          .forEach(System.out::println);
  }

  private static void transformer0a1() {
    System.out.println("Fruits à 6 lettres en maj : ");
    fruits.stream()
          .mapMulti((fruit, mapper) -> {
            if (fruit.length() == 6)
              mapper.accept(fruit.toUpperCase());
          })
          .forEach(System.out::println);
  }

  private static void transformer1aN() {
    System.out.println("Fruits avec bien mûr : ");
    fruits.stream()
          .mapMulti((fruit, mapper) -> {
            mapper.accept(fruit);
            mapper.accept(fruit + " bien mûr");
          })
          .forEach(System.out::println);
  }

  private static void transformerVersAutreType() {
    record Tarte(String fruit) {
    }

    System.out.println("Tartes aux fruits : ");
    List<Tarte> tartes = fruits.stream()
        .mapMulti((fruit, mapper) -> {
          mapper.accept(new Tarte(fruit));
        })
        .collect(Collectors.toList());
    System.out.println(tartes);
  }

  private static void transformerVersAutreType() {
    record Tarte(String fruit) {
    }

    System.out.println("Tartes aux fruits : ");
    List<Tarte> tartes = fruits.stream()
        .<Tarte>mapMulti((fruit, mapper) -> {
          mapper.accept(new Tarte(fruit));
        })
        .collect(Collectors.toList());
    System.out.println(tartes);
  }

  private static Gatherer<Integer, Void, Integer> definirGathererMapDouble() { (1)
    return Gatherer.of((state, element, downstream) -> {
      downstream.push(element * 2);
      return true;
    });
  }

Map double
[0, 1, 1, 2, 3, 5, 8, 13, 21, 1, 0] -> [0, 2, 2, 4, 6, 10, 16, 26, 42, 2, 0]

  private static Gatherer<Integer, Void, Integer> definirGathererMapGrandsDoubles() {
    return Gatherer.of((state, element, downstream) -> {
      if (element > 10) {
        downstream.push(element * 2);
      }
      return true;
    });
  }

Map grands doubles
[0, 1, 1, 2, 3, 5, 8, 13, 21, 1, 0] -> [26, 42]

  private static Gatherer<Integer, Void, Integer> definirGathererCourtCircuit() {
    return Gatherer.of((state, element, downstream) -> {
      if (element > 10) {
        return false;
      } else {
        downstream.push(element);
        return true;
      }
    });
  }

Court-circuit
[0, 1, 1, 2, 3, 5, 8, 13, 21, 1, 0] -> [0, 1, 1, 2, 3, 5, 8]

  private static Gatherer<Integer, ?, Integer> definirGathererSequentielAvecEtat() {
    return Gatherer.ofSequential(
      AtomicInteger::new,
      (state, element, downstream) -> {
        downstream.push(element);
        return state.incrementAndGet() < 5;
      }
    );
  }

Séquentiel avec état
[0, 1, 1, 2, 3, 5, 8, 13, 21, 1, 0] -> [0, 1, 1, 2, 3]

  private static Gatherer<Integer, ?, List<Integer>> definirGathererGroupeDeuxParDeux() {
    return Gatherer.ofSequential(
      () -> new ArrayList<Integer>(),
      (state, element, downstream) -> {
        state.add(element);
        if (state.size() == 2) {
          downstream.push(new ArrayList<>(state));
          state.clear();
        }
        return true;
      },
      (state, downstream) -> {
        if (!state.isEmpty()) {
          downstream.push(state);
        }
      }
    );
  }

Groupe deux par deux
[0, 1, 1, 2, 3, 5, 8, 13, 21, 1, 0] -> [[0, 1], [1, 2], [3, 5], [8, 13], [21, 1], [0]]

  private static Gatherer<Integer, ?, Integer> definirGathererParallelePlusGrandElement() {

    class Etat {
      Integer max = null;
    }

    return Gatherer.of(

      // Initializer
      Etat::new,

      // Integrator
      (state, element, downstream) -> {

        // On sauvegarde l'élément s'il est le plus grand connu
        if (state.max == null || element > state.max) {
          state.max = element;
        }

        return true;
      },

      // Combiner : on renvoie le plus grand des deux éléments
      (e1, e2) ->  (e1.max > e2.max) ? e1 : e2,

      // Finisher
      (state, downstream) -> downstream.push(state.max)
    );
  }

Parallèle plus grand élément
[0, 1, 1, 2, 3, 5, 8, 13, 21, 1, 0] -> [21]

  private static void sequencedCollection() {
    List<Integer> nombres = new ArrayList<>();
    nombres.add(2);
    nombres.addFirst(1);
    nombres.addLast(3);
    System.out.println(nombres);
    System.out.println(nombres.getFirst());
    System.out.println(nombres.getLast());
    nombres.removeLast();
    nombres.removeFirst();
    System.out.println(nombres);
  }

  private static void reversedSequencedCollection() {
    var elements = new ArrayList<>(Arrays.asList("1", "2", "3", "4"));
    System.out.println("elements : " + elements);
    var inverse = elements.reversed();
    System.out.println("inverse  : " + inverse);

    elements.add(2, "5");
    System.out.println("\nelements : " + elements);
    System.out.println("inverse  : " + inverse);

    inverse.add(1, "6");
    System.out.println("\ninverse  : " + inverse);
    System.out.println("elements : " + elements);
  }

  private static void sequencedSet() {
    var nombres = new LinkedHashSet<>(List.of(2, 3, 4));
    System.out.println(nombres);

    Integer premier = nombres.getFirst();
    Integer dernier = nombres.getLast();
    System.out.println(premier);
    System.out.println(dernier);

    nombres.addFirst(1);
    nombres.addLast(5);
    System.out.println(nombres);

    System.out.println(nombres.reversed());
  }

  private static void sequencedMap() {
    SequencedMap<Integer, String> map = new LinkedHashMap<>();

    map.put(1, "Valeur1");
    map.put(2, "Valeur2");
    map.put(3, "Valeur3");

    System.out.println(map);

    System.out.println(map.firstEntry());
    System.out.println(map.lastEntry());

    Map.Entry<Integer, String> premier = map.pollFirstEntry();
    Map.Entry<Integer, String> dernier = map.pollLastEntry();

    System.out.println("\n"+premier);
    System.out.println(dernier);
    System.out.println(map);

    map.putFirst(1, "Valeur1");
    map.putLast(3, "Valeur3");

    System.out.println("\n"+map);

    System.out.println("\n"+map.reversed());
  }

  private static void majSequencedMap() {
    SequencedMap<Integer, String> map = new LinkedHashMap<>();
    map.put(1, "Valeur1");
    map.put(2, "Valeur2");
    map.put(3, "Valeur3");

    try  {
    Entry<Integer, String> entry = map.firstEntry();
    entry.setValue("Valeur1 modifiee");
    } catch (Exception e) {
      e.printStackTrace(System.out);
    }
  }

  private static void collectionNonModifiable() {
    try {
      List<Integer> nombres = List.of(1, 2, 3);
      nombres.addFirst(0);
    } catch (Exception e) {
      e.printStackTrace(System.out);
    }
  }

  private static void collectionTriee() {
    try {
      SequencedSet<Integer> set = new TreeSet<>();
      set.addFirst(0);
    } catch (Exception e) {
      e.printStackTrace(System.out);
    }
  }

Collection triee
java.lang.UnsupportedOperationException
	at java.base/java.util.TreeSet.addFirst(TreeSet.java:478)
	at fr.sciam.workshop.javase.sequencedcollections.MainSequencedCollections.collectionTriee(MainSequencedCollections.java:79)
	at fr.sciam.workshop.javase.sequencedcollections.MainSequencedCollections.main(MainSequencedCollections.java:40)

  private static void collectionVide() {
    try {
      SequencedCollection<String> elements = List.of();
      elements.getFirst();
    } catch (Exception e) {
      e.printStackTrace(System.out);
    }
  }

  private static void unmodifiableSequenced() {
    SequencedMap<Integer, String> map = new LinkedHashMap<>();
    map.put(1, "Valeur1");
    map.put(2, "Valeur2");
    map.put(3, "Valeur3");

    SequencedMap<Integer, String> unmodifiableSequencedMap = Collections.unmodifiableSequencedMap(map);

    try {
      unmodifiableSequencedMap.pollFirstEntry();
    } catch (UnsupportedOperationException e) {
      e.printStackTrace(System.out);
    }
  }

  private static void manipulerChaineDeCaracteres() {
    try (Arena arena = Arena.ofConfined()) {
      MemorySegment memorySegment = arena.allocateFrom("Hello FFM");
      String message = memorySegment.getString(0);

      System.out.println(message);
      System.out.println(memorySegment.byteSize());
    }
  }

Manipulation d'une chaîne de caractères :
Hello FFM
10

  private static void manipulerEntiers() {
    try (Arena arena = Arena.ofConfined()) {
      MemorySegment memorySegment = arena.allocate(32);

      // Ecriture
      long increment = ValueLayout.JAVA_INT.byteSize(); // 4 octets
      for (int i = 0; i < ENTIERS.length; i++) {
        memorySegment.set(ValueLayout.JAVA_INT, i * increment, ENTIERS[i]);
      }

      // Lecture
      for (int i = 0; i < ENTIERS.length; i++) {
        int entier = memorySegment.get(ValueLayout.JAVA_INT, i * increment);
        System.out.print(entier + " ");
      }
    }
  }

Manipulation d'entiers
0 123 456 789 -1 -2 -3 -4

  private static void manipulerEntiers() {
    try (Arena arena = Arena.ofConfined()) {
      MemorySegment memorySegment = arena.allocate(32);

      // Ecriture
      for (int i = 0; i < ENTIERS.length; i++) {
        memorySegment.setAtIndex(ValueLayout.JAVA_INT, i, ENTIERS[i]);
      }

      // Lecture
      for (int i = 0; i < ENTIERS.length; i++) {
        int entier = memorySegment.getAtIndex(ValueLayout.JAVA_INT, i);
        System.out.print(entier + " ");
      }
    }
  }

Manipulation d'entiers
0 123 456 789 -1 -2 -3 -4

  private static void analyserFichierDeClasse() throws IOException {
    Path classFilePath = obtenirChemin(AccumulateurBasique.class);
    ClassModel classModel = ClassFile.of().parse(classFilePath);
    classModel.fields().forEach(System.out::println);
    classModel.methods().forEach(System.out::println);
  }

Analyse d'un fichier de classe
FieldModel[fieldName=valeur, fieldType=I, flags=2]
MethodModel[methodName=<init>, methodType=()V, flags=1]
MethodModel[methodName=ajouter, methodType=(I)I, flags=1]

  private static void analyserAvecPatternMatching() throws IOException {
    Path classFilePath = obtenirChemin(AccumulateurBasique.class);
    ClassModel classModel = ClassFile.of().parse(classFilePath);
    for (ClassElement element : classModel) {
      switch (element) {
        case FieldModel fm -> System.out.printf("Champ : %s%n", fm.fieldName().stringValue());
        case MethodModel mm -> System.out.printf("Méthode : %s%n", mm.methodName().stringValue());
        default -> System.out.printf("Autre élément : %s%n", element);
      }
    }
  }

Analyse d'un fichier de classe avec le Pattern Matching
Autre élément : AccessFlags[flags=33]
Autre élément : ClassFileVersion[majorVersion=68, minorVersion=0]
Autre élément : Superclass[superclassEntry=java/lang/Object]
Autre élément : Interfaces[interfaces=]
Champ : valeur
Méthode : <init>
Méthode : ajouter
Autre élément : Attribute[name=SourceFile]

  private static void analyserMethode() throws IOException {
    Path classFilePath = obtenirChemin(AccumulateurBasique.class);
    ClassModel classModel = ClassFile.of().parse(classFilePath);

    for (MethodModel method : classModel.methods()) {
      if ("ajouter".equals(method.methodName().stringValue())) {
        for (MethodElement methodElement : method) {
          switch (methodElement) {
            case AccessFlags flags -> System.out.printf("Flags : %s%n", flags.flags());
            case CodeModel code -> {
              for (CodeElement codeElement : code) {
                if (codeElement instanceof Instruction instruction) {
                  System.out.printf("Instruction : %s%n", instruction);
                }
              }
            }
            default -> {}
          }
        }
      }
    }
  }

Analyse d'une méthode
Flags : [PUBLIC]
Instruction : Load[OP=ALOAD_0, slot=0]
Instruction : UnboundStackInstruction[op=DUP]
Instruction : Field[OP=GETFIELD, field=fr/sciam/workshop/javase/classfile/AccumulateurBasique.valeur:I]
Instruction : Load[OP=ILOAD_1, slot=1]
Instruction : UnboundOperatorInstruction[op=IADD]
Instruction : Field[OP=PUTFIELD, field=fr/sciam/workshop/javase/classfile/AccumulateurBasique.valeur:I]
Instruction : Load[OP=ALOAD_0, slot=0]
Instruction : Field[OP=GETFIELD, field=fr/sciam/workshop/javase/classfile/AccumulateurBasique.valeur:I]
Instruction : Return[OP=IRETURN]

  private static void ecrireFichierDeClasse() {
    ClassDesc classDesc = ClassDesc.of("fr.sciam.MaClassGeneree");
    byte[] bytes = ClassFile.of().build(classDesc, builder -> {});

    System.out.println("Contenu hexadécimal");
    HexFormat.of().formatHex(System.out, bytes);
    System.out.println();
  }

Écriture d'un fichier de classe
Contenu hexadécimal
cafebabe00000044000501001766722f736369616d2f4d61436c61737347656e657265650700010100106a6176612f6c616e672f4f626a6563740700030001000200040000000000000000

  private static void ecrireFichierDeClasseAvancee() {
    ClassDesc classDesc = ClassDesc.of("fr.sciam.MaClasseGenereeAvancee");
    byte[] bytes = ClassFile.of().build(
      classDesc,
      builder -> {
        // Superclass
        builder.withSuperclass(ClassDesc.of("java.util.Date"))

          // Interfaces
          .withInterfaceSymbols(ClassDesc.of("java.io.Serializable"))

          // Flags
          .withFlags(AccessFlag.FINAL)

          // Méthode main()
          .withMethodBody(
            "main",
            MethodTypeDesc.of(
              ConstantDescs.CD_void,
              ConstantDescs.CD_String.arrayType()
            ),
            ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC,
            CodeBuilder::return_
          );
      }
    );

    sauvegarderFichier(bytes, "fr/sciam/MaClasseGenereeAvancee.class");
  }

javap -classpath . -verbose fr.sciam.MaClasseGenereeAvancee

final class fr.sciam.MaClasseGenereeAvancee extends java.util.Date implements java.io.Serializable
  minor version: 0
  major version: 68
  flags: (0x0010) ACC_FINAL
  this_class: #2                          // fr/sciam/MaClasseGenereeAvancee
  super_class: #4                         // java/util/Date
  interfaces: 1, fields: 0, methods: 1, attributes: 0
Constant pool:
   #1 = Utf8               fr/sciam/MaClasseGenereeAvancee
   #2 = Class              #1             // fr/sciam/MaClasseGenereeAvancee
   #3 = Utf8               java/util/Date
   #4 = Class              #3             // java/util/Date
   #5 = Utf8               main
   #6 = Utf8               ([Ljava/lang/String;)V
   #7 = Utf8               java/io/Serializable
   #8 = Class              #7             // java/io/Serializable
   #9 = Utf8               Code
{
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: return
}

  private static void ecrireFichierDeClasseAvancee() {
    ClassDesc classDesc = ClassDesc.of("fr.sciam.MaClasseGenereeAvancee");
    byte[] bytes = ClassFile.of().build(
      classDesc,
      builder -> {
        // Superclass
        builder.withSuperclass(ClassDesc.of("java.util.Date"))

          // Interfaces
          .withInterfaceSymbols(ClassDesc.of("java.io.Serializable"))

          // Flags
          .withFlags(AccessFlag.FINAL)

          // Field
          .withField(
            "YEAR",
            ConstantDescs.CD_int,
            fieldBuilder ->
              fieldBuilder
                .withFlags(AccessFlag.PRIVATE, AccessFlag.STATIC, AccessFlag.FINAL)
                .with(ConstantValueAttribute.of(builder.constantPool().intEntry(2025))))

          // Méthode main()
          .withMethodBody(
            "main",
            MethodTypeDesc.of(
              ConstantDescs.CD_void,
              ConstantDescs.CD_String.arrayType()
            ),
            ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC,
            CodeBuilder::return_
          );
      }
    );

    sauvegarderFichier(bytes, "fr/sciam/MaClasseGenereeAvancee.class");
  }

Constant pool:
   #1 = Utf8               fr/sciam/MaClasseGenereeAvancee
   #2 = Class              #1             // fr/sciam/MaClasseGenereeAvancee
   #3 = Utf8               java/util/Date
   #4 = Class              #3             // java/util/Date
   #5 = Utf8               YEAR
   #6 = Utf8               I
   #7 = Integer            2025
   #8 = Utf8               main
   #9 = Utf8               ([Ljava/lang/String;)V
  #10 = Utf8               java/io/Serializable
  #11 = Class              #10            // java/io/Serializable
  #12 = Utf8               ConstantValue
  #13 = Utf8               Code

  private static void ecrireFichierDeClasseHelloWorld() {
    ClassDesc classDesc = ClassDesc.of("fr.sciam.MonHelloWorld");
    byte[] bytes = ClassFile.of().build(
      classDesc,
      builder -> builder.withMethodBody(
        "main",
        MethodTypeDesc.of(
          ConstantDescs.CD_void,
          ConstantDescs.CD_String.arrayType()
        ),
        ClassFile.ACC_PUBLIC | ClassFile.ACC_STATIC,
        codeBuilder -> {
          ClassDesc printStreamClassDesc = ClassDesc.of("java.io.PrintStream");

          codeBuilder.getstatic(
              ClassDesc.of("java.lang.System"),
              "out",
              printStreamClassDesc
            )
            .loadConstant("Hello World")
            .invokevirtual(
              printStreamClassDesc,
              "println",
              MethodTypeDesc.of(
                ConstantDescs.CD_void,
                ConstantDescs.CD_Object
              )
            )
            .return_();
        }
      )
    );

    sauvegarderFichier(bytes, "fr/sciam/MonHelloWorld.class");
  }

javap -classpath . -verbose fr.sciam.MonHelloWorld

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #10                 // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #12                 // String Hello World
         5: invokevirtual #18                 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
         8: return

$ java -classpath . fr.sciam.MonHelloWorld
Hello World

  private static void transformerFichierDeClasse() throws IOException {
    // Obtention du ClassModel correspondant à AccumulateurAvance
    Path path = obtenirChemin(AccumulateurAvance.class);
    ClassModel classModel = ClassFile.of().parse(path);

    ClassTransform ct = (builder, element) -> {

      // Filtrage sur les méthodes publiques (hors constructeur)
      if (element instanceof MethodModel mm
        && mm.flags().has(AccessFlag.PUBLIC)
        && !"<init>".equals(mm.methodName().stringValue())) {

        // Ajout de la méthode à l'identique avec modificateur synchronized
        builder.withMethod(
          mm.methodName().stringValue(),
          mm.methodTypeSymbol(),
          mm.flags().flagsMask(),
          methodBuilder -> {
            mm.forEach(methodBuilder::with);
            methodBuilder.withFlags(AccessFlag.PUBLIC, AccessFlag.SYNCHRONIZED);
          }
        );

      } else {
        // Conservation de l'élément à l'identique
        builder.with(element);
      }
    };

    byte[] bytecode = ClassFile.of().transformClass(classModel, ct);
    sauvegarderFichier(bytecode, "fr/sciam/AccumulateurAvance.class");
  }

javap -classpath . -verbose fr.sciam.AccumulateurAvance

  public fr.sciam.workshop.javase.classfile.AccumulateurAvance();
    descriptor: ()V
    flags: (0x0001) ACC_PUBLIC

[...]

  public synchronized int ajouter(int);
    descriptor: (I)I
    flags: (0x0021) ACC_PUBLIC, ACC_SYNCHRONIZED

[...]

  public synchronized int soustraire(int);
    descriptor: (I)I
    flags: (0x0021) ACC_PUBLIC, ACC_SYNCHRONIZED

  private static void transformerFichierDeClasse() throws IOException {
    Path path = obtenirChemin(AccumulateurAvance.class);
    ClassModel classModel = ClassFile.of().parse(path);

    // Filtrage sur les méthodes publiques (hors constructeur)
    Predicate<MethodModel> predicate = methodModel ->
      methodModel.flags().has(AccessFlag.PUBLIC)
        && !"<init>".equals(methodModel.methodName().stringValue());

    // Transformation de la méthode avec ajout du modificateur synchronized
    MethodTransform mt = MethodTransform.endHandler(builder ->
      builder.withFlags(AccessFlag.PUBLIC, AccessFlag.SYNCHRONIZED)
    );
    ClassTransform ct = ClassTransform.transformingMethods(predicate, mt);

    byte[] bytecode = ClassFile.of().transformClass(classModel, ct);
    sauvegarderFichier(bytecode, "fr/sciam/AccumulateurAvance.class");
  }

  private static void formaterSimple() {
    NumberFormat fmt = NumberFormat.getCompactNumberInstance();
    LongStream.of(nombreRonds).forEach( n -> System.out.printf("%-12s -> %s\n", n, fmt.format(n)));
  }

  private static void formaterAvecLocaleLong() {
    NumberFormat fmt = NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.LONG);
    LongStream.of(nombreRonds).forEach( n -> System.out.printf("%-12s -> %s\n", n, fmt.format(n)));
  }

  private static void formaterAvecArrondi() {
    NumberFormat fmt = NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.SHORT);

    System.out.printf("%-12s %-12s %-12s %-12s\n", "", "HALF_DOWN", "HALF_EVEN", "HALF_UP");
    LongStream.of(nombresArrondis).forEach( n -> {
      fmt.setRoundingMode(RoundingMode.HALF_DOWN);
      String down = fmt.format(n);
      fmt.setRoundingMode(RoundingMode.HALF_EVEN);
      String even = fmt.format(n);
      fmt.setRoundingMode(RoundingMode.HALF_UP);
      String up = fmt.format(n);
      System.out.printf("%-12s %-12s %-12s %-12s\n", n, down, even, up);
    });
  }

  private static void formaterDecimaux() {
    NumberFormat fmt = NumberFormat.getCompactNumberInstance();
    fmt.setMinimumFractionDigits(0);
    fmt.setMaximumFractionDigits(2);
    LongStream.of(nombresDecimaux).forEach( n -> System.out.printf("%-12s -> %s\n", n, fmt.format(n)));
  }

  private static void formaterAvecPatterns() {
    String[] compactPatterns = { "", "", "", "0k", "00k", "000k", "0m", "00m", "000m",
                                 "0md", "00md", "000md", "0t", "00t", "000t" };

    DecimalFormat decimalFormat = (DecimalFormat) NumberFormat.getNumberInstance(Locale.FRANCE);

    CompactNumberFormat fmt = new CompactNumberFormat(decimalFormat.toPattern(),
        decimalFormat.getDecimalFormatSymbols(), compactPatterns);

    LongStream.of(nombreRonds).forEach( n -> System.out.printf("%-12s -> %s\n", n, fmt.format(n)));
  }

  private static void parser() {
    var nombresTextes = List.of("100", "1 millier", "10 mille", "10 millions", "1 milliard");

    NumberFormat fmt = NumberFormat.getCompactNumberInstance(Locale.FRANCE, NumberFormat.Style.LONG);

    for (String n : nombresTextes) {
      try {
        System.out.printf("%-12s -> %s\n", n, fmt.parse(n));
      } catch (ParseException e) {
        e.printStackTrace(System.out);
      }
    }
  }