happy's questions

Estou aprendendo sobre HashMaps em Java e estou confuso sobre a ordem de iteração. A documentação afirma que HashMap não garante nenhuma ordem de iteração específica, mas no meu teste simples, a ordem parece permanecer consistente:

Esta classe não garante a ordem do mapa; em particular, não garante que a ordem permanecerá constante ao longo do tempo. Documentação Java 11

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<String, String> dishes = new HashMap<>();

        // Adding more elements with complex keys
        dishes.put("dish-1234", "Pho");
        dishes.put("dish-5678", "Spicy Beef Noodle Soup");
        dishes.put("dish-9012", "Broken Rice");
        dishes.put("dish-3456", "Banh Mi");
        dishes.put("dish-7890", "Hu Tieu");
        dishes.put("dish-2345", "Mi Quang");
        dishes.put("dish-6789", "Crab Noodle Soup");
        dishes.put("dish-0123", "Rolled Rice Cake");

        System.out.println("First time:");
        dishes.forEach((id, name) -> System.out.println(id + ": " + name));

        // Create new HashMap with same data
        HashMap<String, String> dishes2 = new HashMap<>();
        dishes2.putAll(dishes);

        System.out.println("\nSecond time (New HashMap):");
        dishes2.forEach((id, name) -> System.out.println(id + ": " + name));
    }
}

Saída:

First time:
dish-7890: Hu Tieu
dish-3456: Banh Mi
dish-2345: Mi Quang
dish-1234: Pho
dish-0123: Rolled Rice Cake
dish-5678: Spicy Beef Noodle Soup
dish-9012: Broken Rice
dish-6789: Crab Noodle Soup

Second time (New HashMap):
dish-7890: Hu Tieu
dish-3456: Banh Mi
dish-2345: Mi Quang
dish-1234: Pho
dish-0123: Rolled Rice Cake
dish-5678: Spicy Beef Noodle Soup
dish-9012: Broken Rice
dish-6789: Crab Noodle Soup

Entendo que se eu precisar de ordem garantida, devo usar LinkedHashMap ou TreeMap, mas estou tentando entender o comportamento real do HashMap. Li alguma documentação falando sobre redimensionamento e re-hash, talvez seja muito difícil de entender para mim.

Também li alguns posts falando desse problema, mas não consigo reproduzir

• Por que o HashMap não garante que a ordem do mapa permanecerá constante ao longo do tempo
• Causa da diferença na ordem de inserção de HashMap e LinkedHashMap

Como posso entender isso?

Estou tentando entender o comportamento de substituição de método, chamadas de construtor e sombreamento de variável na herança Java. Tenho o seguinte código

class Base {
    int id = 1000; //Line n1

    Base() {
        Base(); //Line n2
    }

    void Base() { //Line n3
        System.out.println(++id); //Line n4
    }
}

class Derived extends Base {
    int id = 2000; //Line n5

    Derived() {} //Line n6

    void Base() { //Line n7
        System.out.println(--id); //Line n8
    }
}

public class Test {
    public static void main(String[] args) {
        Base base = new Derived(); //Line n9
    }
}

Quando executo esse código, ele retorna -1 .

Entendo que Derived estende Base , e ambas as classes têm uma variável id e um método Base() . A ordem é a seguinte

1. chamar construtor de Derived
2. chamar construtor de Base
3. chamar o método Base(), devido à substituição do método, o método na classe filha é executado.

Portanto, na minha opinião, o resultado será 1001.

Estou tentando entender por que há uma diferença quando mudo de y.addAll(x) para x.addAll(y) no trecho de código abaixo:

List<Integer> result = List.of(1, 2)
    .parallelStream() 
    .collect(
        ArrayList::new,
        (x, y) -> x.add(y),
        (x, y) -> y.addAll(x)
    );
System.out.println(result);

Eu sei que quando uso paraleloStream(), há mais de um thread sendo executado por vez.

collect() possui três parâmetros; os dois primeiros parâmetros eu entendo. Com o terceiro parâmetro, sei que x, y são substreams e são ArrayLists, mas não entendo por que os resultados são diferentes em cada caso. Eu esperava que eles fossem iguais.

• (x, y) -> y.addAll(x) // saída: [1]

• (x, y) -> x.addAll(y) // saída: [1, 2]