was ist der effizienteste Weg, um eine Liste

Question

Ich habe eine große Liste von Tupeln

List<Tuple2<String,String> list; 

zu fegen, was ist der effizienteste Weg, um es zu fegen, ein Element zu suchen, um es zu retreive oder ändern ??

für zB:

String elementToSearch="l"; 
list={(a,hh)(b,rr)(c,kk)(d,jj)(l,mm).....} 
Tuple2<String,String> result=(l,mm) 

Ich habe versucht, dass die Schleife „für“ verwenden, es hat funktioniert, sondern weil es eine große Liste s, ich bin nicht sicher, ob es der beste Weg, es zu tun ist.

Answer 1

Wenn das erste Element des Tupels ein Schlüssel (keine andere Tupel das gleiche erste Element) ist, werden Sie wahrscheinlich brauchen einen Map ...

Hinweis: für doppelte Schlüssel, doesn dieser‘ t gut funktionieren: nur einer bleibt erhalten!

Map<String, String> myMap = new HashMap<>(); 

myMap.put("a", "bb"); 
//... 

String result = myMap.get("a"); 
//result will be "bb" 

Wenn das erste Element kein Schlüssel ist, so könnte es ("l","mm") und ("l","ee") sein, dann ist es ein wenig komplizierter:

// for clarity, a helper method 
private static <K,V> void add(Map<K, Set<V>> mapToAdd, K key, V value) { 
    Set<V> innerSet = mapToAdd.get(key); 
    if(innerSet==null) { 
    innerSet = new HashSet<>(); 
    mapToAdd.put(key, innerSet); 
    } 
    innerSet.add(value); 
} 

//... 

Map<String, Set<String>> myMap = new HashMap<>(); 
add(myMap, "l", "mm"); 
add(myMap, "l", "ee"); 

// for searching, we also need a helping method: 

private static <K,V> boolean find(Map<K, Set<V>> mapToFind, K key, V value) { 
    boolean found = false; 
    Set<V> setToFind = mapToFind.get(key); 
    if(setToFind!=null) { 
     found = setToFind.contains(value); 
    } 
    return found; 
} 
// result true: 
System.out.println(find(myMap,"l","mm")); 

// result true: 
System.out.println(find(myMap,"l","ee")); 

// result false: 
System.out.println(find(myMap,"l","mddddm")); 

Hinweis: wenn es vollständige Duplikate, dieser behält nur einen von ihnen!

Answer 2

Wenn Sie Listen verwenden:

Wenn die Liste sortiert ist, können Sie es mit einem binary search algorithm suchen.

Wenn es nicht sortiert ist, verwenden Sie einfach eine for-Schleife.

---

Wenn Sie die Datenstruktur, die Antwort von @ppterka

---

folgen ändern Sie die erste (und nur die erste) Element, das die den ersten Teil des Tuple2 entsprechen suchen:

Tuple2<String,String> search(List<Tuple2<String, String>> list, String a) { 
    for (Tuple2<String, String> tuple : list) { 
     if (tuple.getFirst().equals(a)) { 
      return tuple; 
     } 
    } 
    return null; // Or thrown a NotFoundException 
} 


... 

Tuple2<String,String> searched = search(list, "l");