Aide-mémoire Java

$ javac <options> <fichiers source>

$ javac -sourcepath src \ (1)
        -source 11 \ (2)
        -d classes \ (3)
        -classpath classes \ (4)
        -g \ (5)
        src/MonApplication.java (6)

$ java [-options] class [args...]
$ java [-options] -jar jarfile [args...]

$ java -cp classes \ (1)
       MonApplication (2)

int[] arrayOfFiveZeros = { 0, 0, 0, 0, 0};
int[] anArray = new int[5];
assertArrayEquals(arrayOfFiveZeros, anArray);
assertNotSame(arrayOfFiveZeros, anArray); (1)

int[] theSameArray = anArray;
assertSame(anArray, theSameArray); (2)

theSameArray[0] = 12;
assertEquals(12, anArray[0]);
assertEquals(12, theSameArray[0]); (3)

int[] anotherArray = new int[5];
assertArrayEquals(arrayOfFiveZeros, anotherArray);
assertNotSame(arrayOfFiveZeros, anotherArray); (4)

theSameArray = anotherArray;
assertSame(anotherArray, theSameArray);
assertNotSame(anArray, theSameArray); (5)

theSameArray[0] = 21;
assertEquals(12, anArray[0]);
assertEquals(21, theSameArray[0]);
assertEquals(21, anotherArray[0]); (6)

if (aVariable == 0) { (1)
  (2)
  assert aVariable == 0;
} else {
  (3)
  assert aVariable != 0;
}

switch (aVariable) { (1)
  case 1:
    (2)
    assert aVariable == 1;
    break;
  case 2:
    (3)
    assert aVariable == 2;
    break;
  default:
    (4)
    assert aVariable != 1 && aVariable != 2;
}

switch (day) {
    case MONDAY, FRIDAY, SUNDAY -> numLetters = 6; (1)
    case TUESDAY                -> numLetters = 7;
    case THURSDAY, SATURDAY     -> numLetters = 8;
    case WEDNESDAY              -> numLetters = 9;
    default -> throw new IllegalStateException("Invalid day: " + day);
};

var numbers = List.of(1, 2, 3, 4);
for (var number: numbers) { (1)
  (2)
}

for (int i = 1; i < 11; i++) { (3)
  (4)
}

var count = 1;
while (count < 11) { (1)
  (2)
  count++;
}
assert count == 11;
do {
  (3)
  count++;
} while (count < 11); (4)
assert count == 12;

String s1 = new String();
assertEquals("", s1);

char[] abc = {'a', 'b', 'c'};
String s2 = new String(abc);
assertEquals("abc", s2);
assertNotSame("abc", s2);

String s3 = "xyz";
assertEquals("xyz", s3);

String s4 = s2;
assertEquals(s2, s4);
assertSame(s2, s4);

assertEquals(3, s2.length());
assertEquals("b", s2.substring(1, 2));

String source = "abcde";
int sourceLength = source.length();
StringBuilder destination = new StringBuilder(sourceLength);

for (int i = (sourceLength - 1); i >= 0; --i) {
  destination.append(source.charAt(i));
}
assertEquals("edcba", destination.toString());

/**
 * Un bref commentaire.
 * Un commentaire plus détaillé...
 * @version juin 2020
 * @author Prénom NOM
 */
class NomClasse { // Déclaration de la classe
  // Corps de la classe
}

package fr.uvsq.refcardjava.classes;

/**
 * La classe <code>Complex</code> représente un nombre complexe.
 *
 * @author hal
 * @version 2020
 */
public class Complex {
  /** La partie réelle du nombre. */
  private final double real;
  /** La partie imaginaire du nombre. */
  private final double imaginary;

  /**
   * Construit un complexe à partir d'une partie réelle et imaginaire.
   * @param real      la partie réelle
   * @param imaginary la partie imaginaire
   */
  public Complex(double real, double imaginary) {
    this.real = real;
    this.imaginary = imaginary;
  }

  /**
   * Construit un complexe uniquement à partir d'une partie réelle.
   * La partie imaginaire sera égale à zéro.
   *
   * @param real      la partie réelle
   */
  public Complex(double real) {
    this(real, 0.0);
  }

  /**
   * Retourne la partie réelle.
   * @return la partie réelle
   */
  public double getReal() {
    return real;
  }

  /**
   * Retourne la partie imaginaire.
   * @return la partie imaginaire
   */
  public double getImaginary() {
    return imaginary;
  }

