Java ListSet 어딘가에?

Question

게재 순위 콜렉션을 찾고 위치의 효율적인 조회 및 하위 세트보기 (예 : 하위 목록)를 허용합니다. 이것에 대한 가장 간단한 옵션은 List의 linked list 접근법을 취하고 노드를 맵 값으로 포함하고 클래스의 목록 인터페이스의 일부 또는 전체를 노출하는 것입니다. 누군가가 이것에 대해 오라클에 나쁜 것인가

? 정렬 된지도 및 세트에 NavigableMap/Set가 추가되어 훨씬 더 일반적인 게재 신청서가없는 경우 ...

편집 : 제발 LinkedHashSet을 제안하지 마십시오. 위치를 쿼리하거나 할 수있는 방법이 없습니다. 상대적 부분 집합.

Answer 1

당신은 java.util.LinkedHashSet 같은 의미 : 예측 가능한 반복 순서를 가지는

해시 테이블과 Set 인터페이스의 링크리스트의 구현을. 이 구현은 모든 항목을 통해 실행되는 이중 연결 목록을 유지한다는 점에서 HashSet 과 다릅니다. 이 링크 된 목록은 요소가 집합 (삽입 순서)에 삽입 된 순서 인 반복 순서를 정의합니다. 요소를 에 다시 삽입하면 삽입 순서가 영향을받지 않습니다. (. s.add 경우는 요소 e가 세트의 재 삽입한다 (e)는 s.contains (e)는 직전 호출로 true를 반환 할 때 가 호출)

Answer 2

EDIT2 : 새로운 최종 버전 다음은 약간 조정 된 함수 (2로 나뉘며 더 이상지도의 시작으로 null을 허용하지 않음)가있는 집합에 대한 버전입니다.

public class LinkedSet<E> implements Set<E> { 

private LinkedHashMap<E, Integer> m = new LinkedHashMap<E, Integer>(); 
private int monoticallyIncreasing; 

/** 
* Returns true if the value target was added before (exclusive) 
* limitElem in insertion order. 
* 
* If target or limit are not present on the set this method returns false 
* 
* @param limitElem a E that may be a element of the set or not. 
* @return if target was added before limit (can be reset by removing and 
* re-adding the target, that changes iteration order). 
*/ 
public boolean containsBefore(E target, E limitElem) { 
    if (isEmpty()) { 
     return false; 
    } 

    Integer targetN = m.get(target); 
    if (targetN == null) { 
     return false; 
    } 

    Integer highN = m.get(limitElem); 
    if (highN == null) { 
     return false; 
    } 
    return targetN < highN; 
} 

/** 
* Returns true if the value target was added after (exclusive) 
* previousElem in insertion order. 
* 
* If target or previous are not present on the set this method returns false 
* 
* @param previousElem a E that may be a element of the set or not. 
* @return if target was added before previous (can be reset by removing and 
* re-adding the target, that changes iteration order). 
*/ 
public boolean containsAfter(E target, E previousElem) { 
    if (isEmpty()) { 
     return false; 
    } 

    Integer targetN = m.get(target); 
    if (targetN == null) { 
     return false; 
    } 

    Integer low = m.get(previousElem); 
    if (low == null) { 
     return false; 
    } 
    return low < targetN; 
} 

@Override 
public boolean add(E e) { 
    Integer pos = m.get(e); 
    if (pos == null) { 
     m.put(e, monoticallyIncreasing++); 
     return true; 
    } 
    return false; 
} 

@Override 
public int size() { 
    return m.size(); 
} 

@Override 
public boolean isEmpty() { 
    return m.isEmpty(); 
} 

@Override 
public boolean contains(Object o) { 
    return m.containsKey(o); 
} 

@Override 
public Object[] toArray() { 
    Object[] result = new Object[size()]; 
    int i = 0; 
    for (E e : this) { 
     result[i++] = e; 
    } 
    return result; 
} 

@Override 
@SuppressWarnings("unchecked") 
public <T> T[] toArray(T[] a) { 
    int size = size(); 
    if (a.length < size) { 
     a = (T[]) java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size); 
    } 
    int i = 0; 
    Object[] result = a; 
    for (E e : this) { 
     result[i++] = e; 
    } 
    if (a.length > size) { 
     //peculiar toArray contract where it doesn't care about the rest 
     a[size] = null; 
    } 
    return a; 
} 

@Override 
public boolean remove(Object o) { 
    return m.remove(o) != null; 
} 

@Override 
public boolean addAll(Collection<? extends E> c) { 
    boolean changed = false; 
    for (E e : c) { 
     changed |= add(e); 
    } 
    return changed; 
} 

@Override 
public boolean containsAll(Collection<?> c) { 
    return m.keySet().containsAll(c); 
} 

@Override 
public boolean retainAll(Collection<?> c) { 
    return m.keySet().retainAll(c); 
} 

@Override 
public boolean removeAll(Collection<?> c) { 
    return m.keySet().removeAll(c); 
} 

@Override 
public void clear() { 
    m.clear(); 
} 

@Override 
public Iterator<E> iterator() { 
    return m.keySet().iterator(); 
} 
}