объекты: Жена, Будильник, Автомобиль;
переменные: совесть, желание_спать, сытость, злость

если Будильник = 1
{
  перевести(5min);
  перевести(5min);
  выключить();
  встать();
}

если Будильник = 0
{

  пока (совесть < желание_спать)
  {
    спать();
  }

  встать();
}

умыться();

если Жена > 0
{
  приготовить_завтрак(жена);
}

если Жена = 0
{
  приготовить_завтрак(содержимое холодильника[0]);
}

сытость = сытость + 1;

если автомобиль !=1
{
  добраться_до_работы(спать());
}

если автомобиль =1
{
  добраться_до_работы(злость);
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();

        // Вставка элементов
        map.put("One", 1);
        map.put("Two", 2);
        map.put("Three", 3);

        // Поиск элементов
        System.out.println("Value for key 'Two': " + map.get("Two"));

        // Удаление элемента
        map.remove("One");
        System.out.println("Map after removing 'One': " + map);
    }
}

public class Main {
    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();

        // Эти два разных ключа могут дать одинаковый хэш-код
        map.put(1, "One");
        map.put(17, "Seventeen");

        // Оба ключа будут находиться в одном бакете
        System.out.println("Value for key 1: " + map.get(1));
        System.out.println("Value for key 17: " + map.get(17));
    }
}

public class ArithmeticChallenge {
    public static void main(String[] args) {
        int result = mysteriousArithmetic(3, 2);
        System.out.println(result);
    }

    public static int mysteriousArithmetic(int a, int b) {
        int result = 0;
        for (int i = 1; i <= a; i++) {
            result += (i % 2 == 0) ? (i * b) : (i + b);
        }
        return result;
    }
}

public V put(K key, V value) {
    // Вычисление хэш-кода
    int hash = hash(key);
    // Вычисление индекса бакета
    int bucketIndex = indexFor(hash, table.length);
    // Поиск существующего ключа и обновление значения
    for (Entry<K, V> e = table[bucketIndex]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            V oldValue = e.value;
            e.value = value;
            return oldValue;
        }
    }
    // Вставка новой пары ключ-значение
    addEntry(hash, key, value, bucketIndex);
    return null;
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        map.put("Two", 2);
        System.out.println(map); // Output: {One=1, Two=2}
    }
}

public V get(Object key) {
    // Вычисление хэш-кода
    int hash = hash(key);
    // Поиск в бакете
    for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            return e.value;
        }
    }
    return null;
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        System.out.println(map.get("One")); // Output: 1
    }
}

public V remove(Object key) {
    Entry<K, V> e = removeEntryForKey(key);
    return (e == null ? null : e.value);
}

private Entry<K, V> removeEntryForKey(Object key) {
    // Вычисление хэш-кода
    int hash = hash(key);
    int bucketIndex = indexFor(hash, table.length);
    Entry<K, V> prev = table[bucketIndex];
    Entry<K, V> e = prev;

    while (e != null) {
        Entry<K, V> next = e.next;
        Object k;
        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
            if (prev == e) {
                table[bucketIndex] = next;
            } else {
                prev.next = next;
            }
            return e;
        }
        prev = e;
        e = next;
    }
    return null;
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        map.put("Two", 2);
        map.remove("One");
        System.out.println(map); // Output: {Two=2}
    }
}

public boolean containsKey(Object key) {
    return getEntry(key) != null;
}

final Entry<K, V> getEntry(Object key) {
    // Вычисление хэш-кода
    int hash = (key == null) ? 0 : hash(key);
    // Поиск в бакете
    for (Entry<K, V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
        Object k;
        if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
            return e;
        }
    }
    return null;
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        System.out.println(map.containsKey("One")); // Output: true
        System.out.println(map.containsKey("Two")); // Output: false
    }
}

public boolean containsValue(Object value) {
    if (value == null) {
        for (Entry<K, V> e : table)
            for (Entry<K, V> ee = e; ee != null; ee = ee.next)
                if (ee.value == null)
                    return true;
    } else {
        for (Entry<K, V> e : table)
            for (Entry<K, V> ee = e; ee != null; ee = ee.next)
                if (value.equals(ee.value))
                    return true;
    }
    return false;
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        System.out.println(map.containsValue(1)); // Output: true
        System.out.println(map.containsValue(2)); // Output: false
    }
}

public int size() {
    return size;
}
Пример использования:
java
Копировать код
import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        map.put("Two", 2);
        System.out.println(map.size()); // Output: 2
    }
}

public void clear() {
    Entry<K, V>[] tab = table;
    for (int i = 0; i < tab.length; i++)
        tab[i] = null;
    size = 0;
}

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap<>();
        map.put("One", 1);
        map.put("Two", 2);
        map.clear();
        System.out.println(map.size()); // Output: 0
    }
}

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