  /**
   * Retourne un nouveau nombre complexe, somme du nombre courant et du paramètre.
   *
   * @param rhs le nombre complexe en partie droite de l'opération
   * @return la somme de l'objet courant et de rhs
   */
  public Complex add(Complex rhs) {
    if (rhs == null) throw new IllegalArgumentException("Parameter can not be null.");
    return new Complex(real + rhs.real, imaginary + rhs.imaginary);
  }
}

package fr.uvsq.refcardjava.classes;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

public class ComplexTest {
  @Test
  public void shouldCreateAComplexNumber() {
    var c = new Complex(1.0, 2.0); // 1 + 2i
    assertEquals(1.0, c.getReal());
    assertEquals(2.0, c.getImaginary());
  }

  @Test
  public void shouldCreateAComplexNumberFromARealNumber() {
    var c = new Complex(1.0); // 1 + 0i
    assertEquals(1.0, c.getReal());
    assertEquals(0.0, c.getImaginary());
  }

  @Test
  public void shouldAddTwoComplex() {
    var c1 = new Complex(1.0, 2.0); // 1 + 2i
    var c2 = new Complex(2.0, 3.0); // 2 + 3i
    var result = c1.add(c2);
    assertEquals(3.0, result.getReal());
    assertEquals(5.0, result.getImaginary());
  }

  @Test
  public void shouldAddAComplexWithNull() {
    var c1 = new Complex(1.0, 2.0); // 1 + 2i
    Exception exception = assertThrows(IllegalArgumentException.class, () -> c1.add(null));
    assertEquals("Parameter can not be null.", exception.getMessage());
  }
}

package fr.uvsq.refcardjava.classes;

/**
 * La classe <code>ComplexWithCounter</code> est un exemple d'usage de membre de classe.
 *
 * @author hal
 * @version 2020
 */
public class ComplexWithCounter {
  /** Le nomdre de complexe */
  private static long complexCounter = 0L;
  /** La partie réelle du nombre. */
  private final double real;
  /** La partie imaginaire du nombre. */
  private final double imaginary;

  /**
   * Construit un complexe à partir d'une partie réelle et imaginaire.
   * @param real      la partie réelle
   * @param imaginary la partie imaginaire
   */
  public ComplexWithCounter(double real, double imaginary) {
    this.real = real;
    this.imaginary = imaginary;
    complexCounter++;
  }

  /**
   * Retourne le nombre de complexes
   * @return le nombre d'instances
   */
  public static long getComplexCounter() {
    return complexCounter;
  }

  public static void resetComplexCounter() {
    complexCounter = 0;
  }

  /**
   * Décrémente le compteur quand l'objet est détruit.
   */
  @Override
  protected void finalize() throws Throwable {
    --complexCounter;
    super.finalize();
  }

  /**
   * Retourne la partie réelle.
   * @return la partie réelle
   */
  public double getReal() {
    return real;
  }

  /**
   * Retourne la partie imaginaire.
   * @return la partie imaginaire
   */
  public double getImaginary() {
    return imaginary;
  }
}

package fr.uvsq.refcardjava.classes;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

class ComplexWithCounterTest {
  @BeforeEach
  public void setup() {
    ComplexWithCounter.resetComplexCounter();
  }

  @Test
  public void shouldHaveNoInstances() {
    assertEquals(0, ComplexWithCounter.getComplexCounter());
  }

  @Test
  public void shouldHaveThreeInstances() {
    var c1 = new ComplexWithCounter(0.0, 0.0);
    var c2 = new ComplexWithCounter(1.0, 1.0);
    var c3 = new ComplexWithCounter(2.0, 2.0);

    assertEquals(3, ComplexWithCounter.getComplexCounter());
  }

  @Test
  public void shouldHaveAlsoThreeInstances() {
    var c1 = new ComplexWithCounter(0.0, 0.0);
    var c2 = new ComplexWithCounter(1.0, 1.0);
    var c3 = new ComplexWithCounter(2.0, 2.0);
    var c4 = c3;

    assertEquals(3, ComplexWithCounter.getComplexCounter());
  }

  @Disabled
  @Test
  public void shouldHaveTwoInstances() throws InterruptedException {
    var c1 = new ComplexWithCounter(0.0, 0.0);
    var c2 = new ComplexWithCounter(1.0, 1.0);
    var c3 = new ComplexWithCounter(2.0, 2.0);

    assertEquals(3, ComplexWithCounter.getComplexCounter());

    c1 = null;
    System.gc();
    Thread.sleep(1000);

    assertEquals(2, ComplexWithCounter.getComplexCounter());
  }
}

