package foundation.util;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.Comparator;
|
import java.util.HashMap;
|
import java.util.Iterator;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.Map.Entry;
|
import java.util.Set;
|
|
|
public class MapList<K, T> implements Iterable<T> {
|
|
protected List<T> itemList;
|
protected Map<K, T> itemMap;
|
protected Map<K, Integer> indexMap;
|
protected boolean ignoreCase;
|
|
|
public MapList() {
|
itemList = new ArrayList<T>();
|
itemMap = new HashMap<K, T>();
|
ignoreCase = true;
|
}
|
|
public MapList(int size) {
|
itemList = new ArrayList<T>(size);
|
itemMap = new HashMap<K, T>();
|
ignoreCase = true;
|
}
|
|
public MapList(boolean ignoreCase) {
|
this();
|
this.ignoreCase = ignoreCase;
|
}
|
|
public void addAll(Map<K, T> map) {
|
Set<K> keys = map.keySet();
|
|
for (K key: keys) {
|
add(key, map.get(key));
|
}
|
}
|
|
@SuppressWarnings("unchecked")
|
public void add(K key, T item) {
|
if (key == null) {
|
return;
|
}
|
|
if (ignoreCase && (key instanceof String)) {
|
key = (K)((String)key).toLowerCase();
|
}
|
|
T old = itemMap.get(key);
|
|
if (old != null) {
|
itemList.remove(old);
|
}
|
|
itemMap.put(key, item);
|
itemList.add(item);
|
}
|
|
@SuppressWarnings("unchecked")
|
public void set(K key, T item) {
|
if (key == null) {
|
return;
|
}
|
|
if (indexMap == null) {
|
indexMap = new HashMap<K, Integer>();
|
}
|
|
if (ignoreCase) {
|
key = (K)((String)key).toLowerCase();
|
}
|
|
if (!itemMap.containsKey(key)) {
|
itemMap.put(key, item);
|
indexMap.put(key, itemList.size());
|
itemList.add(item);
|
}
|
else {
|
Integer idx = indexMap.get(key);
|
itemList.set(idx, item);
|
}
|
}
|
|
@SuppressWarnings("unchecked")
|
public T get(K key) {
|
if (key == null) {
|
return null;
|
}
|
|
if (ignoreCase && (key instanceof String)) {
|
key = (K)((String)key).toLowerCase();
|
}
|
|
return itemMap.get(key);
|
}
|
|
public T get(int idx) {
|
return itemList.get(idx);
|
}
|
|
@SuppressWarnings("unchecked")
|
public T remove(K key) {
|
if (key == null) {
|
return null;
|
}
|
|
if (ignoreCase && (key instanceof String)) {
|
key = (K)((String)key).toLowerCase();
|
}
|
|
T obj = itemMap.get(key);
|
|
if (obj != null) {
|
itemMap.remove(key);
|
itemList.remove(obj);
|
}
|
|
return obj;
|
}
|
|
@SuppressWarnings("unchecked")
|
public void addBeforeLast(K key, T item) {
|
if (key == null) {
|
return;
|
}
|
|
if (ignoreCase && (key instanceof String)) {
|
key = (K)((String)key).toLowerCase();
|
}
|
|
if (itemList.isEmpty()) {
|
add(key, item);
|
}
|
|
itemMap.put(key, item);
|
|
T last = itemList.remove(itemList.size() - 1);
|
itemList.add(item);
|
itemList.add(last);
|
}
|
|
public List<T> getItemList() {
|
return itemList;
|
}
|
|
public void setList(List<T> list) {
|
itemList = list;
|
}
|
|
@SuppressWarnings("unchecked")
|
public void sortList(Comparator<T> comparator) {
|
int max = itemList.size();
|
T[] array = (T[]) new Object[max];
|
|
for (int i = 0; i < max; i++) {
|
array[i] = itemList.get(i);
|
}
|
|
Arrays.sort(array, comparator);
|
|
List<T> result = Arrays.asList(array);
|
itemList = result;
|
}
|
|
public Map<K, T> getItemMap() {
|
return itemMap;
|
}
|
|
public Set<K> getKeySet() {
|
return itemMap.keySet();
|
}
|
|
public boolean isEmpty() {
|
return itemList.isEmpty();
|
}
|
|
public int size() {
|
return itemList.size();
|
}
|
|
public int mapSize() {
|
return itemMap.size();
|
}
|
|
public Iterator<T> iterator() {
|
return itemList.iterator();
|
}
|
|
public void clear() {
|
itemList.clear();
|
itemMap.clear();
|
}
|
|
public String toString(String separator) {
|
ContentBuilder builder = new ContentBuilder(separator);
|
|
for (Object key: itemMap.keySet()) {
|
builder.append(String.valueOf(key));
|
}
|
|
return builder.toString();
|
}
|
|
public String mapToString(String separator) {
|
ContentBuilder builder = new ContentBuilder(separator);
|
Set<Entry<K, T>> entrySet = itemMap.entrySet();
|
|
for (Entry<K, T> entry: entrySet) {
|
String key = String.valueOf(entry.getKey());
|
String value = String.valueOf(entry.getValue());
|
|
if (value.startsWith("{") || value.startsWith("[")) {
|
builder.append( Util.doubleQuotedStr(key) + ":" + value);
|
}
|
else {
|
builder.append( Util.doubleQuotedStr(key) + ":" + Util.doubleQuotedStr(value));
|
}
|
|
}
|
|
return "{" + builder.toString() + "}";
|
}
|
|
public Set<K> keySet() {
|
return itemMap.keySet();
|
}
|
|
public boolean contains(Object key) {
|
if (key == null) {
|
return false;
|
}
|
|
if (ignoreCase && (key instanceof String)) {
|
key = ((String)key).toLowerCase();
|
}
|
|
return itemMap.containsKey(key);
|
}
|
|
public Object[] toArray() {
|
return itemList.toArray();
|
}
|
|
@SuppressWarnings("hiding")
|
public <T> T[] toArray(T[] a) {
|
return itemList.toArray(a);
|
}
|
|
@SuppressWarnings("unchecked")
|
public void sort(Comparator<Object> comparator) {
|
Object[] array = new Object[itemList.size()];
|
itemList.toArray(array);
|
Arrays.sort(array, comparator);
|
|
itemList.clear();
|
|
for (Object obj: array) {
|
itemList.add((T) obj);
|
}
|
}
|
|
}
|