public class ConcurrentHashMapExample {
    public static void main(String[] args) {
        // Создание ConcurrentHashMap
        Map<String, Integer> map = new ConcurrentHashMap<>();
        // Добавление элементов
        map.put("Apple", 50);
        map.put("Banana", 30);
        map.put("Orange", 20);
        // Получение значения по ключу
        System.out.println("Price of Apple: " + map.get("Apple"));
        // Проверка наличия ключа
        if (map.containsKey("Banana")) {
            System.out.println("Banana is in the list.");
        }
        // Удаление элемента
        map.remove("Orange");
        // Перебор элементов
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
        // Использование атомарных операций
        map.putIfAbsent("Grapes", 40);
        map.replace("Banana", 35);
        // Перебор элементов после атомарных операций
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

import java.util.HashMap;
import java.util.Map;

public class HashMapChallenge {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();
        map.put("one", 1);
        map.put("two", 2);
        map.put("three", 3);
        map.put("four", 4);
        
        int result = processMap(map);
        System.out.println(result);
    }

    public static int processMap(Map<String, Integer> map) {
        int sum = 0;
        for (Map.Entry<String, Integer> entry : map.entrySet()) {
            if (entry.getKey().length() % 2 == 0) {
                sum += entry.getValue() * 2;
            } else {
                sum += entry.getValue() * 3;
            }
        }
        return sum;
    }
}

static class Node<K,V> implements Map.Entry<K,V> {
    final int hash;
    final K key;
    volatile V value;
    volatile Node<K,V> next;

    Node(int hash, K key, V value, Node<K,V> next) {
        this.hash = hash;
        this.key = key;
        this.value = value;
        this.next = next;
    }

    public final K getKey() {
        return key;
    }

    public final V getValue() {
        return value;
    }

    public final String toString() {
        return key + "=" + value;
    }

    public final int hashCode() {
        return key.hashCode() ^ value.hashCode();
    }

    public final V setValue(V value) {
        throw new UnsupportedOperationException();
    }

    public final boolean equals(Object o) {
        Object k, v, u;
        Map.Entry<?,?> e;
        return ((o instanceof Map.Entry) &&
                (k = (e = (Map.Entry<?,?>)o).getKey()) != null &&
                (v = e.getValue()) != null &&
                (k == key || k.equals(key)) &&
                (v == (u = value) || v.equals(u)));
    }
}

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    int hash = spread(key.hashCode());
    int binCount = 0;
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        if (tab == null || (n = tab.length) == 0)
            tab = initTable();
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        else if ((fh = f.hash) == MOVED)
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            synchronized (f) {
                if (tabAt(tab, i) == f) {
                    if (fh >= 0) {
                        binCount = 1;
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.value;
                                if (!onlyIfAbsent)
                                    e.value = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                           value, null);
                                break;
                            }
                        }
                    }
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                              value)) != null) {
                            oldVal = p.value;
                            if (!onlyIfAbsent)
                                p.value = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    addCount(1L, binCount);
    return null;
}

import java.util.LinkedHashMap;
import java.util.Map;

public class LinkedHashMapExample {
    public static void main(String[] args) {
        // Создание LinkedHashMap с порядком вставки
        LinkedHashMap<String, Integer> insertionOrderMap = new LinkedHashMap<>();
        
        // Добавление элементов
        insertionOrderMap.put("Apple", 50);
        insertionOrderMap.put("Banana", 30);
        insertionOrderMap.put("Orange", 20);

        // Перебор элементов в порядке вставки
        System.out.println("Insertion Order:");
        for (Map.Entry<String, Integer> entry : insertionOrderMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }

        // Создание LinkedHashMap с порядком доступа
        LinkedHashMap<String, Integer> accessOrderMap = new LinkedHashMap<>(16, 0.75f, true);
        
        // Добавление элементов
        accessOrderMap.put("Apple", 50);
        accessOrderMap.put("Banana", 30);
        accessOrderMap.put("Orange", 20);

        // Доступ к элементу, что изменит его порядок
        accessOrderMap.get("Banana");

        // Перебор элементов в порядке доступа
        System.out.println("\nAccess Order:");
        for (Map.Entry<String, Integer> entry : accessOrderMap.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }
}

static class Entry<K, V> extends HashMap.Node<K, V> {
    Entry<K, V> before, after;

    Entry(int hash, K key, V value, HashMap.Node<K, V> next) {
        super(hash, key, value, next);
    }
}

transient LinkedHashMap.Entry<K, V> head;
transient LinkedHashMap.Entry<K, V> tail;