package fr.uvsq.refcardjava.classes;

/**
 * La classe <code>Complex</code> représente un nombre complexe générique dont le type de la partie entière et imaginaire est paramétré.
 *
 * @author hal
 * @version 2020
 */
public class GenericComplex<T> {
  /** La partie réelle du nombre. */
  private final T real;
  /** La partie imaginaire du nombre. */
  private final T imaginary;

  /**
   * Construit un complexe à partir d'une partie réelle et imaginaire.
   * @param real      la partie réelle
   * @param imaginary la partie imaginaire
   */
  public GenericComplex(T real, T imaginary) {
    this.real = real;
    this.imaginary = imaginary;
  }

  /**
   * Retourne la partie réelle.
   * @return la partie réelle
   */
  public T getReal() {
    return real;
  }

  /**
   * Retourne la partie imaginaire.
   * @return la partie imaginaire
   */
  public T getImaginary() {
    return imaginary;
  }
}

package fr.uvsq.refcardjava.classes;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;

class GenericComplexTest {
  @Test
  public void shouldCreateAComplexFromFloat() {
    GenericComplex<Float> c = new GenericComplex<>(1.0F, 2.0F);
    assertTrue(c.getReal() instanceof Float);
    assertTrue(c.getImaginary() instanceof Float);
  }

  @Test
  public void shouldCreateAComplexFromDouble() {
    GenericComplex<Double> c = new GenericComplex<>(1.0, 2.0);
    assertTrue(c.getReal() instanceof Double);
    assertTrue(c.getImaginary() instanceof Double);
  }
}

class String implements Comparable<String> {
  // ...
  @Override
  public int compareTo(String o) {
    // Code pour la comparaison
  }
  // ...
}

/**
 * Retourne une chaîne représentant l'objet.
 * @return la chaîne.
 */
@Override
public String toString() {
    return String.format("O = %s L = %s, H = %s", orig, getLargeur(), getHauteur());
}

/**
 * Retourn une chaîne représentant l'objet.
 *
 * @return la chaîne.
 */
@Override
public String toString() {
    return String.format("%s, couleur : %s", super.toString(), couleur);
}

// Création d'un tableau de références sur des Rectangle2D
final int NB_RECTANGLES = 2;
Rectangle2D[] figures = new Rectangle2D[NB_RECTANGLES];

// Un rectangle
figures[0] = new Rectangle2D(new Point2D.Double(0.0, 5.0),
  new Point2D.Double(2.0, 2.0));

// Un rectangle plein
figures[1] = new Rectangle2DPlein(new Point2D.Double(1.0, 3.0),
  new Point2D.Double(3.0, 2.0),
  Color.BLUE);

assertEquals("O = Point2D.Double[0.0, 5.0] L = 2.0, H = 3.0", figures[0].toString());
assertEquals("O = Point2D.Double[1.0, 3.0] L = 2.0, H = 1.0, couleur : java.awt.Color[r=0,g=0,b=255]",
  figures[1].toString());

public static double sqrtWithReturnCode(double d) {
    return Double.isNaN(d) || d < 0.0 ?
            Double.NaN : (1)
            sqrt(d);
}

double result = sqrtWithReturnCode(value);
if (Double.isNaN(result)) { (1)
    System.err.println("Argument illégal (négatif ou égal à NaN).");
} else {
    System.out.printf("sqrt(%f) = %f\n", value, result);
}

public enum SqrtError { None, NegArg, NaNArg }

private static SqrtError sqrtError = SqrtError.None;

public static SqrtError getSqrtError() { return sqrtError; }

public static double sqrtWithGlobalCode(double d) {
    if (Double.isNaN(d)) { (1)
        sqrtError = SqrtError.NaNArg;
    } else if (d < 0) { (1)
        sqrtError = SqrtError.NegArg;
    }
    return sqrt(d);
}

double result = sqrtWithGlobalCode(value);
if (getSqrtError() != SqrtError.None) { (1)
    System.err.println("Argument illégal (négatif ou égal à NaN).");
} else {
    System.out.printf("sqrt(%f) = %f\n", value, result);
}

public static double sqrtWithException(double d) {
    if (Double.isNaN(d) || d < 0.0) { (1)
        throw new IllegalArgumentException("Argument négatif ou NaN");
    }
    return sqrt(d);
}

