import type { Collection } from './Collection';
import type { JavaMap } from './JavaMap';
import type { JavaMapEntry } from './JavaMapEntry';
import type { JavaSet } from './JavaSet';
import type { Cloneable } from '../../java/lang/Cloneable';
import type { Serializable } from '../../java/io/Serializable';
import type { JavaFunction } from './function/JavaFunction';
import { JavaObject } from '../../java/lang/JavaObject';
/**
 * Eine Typescript Implementierung, welche im Transpiler das Verhalten der Java-Klasse java.util.HashMap emuliert.
 */
export declare class HashMap<K, V> extends JavaObject implements JavaMap<K, V>, Cloneable, Serializable {
    protected readonly _map: Map<number, Array<JavaMapEntry<K, V>>>;
    protected _size: number;
    /**
     * Erstellt einen neue leere Hash-Map
     */
    constructor();
    /**
     * Gibt die Anzahl der Werte in der Hash-Map zurück.
     *
     * @returns die Anzahl der Werte in der Hash-Map
     */
    size(): number;
    /**
     * Gibt zurück, ob die Hash-Map leer ist oder nicht
     *
     * @returns true, wenn die Hash-Map leer ist
     */
    isEmpty(): boolean;
    /**
     * Prüft, ob ein Wert für den Schlüsselwert key in der Hash-Map
     * enthalten ist.
     *
     * @param key   der Schlüsselwert
     *
     * @returns true, wen ein Wert enthalten ist
     */
    containsKey(key: K): boolean;
    /**
     * Prüft, ob die Hash-Map den Wert beinhaltet. Die Methode ist
     * langsam, da die alle Einträge traversiert werden müssen.
     *
     * @param value   der zu prüfende Wert.
     *
     * @returns true, wenn der Wert enthalten ist
     */
    containsValue(value: V): boolean;
    /**
     * Bestimmt den Wert in der Hash-Map, der dem übergebenen Schlüsselwert zugeordnet
     * ist. Gibt null zurück, wenn kein Schlüsselwert zugeordnet ist. Wir für den
     * Schlüsselwert null übergeben, so wird immer null zurückgegeben.
     *
     * @param key   der Schlüsselwert
     *
     * @returns der Wert in der Hash-Map oder null
     */
    get(key: any | null): V | null;
    /**
     * Fügt den Wert value für den Schlüsselwert key in die Hash-Map ein.
     * Ist für den Schlüsselwert bereits ein Wert enthalten, so wird dieser
     * ersetzt und der ursprüngliche Wert wird zurückgegeben.
     *
     * @param key     der Schlüsselwert
     * @param value   der einzufügende Wert
     *
     * @returns der ursprüngliche Wert oder null
     */
    put(key: K, value: V): V | null;
    /**
     * Prüft, ob dem übergebenen Schlüsselwert ein Wert zugeordnet ist.
     * Ist dies der Fall, so wird er aus der Hash-Map entfernt und zurückgeben.
     * Ist kein Wert zugeordnet, so wird null zurückgegeben.
     *
     * @param key   der Schlüsselwert
     *
     * @returns der entfernte Wert oder null
     */
    remove(key: any): V | null;
    /**
     * Fügt alle Werte aus der übergenen Map in diese Map ein. Bereits vorhandene
     * Werte für Schlüsselwerte aus der übergebenen Map werden ggf. ersetzt.
     *
     * @param m   die Map, deren Werte eingefügt werden sollen
     */
    putAll(m: JavaMap<K, V>): void;
    /**
     * Entfernt alle Einträge aus dieser Hash-Map.
     */
    clear(): void;
    /**
     * Gibt das Key-Set für diese Hash-Map zurück.
     *
     * @returns das Set mit den Schlüsselwerten.
     */
    keySet(): JavaSet<K>;
    /**
     * Gibt eine Collection mit den Werten dieser Hash-Map zurück.
     *
     * @returns die Collection mit den Werten
     */
    values(): Collection<V>;
    /**
     * Gibt eine Menge mit allen Einträgen in dieser Map zurück.
     *
     * @returns das Set mit den Einträgen
     */
    entrySet(): JavaSet<JavaMapEntry<K, V>>;
    equals(o: any): boolean;
    hashCode(): number;
    computeIfAbsent(key: K, mappingFunction: JavaFunction<K, V>): V | null;
    [Symbol.iterator](): Iterator<JavaMapEntry<K, V>>;
    transpilerCanonicalName(): string;
    isTranspiledInstanceOf(name: string): boolean;
}
export declare function cast_java_util_HashMap<K, V>(obj: unknown): HashMap<K, V>;
//# sourceMappingURL=HashMap.d.ts.map