Dictionary<Key,Value>

Overview

Location

Reference:
- Silver.dll .NET, .NET Standard 2.0
- silver.jar Cooper
- Silver.fx Island
- libSilver.fx Toffee
Namespace: Swift
Ancestry:
- ValueType | Dictionary<Key,Value> .NET, .NET Standard 2.0
- ValueType | Dictionary<Key,Value> Island

constructor

constructor (not nullable Dictionary<not nullable Key, not nullable Value>)

constructor(dictionary: not nullable Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value>(Dictionary<not nullable Key, not nullable Value>! dictionary)

init(_ dictionary: NSDictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value>(HashMap<Key, Value> dictionary)

Sub New(dictionary As Dictionary<not nullable Key, not nullable Value>)

Parameters:

dictionary:

constructor(value: Dictionary<Key, Value>)

Dictionary<Key,Value>(Dictionary<Key, Value> value)

init(_ value: Dictionary<Key, Value>)

Dictionary<Key,Value>(Dictionary<Key, Value> value)

Sub New(value As Dictionary<Key, Value>)

Parameters:

value:

constructor withCopy(var original: not nullable Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withCopy(ref Dictionary<not nullable Key, not nullable Value>! original)

init(copy original: inout Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withCopy(__ref Dictionary<Key, Value> original)

Sub New withCopy(ByRef original As Dictionary<not nullable Key, not nullable Value>)

Parameters:

original:

constructor withDictionaryLiteral(array of not nullable tuple of (not nullable Key, not nullable Value))

constructor withDictionaryLiteral(params elements: array of not nullable tuple of (not nullable Key, not nullable Value))

Dictionary<Key,Value> withDictionaryLiteral(params (Key!, Value!)![] elements)

init(dictionaryLiteral elements: tuple of (not nullable Key, not nullable Value)...)

Dictionary<Key,Value> withDictionaryLiteral(Tuple2<Key, Value>[]... elements)

Sub New withDictionaryLiteral(ParamArray elements As Tuple (Of Key, Value)())

Parameters:

elements:

constructor withItems(items: not nullable Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withItems(Dictionary<not nullable Key, not nullable Value>! items)

init(items: Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withItems(Dictionary<Key, Value> items)

Sub New withItems(items As Dictionary<not nullable Key, not nullable Value>)

Parameters:

items:

constructor withMinimumCapacity(not nullable Int)

constructor withMinimumCapacity(minimumCapacity: not nullable Int)

Dictionary<Key,Value> withMinimumCapacity(Int! minimumCapacity)

init(minimumCapacity: Int)

Dictionary<Key,Value> withMinimumCapacity(Int minimumCapacity)

Sub New withMinimumCapacity(minimumCapacity As Int)

Parameters:

minimumCapacity:

clear Cooper

clone Cooper

Function clone() As Object

compute Cooper

method compute(arg1: Key; arg2: BiFunction<Key, not nullable Key, not nullable Value>): Value

Value compute(Key arg1, BiFunction<Key, not nullable Key, not nullable Value> arg2)

func compute(_ arg1: Key, _ arg2: BiFunction<Key, not nullable Key, not nullable Value>) -> Value

Value compute(Key arg1, BiFunction<Key, Key, Value> arg2)

Function compute(arg1 As Key, arg2 As BiFunction<Key, not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:

computeIfAbsent Cooper

method computeIfAbsent(arg1: Key; arg2: Function<not nullable Key, not nullable Value>): Value

Value computeIfAbsent(Key arg1, Function<not nullable Key, not nullable Value> arg2)

func computeIfAbsent(_ arg1: Key, _ arg2: Function<not nullable Key, not nullable Value>) -> Value

Value computeIfAbsent(Key arg1, Function<Key, Value> arg2)

Function computeIfAbsent(arg1 As Key, arg2 As Function<not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:

computeIfPresent Cooper

method computeIfPresent(arg1: Key; arg2: BiFunction<Key, not nullable Key, not nullable Value>): Value

Value computeIfPresent(Key arg1, BiFunction<Key, not nullable Key, not nullable Value> arg2)

func computeIfPresent(_ arg1: Key, _ arg2: BiFunction<Key, not nullable Key, not nullable Value>) -> Value

Value computeIfPresent(Key arg1, BiFunction<Key, Key, Value> arg2)

Function computeIfPresent(arg1 As Key, arg2 As BiFunction<Key, not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:

containsKey Cooper

method containsKey(arg1: Object): not nullable Bool

Bool! containsKey(Object arg1)

func containsKey(_ arg1: Object) -> Bool

Bool containsKey(Object arg1)

Function containsKey(arg1 As Object) As Bool

Parameters:

arg1:

containsValue Cooper

method containsValue(arg1: Object): not nullable Bool

Bool! containsValue(Object arg1)

func containsValue(_ arg1: Object) -> Bool

Bool containsValue(Object arg1)

Function containsValue(arg1 As Object) As Bool

Parameters:

arg1:

count virtual

property count: not nullable Int read;

ReadOnly Property count() As Int

description override

method description: not nullable NativeString

NativeString! description()

func description() -> NativeString

NativeString description()

Function description() As NativeString

entrySet Cooper

method entrySet: Set<Map<not nullable Key, not nullable Value>>

Set<Map<not nullable Key, not nullable Value>> entrySet()

func entrySet() -> Set<Map<not nullable Key, not nullable Value>>

Set<Map<Key, Value>> entrySet()

Function entrySet() As Set<Map<not nullable Key, not nullable Value>>

equals Cooper

method equals(arg1: Object): not nullable Bool

Bool! equals(Object arg1)

func equals(_ arg1: Object) -> Bool

Function equals(arg1 As Object) As Bool

Parameters:

arg1:

Equals .NET, .NET Standard 2.0

method Equals(other: Object): not nullable Bool

Bool! Equals(Object other)

func Equals(_ other: Object) -> Bool

Function Equals(other As Object) As Bool

Parameters:

other:

forEach Cooper

method forEach(arg1: BiConsumer<Key, Value>)

void forEach(BiConsumer<Key, Value> arg1)

func forEach(_ arg1: BiConsumer<Key, Value>)

void forEach(BiConsumer<Key, Value> arg1)

Sub forEach(arg1 As BiConsumer<Key, Value>)

Parameters:

arg1:

get Cooper

method get(arg1: Object): Value

func get(_ arg1: Object) -> Value

Function get(arg1 As Object) As Value

Parameters:

arg1:

GetEnumerator virtual .NET, .NET Standard 2.0, Island

method GetEnumerator: IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)>

IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)> GetEnumerator()

func GetEnumerator() -> IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)>

Function GetEnumerator() As IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)>

getOrDefault Cooper

method getOrDefault(arg1: Object; arg2: Value): Value

Value getOrDefault(Object arg1, Value arg2)

func getOrDefault(_ arg1: Object, _ arg2: Value) -> Value

Value getOrDefault(Object arg1, Value arg2)

Function getOrDefault(arg1 As Object, arg2 As Value) As Value

Parameters:

arg1:
arg2:

GetSequence virtual

method GetSequence: not nullable IEnumerable<not nullable tuple of (not nullable Key, not nullable Value)>

IEnumerable<not nullable tuple of (not nullable Key, not nullable Value)>! GetSequence()

func GetSequence() -> INSFastEnumeration<not nullable tuple of (not nullable Key, not nullable Value)>

Iterable<Tuple2<Key, Value>> GetSequence()

Function GetSequence() As IEnumerable<not nullable tuple of (not nullable Key, not nullable Value)>

hashCode Cooper

method hashCode: not nullable Integer

func hashCode() -> Integer

Function hashCode() As Integer

isEmpty Cooper

method isEmpty: not nullable Bool

Function isEmpty() As Bool

isEmpty virtual

property isEmpty: not nullable Bool read;

var isEmpty: Bool { get{} }

ReadOnly Property isEmpty() As Bool

isEqual override Toffee

func isEqual(_ other: Object) -> Bool

Parameters:

other:

Item virtual

property Item[key: not nullable Key]: nullable Value read write;

Value? Item[Key! key] { get; set; }

subscript Item(_ key: Key) -> Value? { get{} set{} }

Value Item[Key key] { __get; __set; }

Property Item(key As Key) As Value?

iterator Cooper

method iterator: Iterator<not nullable Tuple2<not nullable Key, not nullable Value>>

Iterator<not nullable Tuple2<not nullable Key, not nullable Value>> iterator()

func iterator() -> Iterator<not nullable Tuple2<not nullable Key, not nullable Value>>

Iterator<Tuple2<Key, Value>> iterator()

Function iterator() As Iterator<not nullable Tuple2<not nullable Key, not nullable Value>>

keys virtual

property keys: not nullable IEnumerable<not nullable Key> read;

IEnumerable<not nullable Key>! keys { get; }

// .NET, .NET Standard 2.0, Island
var keys: IEnumerable<not nullable Key> { get{} }
// Toffee
var keys: INSFastEnumeration<not nullable Key> { get{} }

Iterable<Key> keys { __get; }

ReadOnly Property keys() As IEnumerable<not nullable Key>

keySet Cooper

method keySet: Set<not nullable Key>

Set<not nullable Key> keySet()

func keySet() -> Set<not nullable Key>

Function keySet() As Set<not nullable Key>

merge Cooper

method merge(arg1: Key; arg2: Value; arg3: BiFunction<Key, not nullable Key, not nullable Value>): Value

Value merge(Key arg1, Value arg2, BiFunction<Key, not nullable Key, not nullable Value> arg3)

func merge(_ arg1: Key, _ arg2: Value, _ arg3: BiFunction<Key, not nullable Key, not nullable Value>) -> Value

Value merge(Key arg1, Value arg2, BiFunction<Key, Key, Value> arg3)

Function merge(arg1 As Key, arg2 As Value, arg3 As BiFunction<Key, not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:
arg3:

platformDictionary virtual

property platformDictionary: not nullable Dictionary<not nullable Key, not nullable Value> read;

Dictionary<not nullable Key, not nullable Value>! platformDictionary { get; }

// .NET, .NET Standard 2.0, Island
var platformDictionary: Dictionary<not nullable Key, not nullable Value> { get{} }
// Toffee
var platformDictionary: NSMutableDictionary<not nullable Key, not nullable Value> { get{} }

HashMap<Key, Value> platformDictionary { __get; }

ReadOnly Property platformDictionary() As Dictionary<not nullable Key, not nullable Value>

put Cooper

method put(arg1: Key; arg2: Value): Value

Value put(Key arg1, Value arg2)

func put(_ arg1: Key, _ arg2: Value) -> Value

Value put(Key arg1, Value arg2)

Function put(arg1 As Key, arg2 As Value) As Value

Parameters:

arg1:
arg2:

putAll Cooper

method putAll(arg1: Map<Key, Value>)

void putAll(Map<Key, Value> arg1)

func putAll(_ arg1: Map<Key, Value>)

void putAll(Map<Key, Value> arg1)

Sub putAll(arg1 As Map<Key, Value>)

Parameters:

arg1:

putIfAbsent Cooper

method putIfAbsent(arg1: Key; arg2: Value): Value

Value putIfAbsent(Key arg1, Value arg2)

func putIfAbsent(_ arg1: Key, _ arg2: Value) -> Value

Value putIfAbsent(Key arg1, Value arg2)

Function putIfAbsent(arg1 As Key, arg2 As Value) As Value

Parameters:

arg1:
arg2:

remove (Object): Value Cooper

method remove(arg1: Object): Value

Value remove(Object arg1)

func remove(_ arg1: Object) -> Value

Value remove(Object arg1)

Function remove(arg1 As Object) As Value

Parameters:

arg1:

remove (Object, Object): not nullable Bool Cooper

method remove(arg1: Object; arg2: Object): not nullable Bool

Bool! remove(Object arg1, Object arg2)

func remove(_ arg1: Object, _ arg2: Object) -> Bool

Bool remove(Object arg1, Object arg2)

Function remove(arg1 As Object, arg2 As Object) As Bool

Parameters:

arg1:
arg2:

removeAll virtual

method removeAll keepCapacity(keepCapacity: not nullable Bool := false)

void removeAll keepCapacity(Bool! keepCapacity = false)

func removeAll(keepCapacity: Bool = false)

void removeAll keepCapacity(Bool keepCapacity)

Sub removeAll keepCapacity(keepCapacity As Bool = false)

Parameters:

keepCapacity:

removeValue virtual

method removeValue forKey(key: not nullable Key): nullable Value

Value? removeValue forKey(Key! key)

func removeValue(forKey key: Key) -> Value?

Value removeValue forKey(Key key)

Function removeValue forKey(key As Key) As Value?

Parameters:

key:

replace (Key, Value): Value Cooper

method replace(arg1: Key; arg2: Value): Value

Value replace(Key arg1, Value arg2)

func replace(_ arg1: Key, _ arg2: Value) -> Value

Value replace(Key arg1, Value arg2)

Function replace(arg1 As Key, arg2 As Value) As Value

Parameters:

arg1:
arg2:

replace (Key, Value, Value): not nullable Bool Cooper

method replace(arg1: Key; arg2: Value; arg3: Value): not nullable Bool

Bool! replace(Key arg1, Value arg2, Value arg3)

func replace(_ arg1: Key, _ arg2: Value, _ arg3: Value) -> Bool

Bool replace(Key arg1, Value arg2, Value arg3)

Function replace(arg1 As Key, arg2 As Value, arg3 As Value) As Bool

Parameters:

arg1:
arg2:
arg3:

replaceAll Cooper

method replaceAll(arg1: BiFunction<Key, Key, Value>)

void replaceAll(BiFunction<Key, Key, Value> arg1)

func replaceAll(_ arg1: BiFunction<Key, Key, Value>)

void replaceAll(BiFunction<Key, Key, Value> arg1)

Sub replaceAll(arg1 As BiFunction<Key, Key, Value>)

Parameters:

arg1:

size Cooper

method size: not nullable Integer

Function size() As Integer

toString Cooper

func toString() -> String

Function toString() As String

updateValue virtual

method updateValue(value: not nullable Value) forKey(key: not nullable Key): nullable Value

Value? updateValue(Value! value) forKey(Key! key)

func updateValue(_ value: Value, forKey key: Key) -> Value?

Value updateValue(Value value) forKey(Key key)

Function updateValue(value As Value) forKey(key As Key) As Value?

Parameters:

value:
key:

values Cooper

method values: Collection<not nullable Value>

Collection<not nullable Value> values()

func values() -> Collection<not nullable Value>

Collection<Value> values()

Function values() As Collection<not nullable Value>

values virtual

property values: not nullable IEnumerable<not nullable Value> read;

IEnumerable<not nullable Value>! values { get; }

// .NET, .NET Standard 2.0, Island
var values: IEnumerable<not nullable Value> { get{} }
// Toffee
var values: INSFastEnumeration<not nullable Value> { get{} }

Iterable<Value> values { __get; }

ReadOnly Property values() As IEnumerable<not nullable Value>

count virtual

property count: not nullable Int read;

ReadOnly Property count() As Int

isEmpty virtual

property isEmpty: not nullable Bool read;

var isEmpty: Bool { get{} }

ReadOnly Property isEmpty() As Bool

Item virtual

property Item[key: not nullable Key]: nullable Value read write;

Value? Item[Key! key] { get; set; }

subscript Item(_ key: Key) -> Value? { get{} set{} }

Value Item[Key key] { __get; __set; }

Property Item(key As Key) As Value?

keys virtual

property keys: not nullable IEnumerable<not nullable Key> read;

IEnumerable<not nullable Key>! keys { get; }

// .NET, .NET Standard 2.0, Island
var keys: IEnumerable<not nullable Key> { get{} }
// Toffee
var keys: INSFastEnumeration<not nullable Key> { get{} }

Iterable<Key> keys { __get; }

ReadOnly Property keys() As IEnumerable<not nullable Key>

platformDictionary virtual

property platformDictionary: not nullable Dictionary<not nullable Key, not nullable Value> read;

Dictionary<not nullable Key, not nullable Value>! platformDictionary { get; }

// .NET, .NET Standard 2.0, Island
var platformDictionary: Dictionary<not nullable Key, not nullable Value> { get{} }
// Toffee
var platformDictionary: NSMutableDictionary<not nullable Key, not nullable Value> { get{} }

HashMap<Key, Value> platformDictionary { __get; }

ReadOnly Property platformDictionary() As Dictionary<not nullable Key, not nullable Value>

values virtual

property values: not nullable IEnumerable<not nullable Value> read;

IEnumerable<not nullable Value>! values { get; }

// .NET, .NET Standard 2.0, Island
var values: IEnumerable<not nullable Value> { get{} }
// Toffee
var values: INSFastEnumeration<not nullable Value> { get{} }

Iterable<Value> values { __get; }

ReadOnly Property values() As IEnumerable<not nullable Value>

constructor

constructor (not nullable Dictionary<not nullable Key, not nullable Value>)

constructor(dictionary: not nullable Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value>(Dictionary<not nullable Key, not nullable Value>! dictionary)

init(_ dictionary: NSDictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value>(HashMap<Key, Value> dictionary)

Sub New(dictionary As Dictionary<not nullable Key, not nullable Value>)

Parameters:

dictionary:

constructor(value: Dictionary<Key, Value>)

Dictionary<Key,Value>(Dictionary<Key, Value> value)

init(_ value: Dictionary<Key, Value>)

Dictionary<Key,Value>(Dictionary<Key, Value> value)

Sub New(value As Dictionary<Key, Value>)

Parameters:

value:

constructor withCopy(var original: not nullable Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withCopy(ref Dictionary<not nullable Key, not nullable Value>! original)

init(copy original: inout Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withCopy(__ref Dictionary<Key, Value> original)

Sub New withCopy(ByRef original As Dictionary<not nullable Key, not nullable Value>)

Parameters:

original:

constructor withDictionaryLiteral(array of not nullable tuple of (not nullable Key, not nullable Value))

constructor withDictionaryLiteral(params elements: array of not nullable tuple of (not nullable Key, not nullable Value))

Dictionary<Key,Value> withDictionaryLiteral(params (Key!, Value!)![] elements)

init(dictionaryLiteral elements: tuple of (not nullable Key, not nullable Value)...)

Dictionary<Key,Value> withDictionaryLiteral(Tuple2<Key, Value>[]... elements)

Sub New withDictionaryLiteral(ParamArray elements As Tuple (Of Key, Value)())

Parameters:

elements:

constructor withItems(items: not nullable Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withItems(Dictionary<not nullable Key, not nullable Value>! items)

init(items: Dictionary<not nullable Key, not nullable Value>)

Dictionary<Key,Value> withItems(Dictionary<Key, Value> items)

Sub New withItems(items As Dictionary<not nullable Key, not nullable Value>)

Parameters:

items:

constructor withMinimumCapacity(not nullable Int)

constructor withMinimumCapacity(minimumCapacity: not nullable Int)

Dictionary<Key,Value> withMinimumCapacity(Int! minimumCapacity)

init(minimumCapacity: Int)

Dictionary<Key,Value> withMinimumCapacity(Int minimumCapacity)

Sub New withMinimumCapacity(minimumCapacity As Int)

Parameters:

minimumCapacity:

clear Cooper

clone Cooper

Function clone() As Object

compute Cooper

method compute(arg1: Key; arg2: BiFunction<Key, not nullable Key, not nullable Value>): Value

Value compute(Key arg1, BiFunction<Key, not nullable Key, not nullable Value> arg2)

func compute(_ arg1: Key, _ arg2: BiFunction<Key, not nullable Key, not nullable Value>) -> Value

Value compute(Key arg1, BiFunction<Key, Key, Value> arg2)

Function compute(arg1 As Key, arg2 As BiFunction<Key, not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:

computeIfAbsent Cooper

method computeIfAbsent(arg1: Key; arg2: Function<not nullable Key, not nullable Value>): Value

Value computeIfAbsent(Key arg1, Function<not nullable Key, not nullable Value> arg2)

func computeIfAbsent(_ arg1: Key, _ arg2: Function<not nullable Key, not nullable Value>) -> Value

Value computeIfAbsent(Key arg1, Function<Key, Value> arg2)

Function computeIfAbsent(arg1 As Key, arg2 As Function<not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:

computeIfPresent Cooper

method computeIfPresent(arg1: Key; arg2: BiFunction<Key, not nullable Key, not nullable Value>): Value

Value computeIfPresent(Key arg1, BiFunction<Key, not nullable Key, not nullable Value> arg2)

func computeIfPresent(_ arg1: Key, _ arg2: BiFunction<Key, not nullable Key, not nullable Value>) -> Value

Value computeIfPresent(Key arg1, BiFunction<Key, Key, Value> arg2)

Function computeIfPresent(arg1 As Key, arg2 As BiFunction<Key, not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:

containsKey Cooper

method containsKey(arg1: Object): not nullable Bool

Bool! containsKey(Object arg1)

func containsKey(_ arg1: Object) -> Bool

Bool containsKey(Object arg1)

Function containsKey(arg1 As Object) As Bool

Parameters:

arg1:

containsValue Cooper

method containsValue(arg1: Object): not nullable Bool

Bool! containsValue(Object arg1)

func containsValue(_ arg1: Object) -> Bool

Bool containsValue(Object arg1)

Function containsValue(arg1 As Object) As Bool

Parameters:

arg1:

description override

method description: not nullable NativeString

NativeString! description()

func description() -> NativeString

NativeString description()

Function description() As NativeString

entrySet Cooper

method entrySet: Set<Map<not nullable Key, not nullable Value>>

Set<Map<not nullable Key, not nullable Value>> entrySet()

func entrySet() -> Set<Map<not nullable Key, not nullable Value>>

Set<Map<Key, Value>> entrySet()

Function entrySet() As Set<Map<not nullable Key, not nullable Value>>

equals Cooper

method equals(arg1: Object): not nullable Bool

Bool! equals(Object arg1)

func equals(_ arg1: Object) -> Bool

Function equals(arg1 As Object) As Bool

Parameters:

arg1:

Equals .NET, .NET Standard 2.0

method Equals(other: Object): not nullable Bool

Bool! Equals(Object other)

func Equals(_ other: Object) -> Bool

Function Equals(other As Object) As Bool

Parameters:

other:

forEach Cooper

method forEach(arg1: BiConsumer<Key, Value>)

void forEach(BiConsumer<Key, Value> arg1)

func forEach(_ arg1: BiConsumer<Key, Value>)

void forEach(BiConsumer<Key, Value> arg1)

Sub forEach(arg1 As BiConsumer<Key, Value>)

Parameters:

arg1:

get Cooper

method get(arg1: Object): Value

func get(_ arg1: Object) -> Value

Function get(arg1 As Object) As Value

Parameters:

arg1:

GetEnumerator virtual .NET, .NET Standard 2.0, Island

method GetEnumerator: IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)>

IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)> GetEnumerator()

func GetEnumerator() -> IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)>

Function GetEnumerator() As IEnumerator<not nullable tuple of (not nullable Key, not nullable Value)>

getOrDefault Cooper

method getOrDefault(arg1: Object; arg2: Value): Value

Value getOrDefault(Object arg1, Value arg2)

func getOrDefault(_ arg1: Object, _ arg2: Value) -> Value

Value getOrDefault(Object arg1, Value arg2)

Function getOrDefault(arg1 As Object, arg2 As Value) As Value

Parameters:

arg1:
arg2:

GetSequence virtual

method GetSequence: not nullable IEnumerable<not nullable tuple of (not nullable Key, not nullable Value)>

IEnumerable<not nullable tuple of (not nullable Key, not nullable Value)>! GetSequence()

func GetSequence() -> INSFastEnumeration<not nullable tuple of (not nullable Key, not nullable Value)>

Iterable<Tuple2<Key, Value>> GetSequence()

Function GetSequence() As IEnumerable<not nullable tuple of (not nullable Key, not nullable Value)>

hashCode Cooper

method hashCode: not nullable Integer

func hashCode() -> Integer

Function hashCode() As Integer

isEmpty Cooper

method isEmpty: not nullable Bool

Function isEmpty() As Bool

isEqual override Toffee

func isEqual(_ other: Object) -> Bool

Parameters:

other:

iterator Cooper

method iterator: Iterator<not nullable Tuple2<not nullable Key, not nullable Value>>

Iterator<not nullable Tuple2<not nullable Key, not nullable Value>> iterator()

func iterator() -> Iterator<not nullable Tuple2<not nullable Key, not nullable Value>>

Iterator<Tuple2<Key, Value>> iterator()

Function iterator() As Iterator<not nullable Tuple2<not nullable Key, not nullable Value>>

keySet Cooper

method keySet: Set<not nullable Key>

Set<not nullable Key> keySet()

func keySet() -> Set<not nullable Key>

Function keySet() As Set<not nullable Key>

merge Cooper

method merge(arg1: Key; arg2: Value; arg3: BiFunction<Key, not nullable Key, not nullable Value>): Value

Value merge(Key arg1, Value arg2, BiFunction<Key, not nullable Key, not nullable Value> arg3)

func merge(_ arg1: Key, _ arg2: Value, _ arg3: BiFunction<Key, not nullable Key, not nullable Value>) -> Value

Value merge(Key arg1, Value arg2, BiFunction<Key, Key, Value> arg3)

Function merge(arg1 As Key, arg2 As Value, arg3 As BiFunction<Key, not nullable Key, not nullable Value>) As Value

Parameters:

arg1:
arg2:
arg3:

put Cooper

method put(arg1: Key; arg2: Value): Value

Value put(Key arg1, Value arg2)

func put(_ arg1: Key, _ arg2: Value) -> Value

Value put(Key arg1, Value arg2)

Function put(arg1 As Key, arg2 As Value) As Value

Parameters:

arg1:
arg2:

putAll Cooper

method putAll(arg1: Map<Key, Value>)

void putAll(Map<Key, Value> arg1)

func putAll(_ arg1: Map<Key, Value>)

void putAll(Map<Key, Value> arg1)

Sub putAll(arg1 As Map<Key, Value>)

Parameters:

arg1:

putIfAbsent Cooper

method putIfAbsent(arg1: Key; arg2: Value): Value

Value putIfAbsent(Key arg1, Value arg2)

func putIfAbsent(_ arg1: Key, _ arg2: Value) -> Value

Value putIfAbsent(Key arg1, Value arg2)

Function putIfAbsent(arg1 As Key, arg2 As Value) As Value

Parameters:

arg1:
arg2:

remove (Object): Value Cooper

method remove(arg1: Object): Value

Value remove(Object arg1)

func remove(_ arg1: Object) -> Value

Value remove(Object arg1)

Function remove(arg1 As Object) As Value

Parameters:

arg1:

remove (Object, Object): not nullable Bool Cooper

method remove(arg1: Object; arg2: Object): not nullable Bool

Bool! remove(Object arg1, Object arg2)

func remove(_ arg1: Object, _ arg2: Object) -> Bool

Bool remove(Object arg1, Object arg2)

Function remove(arg1 As Object, arg2 As Object) As Bool

Parameters:

arg1:
arg2:

removeAll virtual

method removeAll keepCapacity(keepCapacity: not nullable Bool := false)

void removeAll keepCapacity(Bool! keepCapacity = false)

func removeAll(keepCapacity: Bool = false)

void removeAll keepCapacity(Bool keepCapacity)

Sub removeAll keepCapacity(keepCapacity As Bool = false)

Parameters:

keepCapacity:

removeValue virtual

method removeValue forKey(key: not nullable Key): nullable Value

Value? removeValue forKey(Key! key)

func removeValue(forKey key: Key) -> Value?

Value removeValue forKey(Key key)

Function removeValue forKey(key As Key) As Value?

Parameters:

key:

replace (Key, Value): Value Cooper

method replace(arg1: Key; arg2: Value): Value

Value replace(Key arg1, Value arg2)

func replace(_ arg1: Key, _ arg2: Value) -> Value

Value replace(Key arg1, Value arg2)

Function replace(arg1 As Key, arg2 As Value) As Value

Parameters:

arg1:
arg2:

replace (Key, Value, Value): not nullable Bool Cooper

method replace(arg1: Key; arg2: Value; arg3: Value): not nullable Bool

Bool! replace(Key arg1, Value arg2, Value arg3)

func replace(_ arg1: Key, _ arg2: Value, _ arg3: Value) -> Bool

Bool replace(Key arg1, Value arg2, Value arg3)

Function replace(arg1 As Key, arg2 As Value, arg3 As Value) As Bool

Parameters:

arg1:
arg2:
arg3:

replaceAll Cooper

method replaceAll(arg1: BiFunction<Key, Key, Value>)

void replaceAll(BiFunction<Key, Key, Value> arg1)

func replaceAll(_ arg1: BiFunction<Key, Key, Value>)

void replaceAll(BiFunction<Key, Key, Value> arg1)

Sub replaceAll(arg1 As BiFunction<Key, Key, Value>)

Parameters:

arg1:

size Cooper

method size: not nullable Integer

Function size() As Integer

toString Cooper

func toString() -> String

Function toString() As String

updateValue virtual

method updateValue(value: not nullable Value) forKey(key: not nullable Key): nullable Value

Value? updateValue(Value! value) forKey(Key! key)

func updateValue(_ value: Value, forKey key: Key) -> Value?

Value updateValue(Value value) forKey(Key key)

Function updateValue(value As Value) forKey(key As Key) As Value?

Parameters:

value:
key:

values Cooper

method values: Collection<not nullable Value>

Collection<not nullable Value> values()

func values() -> Collection<not nullable Value>

Collection<Value> values()

Function values() As Collection<not nullable Value>

IEnumerable
IEnumerable<T>