double result;
try { (1)
    result = sqrtWithException(value);
    System.out.printf("sqrt(%f) = %f\n", value, result);
} catch (IllegalArgumentException ex) { (1)
    ex.printStackTrace(System.err);
}

public static Optional<Double> sqrtWithOption(double d) {
    return Double.isNaN(d) || d < 0.0 ?
            Optional.empty() :  (1)
            Optional.of(sqrt(d));
}

Optional<Double> result = sqrtWithOption(value); (1)
System.out.printf("sqrt(%f) = %f\n", value, result.orElse(Double.NaN));

try { (1)
    Pile unePile = new Pile(2);
    unePile.empile("azerty");
    unePile.empile("qsdfgh");
    unePile.empile("wxcvbn");
    assert false : "Jamais atteint";
    String str = (String) unePile.depile();
} catch (PileVideException e) { (2)
    assert e.getMessage().equals("La Pile est vide");
} catch (PileException e) { (3)
    assert e.getMessage().equals("La Pile est pleine");
}

/**
 * Empile un élément au sommet de la pile.
 *
 * @param unObjet l'objet à empiler
 * @throws PilePleineException s'il n'y a plus de place
 */
public void empile(Object unObjet) throws PilePleineException {

/**
 * Dépile l'élément se trouvant au sommet de la pile.
 *
 * @return l'élément au sommet
 * @throws PileVideException s'il n'y a pas d'élément
 */
public Object depile() throws PileVideException {

/**
 * Empile un élément au sommet de la pile.
 *
 * @param unObjet l'objet à empiler
 * @throws PilePleineException s'il n'y a plus de place
 */
public void empile(Object unObjet) throws PilePleineException {
    if (sommet == contenu.length) {
        throw new PilePleineException();
    }
    contenu[sommet++] = unObjet;
}

/**
 * Dépile l'élément se trouvant au sommet de la pile.
 *
 * @return l'élément au sommet
 * @throws PileVideException s'il n'y a pas d'élément
 */
public Object depile() throws PileVideException {
    if (sommet == 0) {
        throw new PileVideException();
    }
    return contenu[--sommet];
}

package fr.uvsq.refcardjava.errors;

/**
 * La racine de la hiérarchie d'exception pour la pile.
 *
 * @author Stéphane Lopes
 * @version fév. 2017
 */
class PileException extends Exception {
    /**
     * Initialise une instance de <code>PileException</code>.
     *
     * @param message le message d'erreur.
     */
    public PileException(String message) {
        super(message);
    }
}

package fr.uvsq.refcardjava.errors;

/**
 * Exception pour la pile vide.
 *
 * @author Stéphane Lopes
 * @version fév. 2017
 */
class PileVideException extends PileException {
    /**
     * Initialise une instance de <code>PileVideException</code>.
     */
    public PileVideException() {
        super("La Pile est vide");
    }
}

package fr.uvsq.refcardjava.errors;

/**
 * Exception pour la pile pleine.
 *
 * @author Stéphane Lopes
 * @version fév. 2017
 */
class PilePleineException extends PileException {
    /**
     * Initialise une instance de <code>PilePleineException</code>.
     */
    public PilePleineException() {
        super("La Pile est pleine");
    }
}

/**
 * Copie un fichier caractère par caractère.
 */
private static void textFileCopy(String inFilename, String outFilename) throws IOException {
    try (
            FileReader in = new FileReader(inFilename);
            FileWriter out = new FileWriter(outFilename)
    ) {
        int c;
        while ((c = in.read()) != END_OF_STREAM) {
            out.write(c);
        }
    }
}

/**
 * Copie un fichier en utilisant un buffer.
 */
private static void bufferedTextFileCopy(String inFilename, String outFilename) throws IOException {
    Path inPath = Paths.get(inFilename);
    Path outPath = Paths.get(outFilename);
    try (
            BufferedReader in = Files.newBufferedReader(inPath);
            BufferedWriter out = Files.newBufferedWriter(outPath)
    ) {
        String line;
        while ((line = in.readLine()) != null) {
            out.write(line);
            out.newLine();
        }
    }
}

/**
 * Copie un fichier texte.
 * Le fichier doit être de taille raisonnable car il est chargé en totalité en mémoire.
 */
private static void simpleTextFileCopy(String inFilename, String outFilename) throws IOException {
    Path inPath = Paths.get(inFilename);
    Path outPath = Paths.get(outFilename);
    List<String> lines = Files.readAllLines(inPath);
    Files.write(outPath, lines);
}

/**
 * Copie un fichier octet par octet.
 */
private static void binaryFileCopy(String inFilename, String outFilename) throws IOException {
    try (
            FileInputStream in = new FileInputStream(inFilename);
            FileOutputStream out = new FileOutputStream(outFilename)
    ) {
        int c;
        while ((c = in.read()) != END_OF_STREAM) {
            out.write(c);
        }
    }
}

package fr.uvsq.refcardjava.io;

import java.io.Serializable;

public class Student implements Serializable {
    private int number;
    private String name;

    public Student(int number, String name) {
        this.number = number;
        this.name = name;
    }

    @Override
    public String toString() {
        return String.format("Student{number: %d, name: '%s'}", number, name);
    }
}

private static final long serialVersionUID = 354054054054L;

public interface Collection<E> extends Iterable<E> {
  // Opérations simples
  int size(); // Returns the number of elements in this collection.
  boolean isEmpty(); // Returns true if this collection contains no elements.
  boolean contains(Object element); // Returns true if this collection contains the specified element.
  boolean add(E element); // Ensures that this collection contains the specified element (optional operation).
  boolean remove(Object element); // Removes a single instance of the specified element from this collection, if it is present (optional operation).
  boolean equals(Object o); // Compares the specified object with this collection for equality.
  int hashCode(); // Returns the hash code value for this collection.

  // Opérations de groupe
  boolean containsAll(Collection<?> c); // Returns true if this collection contains all of the elements in the specified collection.
  boolean addAll(Collection<? extends E> c); // Adds all of the elements in the specified collection to this collection (optional operation).
  boolean removeAll(Collection<?> c); // Removes all of this collection's elements that are also contained in the specified collection (optional operation).
  default boolean removeIf(Predicate<? super E> filter); // Removes all of the elements of this collection that satisfy the given predicate.
  boolean retainAll(Collection<?> c); // Retains only the elements in this collection that are contained in the specified collection (optional operation).
  void clear();    // Removes all of the elements from this collection (optional operation).

  // Conversions
  Object[] toArray(); // Returns an array containing all of the elements in this collection.
  <T> T[] toArray(T[] a); // Returns an array containing all of the elements in this collection; the runtime type of the returned array is that of the specified array.
  default <T> T[] toArray(IntFunction<T[]> generator); // Returns an array containing all of the elements in this collection, using the provided generator function to allocate the returned array.

  // Itération et Streams
  Iterator<E> iterator(); // Returns an iterator over the elements in this collection.
  default Spliterator<E> spliterator(); // Creates a Spliterator over the elements in this collection.
  default Stream<E> stream(); // Returns a sequential Stream with this collection as its source.
  default Stream<E> parallelStream(); // Returns a possibly parallel Stream with this collection as its source.
}

public interface List<E> extends Collection<E> {
  // Accès par position
  E get(int index); // Returns the element at the specified position in this list.
  E set(int index, E element); // Replaces the element at the specified position in this list with the specified element (optional operation).
  void add(int index, E element); // Inserts the specified element at the specified position in this list (optional operation).
  E remove(int index); // Removes the element at the specified position in this list (optional operation).
  boolean addAll(int index, Collection<? extends E> c); // Inserts all of the elements in the specified collection into this list at the specified position (optional operation).

  // Opération de groupe
  default void replaceAll(UnaryOperator<E> operator) {
        Objects.requireNonNull(operator);
        final ListIterator<E> li = this.listIterator();
        while (li.hasNext()) {
            li.set(operator.apply(li.next()));
        }
    }
  default void sort(Comparator<? super E> c) {
        Collections.sort(this, c);
    }

  // Recherche
  int indexOf(Object o); // Returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
  int lastIndexOf(Object o); // Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.

  // Itération
  ListIterator<E> listIterator(); // Returns a list iterator over the elements in this list (in proper sequence).
  ListIterator<E> listIterator(int index); // Returns a list iterator over the elements in this list (in proper sequence), starting at the specified position in the list.

  // Vue en sous-liste
  List<E> subList(int from, int to); // Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive.

  // Factories
  static <E> List<E> copyOf(Collection<? extends E> coll); // Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.
  static <E> List<E> of(); // Returns an unmodifiable list containing zero elements.
  static <E> List<E> of(E e1); // Returns an unmodifiable list containing one element.
  static <E> List<E> of(E... elements); // Returns an unmodifiable list containing an arbitrary number of elements.
  static <E> List<E> of(E e1, E e2); // Returns an unmodifiable list containing two elements.
  // [...]
}

public interface ListIterator<E> extends Iterator<E> {
    boolean hasPrevious();
    E previous();

    int nextIndex();
    int previousIndex();

    void set(E o);     // Optionnel
    void add(E o);     // Optionnel
}

public interface Map<K, V> {
  // Opérations de base
  int size();
  boolean isEmpty();
  V put(K key, V value);
  V get(Object key);
  V remove(Object key);
  boolean containsKey(Object key);
  boolean containsValue(Object value);

  // Opérations sur des groupes
  void putAll(Map<? extends K,? extends V> t);
  void clear();

  // Vues
  public Set<K> keySet();
  public Collection<V> values();
  public Set<Map.Entry<K,V>> entrySet();

  // Interface pour entrySet
  public interface Entry<K, V> {
    K getKey();
    V getValue();
    V setValue(V value);
  }

  // Factories
  static <K, V> Map<K, V> copyOf(Map<? extends K,? extends V> map); // Returns an unmodifiable Map containing the entries of the given Map.
  static <K, V> Map.Entry<K, V> entry(K k, V v); // Returns an unmodifiable Map.Entry containing the given key and value.
  static <K, V> Map<K, V> of(); // Returns an unmodifiable map containing zero mappings.
  static <K, V> Map<K, V> of(K k1, V v1); // Returns an unmodifiable map containing a single mapping.
  static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2); // Returns an unmodifiable map containing two mappings.
  // [...]
  static <K, V> Map<K, V> ofEntries(Map.Entry<? extends K, ? extends V>... entries); // Returns an unmodifiable map containing keys and values extracted from the given entries.

  // + des méthodes par défaut
}

/**
 * Produit l'histogramme d'une image.
 *
 * @param img l'image à analyser
 * @return l'histogramme de l'image sous la forme d'un dictionnaire (couleur, fréquence)
 */
public static Map<Integer, Long> frequency(int[][] img) {
    Stream<Integer> imgColors = Arrays.stream(img)
            .flatMap(c -> Arrays.stream(c).boxed());
    Map<Integer, Long> frequencyMap = imgColors.collect(
            Collectors.groupingBy(
                    Function.identity(), Collectors.counting()
            )
    );
    return frequencyMap;
}

int[][] image = {
        {0, 1, 12, 1},
        {1, 12, 12, 12},
        {0, 12, 12, 0}
};

Map<Integer, Long> histogramme = frequency(image);
System.out.println(histogramme); // {0=3, 1=3, 12=6}
System.out.println(histogramme.keySet()); // [0, 1, 12]

Optional<Long> max = histogramme.values().stream()
        .max(Comparator.naturalOrder());
System.out.format("Fréq. max. : %d%n", max.orElse(-1L)); // Fréq. max. : 6

public interface SortedSet<E> extends Set<E> {
  // Vue par intervalle
  SortedSet<E> subSet(E fromElement, E toElement);
  SortedSet<E> headSet(E toElement);
  SortedSet<E> tailSet(E fromElement);

  // Extrémités
  E first();
  E last();

  // Comparateur
  Comparator<? super E> comparator();
}

public interface SortedMap<K, V> extends Map<K, V> {
  // Range-view
  SortedMap<K, V> subMap(K fromKey, K toKey);
  SortedMap<K, V> headMap(K toKey);
  SortedMap<K, V> tailMap(K fromKey);

  // Endpoints
  K firstKey();
  K lastKey();

  // Comparator access
  Comparator<? super K> comparator();
}

Set<Integer> unEnsemble = new HashSet<>();
List<Integer> uneList = new ArrayList<>();
Map<String, String> uneMap = new HashMap<>();

// Créer une liste de taille fixe
List<String> list = Arrays.asList(new String[size]);

// Créer une liste de 1000 éléments initialisés à null
List<Type> l = new ArrayList<>(Collections.nCopies(1000, (Type)null));

// Ajouter 10 fois la chaîne "element" à une collection
uneCollection.addAll(Collections.nCopies(10, "element"));

// Supprimer toutes les occurences de e dans la collection
c.removeAll(Collections.singleton(e));

// Supprimer tous les juristes d'une map
profession.values().removeAll(Collections.singleton(JURISTE));

// Récupérer une liste vide
List<String> s = Collections.emptyList();

List<Integer> l = new ArrayList<Integer>();
// ...
Collections.sort(l);
int pos = Collections.binarySearch(l, key);