Why does HashMap::iter.nth(0) give different output for each execution run? [duplicate] - hashmap

Question

This question already has answers here:
Get first element from HashMap
(2 answers)
Closed 4 years ago.
Given the below program:
use std::collections::HashMap;
fn main() {
let mut hm = HashMap::new();
hm.insert(0, 1);
hm.insert(1, 1);
let mut iter = hm.iter();
println!("{:?}", iter.nth(0).expect("Fatal.").0)
}
I get a different output for each execution run of the code:
procyclinsur#procyclinsur:~/Documents/Rust/t1$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/t1`
1
procyclinsur#procyclinsur:~/Documents/Rust/t1$ vim src/main.rs
procyclinsur#procyclinsur:~/Documents/Rust/t1$ cargo run
Compiling t1 v0.1.0 (file:///home/procyclinsur/Documents/Rust/t1)
Finished dev [unoptimized + debuginfo] target(s) in 1.12 secs
Running `target/debug/t1`
1
procyclinsur#procyclinsur:~/Documents/Rust/t1$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/t1`
1
procyclinsur#procyclinsur:~/Documents/Rust/t1$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/t1`
0
procyclinsur#procyclinsur:~/Documents/Rust/t1$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
Running `target/debug/t1`
1
I'd expect that I should see the same output for each run of the program. Does anyone know the reason why this code behaves in such a way? How do I get this to output only 0 as expected?

Answer 1

It's because a HashMap is unordered. Its iter method
visits all key-value pairs in arbitrary order
The documentation on collections describes this behavior:
For unordered collections like HashMap, the items will be yielded in
whatever order the internal representation made most convenient.
In order to always retrieve a specific value you need to search by the key (or use one of the Iterator methods that don't depend on the order, e.g. find); for example:
use std::collections::HashMap;
fn main() {
let mut hm = HashMap::new();
hm.insert(0, "a");
hm.insert(1, "b");
println!("{:?}", hm.get(&0)) // always Some("a")
}

Answer 2

As others have said, the order is not predictable. However, using a different hasher can at least give you reproducible results. For example the FNV hash function, which you can use like this:
extern crate fnv;
use std::collections::HashMap;
use std::hash::BuildHasherDefault;
use fnv::FnvHasher;
type HashMapFnv<K, V> = HashMap<K, V, BuildHasherDefault<FnvHasher>>;
fn main() {
let mut hm = HashMapFnv::default();
hm.insert(0, 1);
hm.insert(1, 1);
let mut iter = hm.iter();
println!("{:?}", iter.nth(0).expect("Fatal.").0)
}
This should give you the same results each time. However, there are no guarantees about what that order is, so you might get different results on a different operating system, if you update FNV or if you use a different version of Rust itself.
Note that you shouldn't use this hash function in any application that processes external data, as it is be vulnerable to hash collision attacks. The default hash function in Rust is safe.

Answer 3

It is worth mentioning BTreeMap and corresponding iter function
Gets an iterator over the entries of the map, sorted by key.
This may be a simple drop-in replacement.
use std::collections::BTreeMap;
fn main() {
let mut hm = BTreeMap::new();
hm.insert(0, 1);
hm.insert(1, 1);
let mut iter = hm.iter();
println!("{:?}", iter.nth(0).expect("Fatal.").0);
}
playground