Linked HashMap - Iteration (Java)

Question

I'm trying to iterate through a Linked HashMap keySet however I am having difficulties in getting it to work.

Essentially I am searching the keySet to find a word, and another word. If the second word is immediately after the first word I wish to return true. This is the progress I have made so far.

for (String word : storedWords.keySet()) {

        value0++;

        if(word.equals(firstWord)){
            value1 = value0;
        }

        if(word.equals(secondWord)){
            value2 = value0;
        }

        int value3 = value2 - 1;
        if(value1 == value3){
            result = true;
            break;
        }
    }

EDIT:

I've solved my problem and am thankful for all of those who helped. I apologise for making a post when there was a lot of information available on the website however I just lacked the understanding of the logic behind it.

Answer 1

You can avoid iterating over the whole keySet by storing the indices of each element in a separate map; then you can just test if both keys are present and have indices differing by 1. For convenience, encapsulate both maps into an object:

import java.util.*;

public class MapWithIndices<K, V> {
    private final Map<K, V> map = new LinkedHashMap<>();
    private final Map<K, Integer> indices = new HashMap<>();

    public V get(K k) {
        return map.get(k);
    }

    public V put(K k, V v) {
        V old = map.put(k, v);
        if(old == null) {
            indices.put(k, indices.size());
        }
        return old;
    }

    public boolean areAdjacent(K k1, K k2) {
        Integer i1 = indices.get(k1);
        Integer i2 = indices.get(k2);
        return i1 != null && i2 != null && i1 + 1 == i2;
    }
}

You can add more Map methods (e.g. size) by delegating them to map. However, the remove method cannot be implemented efficiently since it requires recomputing all later indices. If removing from the map is required, an alternative data structure design should be considered; for example, indices can store the original insertion order of each key, and an order statistic tree can be used to count how many existing keys have a lower original-insertion-order.

Answer 2

Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

Answer 3

I think this is sort of in line with what you started with. You might want to test the performance though.

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

class Testing {
  Map<String, Integer> storedWords = new LinkedHashMap<>();
  {
    storedWords.put("One",1);
    storedWords.put("Two",2);
    storedWords.put("Three",3);
    storedWords.put("Four",4);
    storedWords.put("Five",5);
  }

  public static void main(String[] args) {
    Testing t = new Testing();
    String firstWord;
    String secondWord;

    firstWord = "Three";
    secondWord = "Five";
    System.out.println(t.consecutive(firstWord, secondWord)); // false

    firstWord = "Two";
    secondWord = "Three";
    System.out.println(t.consecutive(firstWord, secondWord)); // true
  }

  public boolean consecutive(String firstWord, String secondWord) {
    boolean foundfirst = false;  
    for (String word : storedWords.keySet()) {
      if (!foundfirst && word.equals(firstWord)){
        foundfirst = true;
        continue;
      }

      if (foundfirst) {
        if(word.equals(secondWord)){
          return true;
        } else {
          foundfirst = false; // reset to search for the first word again
        }
      }
    }
    return false;
  }
}