1. 常用容器类
public interface Iterable<T> {
// 重写该方法，返回自定义的 Iterator 对象。
Iterator<T> iterator();
}
Collection 的常用方法
public interface Collection<E> extends Iterable<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);//添加
boolean removeAll(Collection<?> c);//删除
boolean retainAll(Collection<?> c);
void clear();
}
List 的常用方法
public interface List<E> extends Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(int index,Collection<? extends E> c);
boolean retainAll(Collection<?> c);
boolean removeAll(Collection<?> c);
default void replaceAll(UnaryOperator<E> operator) {
Objects.requireNonNull(operator);
final ListIterator<E> li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparator<? super E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator<E> i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
void clear();
boolean equals(Object o);
int hashCode();
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
int lastIndexOf(Object o);
ListIterator<E> listIterator();
ListIterator<E> listIterator(int index);
}
Set 的常用方法
public interface Set<E> extends Collection<E> {
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator<E> iterator();
Object[] toArray();
<T> T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection<?> c);
boolean addAll(Collection<? extends E> c);
boolean retainAll(Collection<?> c);
boolean removeAll(Collection<?> c);
void clear();
boolean equals(Object o);
int hashCode();
}
Map 的常用方法
public interface Map<K,V> {
int size();
boolean isEmpty();
containsKey(Object key);
containsValue(Object value);
void putAll(Map<? extends K, ? extends V> m);
void clear();
interface Entry<K,V> {
K getKey();
V getValue();
V setValue(V value);
boolean equals(Object o);
int hashCode();
......
}
boolean equals(Object o);
int hashCode();
default V getOrDefault(Object key, V defaultValue) {
V v;
return (((v = get(key)) != null) || containsKey(key))
? v
: defaultValue;
}
put(k,v)
remove(k)
get(K)
values()//
keySet//获取键
entrySet() //getKey() getValue()
}
Properies 常用方法
Properies p=new Properties("")
||setProperty(String key,String value)||
||getProperty(String key)||
||getProperty(String key,String defaultValue)||
||store(OutputStream out,String comment)|默认相对路径，当前工程，指定相对路径：src/,src/com/iecas。|
||store(Writer writer,String comment)||
||load(InputStream in)||
||load(Reader reader)||
| 类 | 特点 | |
|---|---|---|
| List | ||
| ArrayList:数组 | 查看多于修改 | |
| LinkedList:链表 | 修改多于查看,多了些链头与链尾的方法 | |
| HashSet | 元素重写 hashcode +equals | |
| TreeSet | 元素可以排序 或者提供排序的业务类 | |
| HashMap | 键不能重复，必须重写 hashcode +equals，值可以重复，键最多一个 null | |
| Hashtable | 键与值都不能为null，线程安全 | |
| Stack | 栈 | |
| Properties | 继承 Hashtable,资源配置文件，相对路径获取文件。 |
2. 迭代和比较
2.1 迭代器
迭代器又称为游标，提供一种方法访问一个容器中的各个元素，又不暴露该对象的内部细节。所有实现了 Collection 接口的容器类都有一个 iterator 方法返回一个实现了 Iterator 接口的实现类。 Iterator 接口定义了如下三个方法：
public interface Iterator<E> {
//判断是否有元素没被遍历。
boolean hasNext();
//返回下一个元素
E next();
//返回当前元素，并将游标移向另一个元素。
default void remove() {
throw new UnsupportedOperationException("remove");
}
default void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (hasNext())
action.accept(next());
}
}
2.2 比较器
| 类 | 方法 | 功能 |
|---|---|---|
| java.lang.Comparable | compareTo(Object obj) | 实体类可以排序，List+Collections.sort()、TreeSet、TreeMap。 |
| java.util.Comparator | compare(T o1,T o2) | 排序比较器(解耦、多种排序规则) 。 |
| 类 | 特点 | 有序性 |
|---|---|---|
| java.lang.TreeSet | 数据元素有序不重复,元素实现 Comparable 接口，或构造时传入 Comparator 实现类。 | 有序 |
| java.util.TreeMap | 排序比较器(解耦、多种排序规则) 。 | 有序 |
| java.lang.HashSet | 数据元素无序不重复,元素必须重写 hashcode() 和 equals() 方法。 | 无序 |
| java.util.HashMap | Key 无序不重复,Key 必须重写 hashcode() 和 equals() 方法。 | 无序 |
3. 同步容器
3.1 ArrayList、Vector 与 Stack
- Vector 和 ArrayList 功能相同。
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
- 使用 synchronized 关键字对方法进行同步。
- Stack 基于 Vector 实现,Stack 也是同步容器。
public class Stack<E> extends Vector<E> {
}
3.2 调用 Collections.synchronizedList(Set、Map) 方法
public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
new SynchronizedRandomAccessList<>(list) :
new SynchronizedList<>(list));
}
3.3 HashTable、HashMap 和 ConcurrentHashMap
- HashTable 与 HashMap 实现了 Map 接口，功能相同。
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
4. 并发容器
4.1 CopyOnWriteArrayList
4.1.1 含义
对写操作进行加锁，写操作时复制，设计思想，最终一致性，读写分离，即读操作和写操作针对两个集合。
public boolean add(E e) {
final ReentrantLock lock = this.lock;
lock.lock();
try {
Object[] elements = getArray();
int len = elements.length;
Object[] newElements = Arrays.copyOf(elements, len + 1);
newElements[len] = e;
setArray(newElements);
return true;
} finally {
lock.unlock();
}
}
public E get(int index) {
return get(getArray(), index);
}
4.1.2 优点
- 无需对读操作进行同步操作。
4.1.3 缺点
- 消耗内存。
- 实时读。
- CopyOnWriteArraySet 基于 CopyOnWriteArrayList 实现
public class CopyOnWriteArraySet<E> extends AbstractSet<E> implements java.io.Serializable {
private static final long serialVersionUID = 5457747651344034263L;
private final CopyOnWriteArrayList<E> al;
}
4.2 不可变容器
- 使用 Collections.unmodifiableXXX（Collection、List、Set、Map） 方法:将 Collection、List、Set、Map传入对应方法中，容器便不能修改。原理，在初始化时将数值拷贝到UnmodifiableMap中，并使用UnSupportedOperationException。
- Guava:ImmutableXXX: Collection、List、Set、Map:提供带初始化数据的申明方法。
5. 容器工具类
| 类 | 方法 | 功能 |
|---|---|---|
| java.util.Collections | sort() | 集合排序。 |
| Arrays | copyOf |
网友评论