关于集合类的总结
2015-04-20 22:02
260 查看
1、集合的概念
为什么出现集合类?为了对对象进行存储。
当你事先要知道要存放数据的个数,或者你需要一种比数组下标存取机制更灵活的方法时,你就需要用到集合类。
集合类型主要有3种:set(集)、list(列表)和map(映射),set和list是继承自connection接口的,存放亍java.util包中。
Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements,Map提供key到value的映射
Collection
├List
│├LinkedList(重点)
│├ArrayList (重点)
│└Vector
│ └Stack
└Set
│ ├HashSet(重点)
│ ├TreeSet (重点)
│
Map
├Hashtable (重点)
├HashMap (重点)
└WeakHashMap
2、Collection接口
既然Collection接口是集合中的顶层接口,那么它中定义的所有功能子类都可以使 用。查阅API中描述的Collection接口。Collection 层次结构 中的根接口。Collection 表
示一组对象,这些对象也称为 collection 的元素。一些 collection 允许有重复的元素, 而另一些则不允许。一些 collection 是有序的,而另一些则是无序的。
3、List接口
List接口有多个子类,这里我们介绍几个最常用的集合,其他的集合不是很常用,大家如果有用到可以查阅相关API,集合用法差别不是特别大。首先我们来学习List下的常用集合ArrayList、Vector、LinkedList集合。
ArrayList:是数组结构,长度是可变的(原理是创建新数组+复制数组),查询速度很快,增删较慢,不同步的。
Vector:可以增长的数组结构。同步的。效率非常低。已被ArrayList替代。
LinkedList:是链表结构,不同步的,增删速度很快,查询速度较慢。
4、Set接口
Set:不包含重复元素的集合,不保证顺序。而且方法和Collection一致。Set集合取出元素的方式只有一种:迭代器。
Set集合有多个子类,这里我们介绍其中的HashSet、TreeSet和LinkedHashSet这三个集合。
HashSet:哈希表结构,不同步,保证元素唯一性的方式依赖于:hashCode(),equals()方法。查询速度快。
5、迭代器
a) 通常遍历List和Set都是使用迭代器iterator进行遍历
b) 代码实现
public class IteratorDeamo { public static void main(String[] args) { getByIterator(); } public static void getByIterator() { //定义一个集合 ArrayList al=new ArrayList(); //添加对象 al.add("java1"); al.add("java2"); al 4000 .add("java3"); //使用迭代器 Iterator it=al.iterator(); while(it.hasNext()) { System.out.println(it.next()); } } }
6、哈希表
哈希映射结构由一个存储元素的内部数组组成。 由于内部采用数组存储,因此必然存在一个用于确定任意键访问数组的索引机制。 实际上,该机制需要提供一个小于数组大小的整数索引值。 该机制称作哈希函数。在 Java 基于哈希的 Map 中,哈希函数将对象转换为一个适合内部数组的整数。每个对象都包含一
个返回整数值的 hashCode() 方法。要将该值映射到数组,只需将其转换为一个 正值,然后在将该值除以数组大小后取余数即可。
附录:各个类操作(供查用)
a) ArrayList类
boolean add(E e)
//将指定的元素添加到此列表的尾部。
void add(int index, E element)
//将指定的元素插入此列表中的指定位置。
boolean addAll(Collection<? extends E> c)
//按照指定 collection 的迭代器所返回的元素顺序,将该 collection 中的所有元素//添加到此列表的尾部。
boolean addAll(int index, Collection<? extends E> c)
//从指定的位置开始,将指定 collection 中的所有元素插入到此列表中。
void clear() //移除此列表中的所有元素。
boolean contains(Object o)
//如果此列表中包含指定的元素,则返回 true。
E get(int index)
//返回此列表中指定位置上的元素。
int indexOf(Object o)
//返回此列表中首次出现的指定元素的索引,或如果此列表不包含元素,则返回 -1。
boolean isEmpty()
//如果此列表中没有元素,则返回 true
int lastIndexOf(Object o)
//返回此列表中最后一次出现的指定元素的索引,或如果此列表不包含索引,则返回 -1。
E remove(int index)
//移除此列表中指定位置上的元素。
boolean remove(Object o)
//移除此列表中首次出现的指定元素(如果存在)。
protected void removeRange(int fromIndex, int toIndex)
//移除列表中索引在 fromIndex(包括)和 toIndex(不包括)之间的所有元素。
E set(int index, E element)
//用指定的元素替代此列表中指定位置上的元素。
int size()
//返回此列表中的元素数。
Object[] toArray()
//按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组。
<T> T[] toArray(T[] a)
//按适当顺序(从第一个到最后一个元素)返回包含此列表中所有元素的数组;返//回数组的运行时类型是指定数组的运行时类型。
b) LinkedList类
boolean add(E e)
//将指定元素添加到此列表的结尾。
void add(int index, E element)
//在此列表中指定的位置插入指定的元素。
boolean addAll(Collection<? extends E> c)
//添加指定 collection 中的所有元素到此列表的结尾,顺序是指定 collection 的迭
//代器返回这些元素的顺序。
boolean addAll(int index, Collection<? extends E> c)
//将指定 collection 中的所有元素从指定位置开始插入此列表。
void addFirst(E e)
//将指定元素插入此列表的开头。
void addLast(E e)
//将指定元素添加到此列表的结尾。
void clear()
//从此列表中移除所有元素。
Object clone()
//返回此 LinkedList 的浅表副本。
boolean contains(Object o)
//如果此列表包含指定元素,则返回 true。
Iterator<E> descendingIterator()
//返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。
E element()
//获取但不移除此列表的头(第一个元素)。
E get(int index)
//返回此列表中指定位置处的元素。
E getFirst()
//返回此列表的第一个元素。
E getLast()
//返回此列表的最后一个元素。
int indexOf(Object o)
//返回此列表中首次出现的指定元素的索引,如果此列表中不包含该元素,则返 //回 -1。
int lastIndexOf(Object o)
//返回此列表中最后出现的指定元素的索引,如果此列表中不包含该元素,则返 //回 -1。
ListIterator<E> listIterator(int index)
//返回此列表中的元素的列表迭代器(按适当顺序),从列表中指定位置开始。
boolean offer(E e)
//将指定元素添加到此列表的末尾(最后一个元素)。
boolean offerFirst(E e)
//在此列表的开头插入指定的元素。
boolean offerLast(E e)
//在此列表末尾插入指定的元素。
E peek()
//获取但不移除此列表的头(第一个元素)。
E peekFirst()
//获取但不移除此列表的第一个元素;如果此列表为空,则返回 null。
E peekLast()
//获取但不移除此列表的最后一个元素;如果此列表为空,则返回 null。
E poll()
//获取并移除此列表的头(第一个元素)
E pollFirst()
//获取并移除此列表的第一个元素;如果此列表为空,则返回 null。
E pollLast()
//获取并移除此列表的最后一个元素;如果此列表为空,则返回 null。
E pop()
//从此列表所表示的堆栈处弹出一个元素。
void push(E e)
// 将元素推入此列表所表示的堆栈。
E remove()
//获取并移除此列表的头(第一个元素)。
E remove(int index)
//移除此列表中指定位置处的元素。
boolean remove(Object o)
//从此列表中移除首次出现的指定元素(如果存在)。
E removeFirst()
//移除并返回此列表的第一个元素。
boolean removeFirstOccurrence(Object o)
//从此列表中移除第一次出现的指定元素(从头部到尾部遍历列表时)。
E removeLast()
//移除并返回此列表的最后一个元素。
boolean removeLastOccurrence(Object o)
//从此列表中移除最后一次出现的指定元素(从头部到尾部遍历列表时)。
E set(int index, E element)
//将此列表中指定位置的元素替换为指定的元素。
int size()
//返回此列表的元素数。
Object[] toArray()
//返回以适当顺序(从第一个元素到最后一个元素)包含此列表中所有元素的数 //组。
<T> T[] toArray(T[] a)
//返回以适当顺序(从第一个元素到最后一个元素)包含此列表中所有元素的数 //组;返回数组的运行时类型为指定数组的类型。
c) HashSet类
boolean add(E e)
//如果此 set 中尚未包含指定元素,则添加指定元素。
void clear()
//从此 set 中移除所有元素。
boolean contains(Object o)
//如果此 set 包含指定元素,则返回 true。
boolean isEmpty()
//如果此 set 不包含任何元素,则返回 true。
Iterator<E> iterator()
//返回对此 set 中元素进行迭代的迭代器。
boolean remove(Object o)
//如果指定元素存在于此 set 中,则将其移除。
int size()
//返回此 set 中的元素的数量(set 的容量)。
d) TreeSet类
boolean add(E e)
//将指定的元素添加到此 set(如果该元素尚未存在于 set 中)。
boolean addAll(Collection<? extends E> c)
//将指定 collection 中的所有元素添加到此 set 中。
E ceiling(E e)
//返回此 set 中大于等于给定元素的最小元素;如果不存在这样的元素,则返回 //null。
void clear()
//移除此 set 中的所有元素。
Object clone()
//返回 TreeSet 实例的浅表副本。
112a1
Comparator<? super E> comparator()
//返回对此 set 中的元素进行排序的比较器;如果此 set 使用其元素的自然顺序, //则返回 null。
boolean contains(Object o)
//如果此 set 包含指定的元素,则返回 true。
Iterator<E> descendingIterator()
//返回在此 set 元素上按降序进行迭代的迭代器。
NavigableSet<E> descendingSet()
//返回此 set 中所包含元素的逆序视图。
E first()
//返回此 set 中当前第一个(最低)元素。
E floor(E e)
//返回此 set 中小于等于给定元素的最大元素;如果不存在这样的元素,则返回 //null。
E higher(E e)
//返回此 set 中严格大于给定元素的最小元素;如果不存在这样的元素,则返回 //null。
boolean isEmpty()
//如果此 set 不包含任何元素,则返回 true。
Iterator<E> iterator()
//返回在此 set 中的元素上按升序进行迭代的迭代器。
E last()
//返回此 set 中当前最后一个(最高)元素。
E lower(E e)
//返回此 set 中严格小于给定元素的最大元素;如果不存在这样的元素,则返回 //null。
E pollFirst()
//获取并移除第一个(最低)元素;如果此 set 为空,则返回 null。
E pollLast()
//获取并移除最后一个(最高)元素;如果此 set 为空,则返回 null。
boolean remove(Object o)
//将指定的元素从 set 中移除(如果该元素存在于此 set 中)。
int size()
//返回 set 中的元素数(set 的容量)。
e) HashMap
void clear()
//从此映射中移除所有映射关系。
boolean containsKey(Object key)
//如果此映射包含对于指定键的映射关系,则返回 true。
boolean containsValue(Object value)
//如果此映射将一个或多个键映射到指定值,则返回 true。
Set<Map.Entry<K,V>> entrySet()
//返回此映射所包含的映射关系的 Set 视图。
V get(Object key)
//返回指定键所映射的值;如果对于该键来说,此映射不包含任何映射关系,则 //返回 null。
boolean isEmpty()
//如果此映射不包含键-值映射关系,则返回 true。
Set<K> keySet()
//返回此映射中所包含的键的 Set 视图。
V put(K key, V value)
//在此映射中关联指定值与指定键。
void putAll(Map<? extends K,? extends V> m)
//将指定映射的所有映射关系复制到此映射中,这些映射关系将替换此映射目前 //针对指定映射中所有键的所有映射关系。
V remove(Object key)
//从此映射中移除指定键的映射关系(如果存在)。
int size()
//返回此映射中的键-值映射关系数。
Collection<V> values()
//返回此映射所包含的值的 Collection 视图。
f) TreeMap
Map.Entry<K,V> ceilingEntry(K key)
//返回一个键-值映射关系,它与大于等于给定键的最小键关联;如果不存在这样 //的键,则返回 null。
K ceilingKey(K key)
//返回大于等于给定键的最小键;如果不存在这样的键,则返回 null。
void clear()
//从此映射中移除所有映射关系。
Object clone()
//返回此 TreeMap 实例的浅表副本。
Comparator<? super K> comparator()
//返回对此映射中的键进行排序的比较器;如果此映射使用键的自然顺序,则返 //回 null。
boolean containsKey(Object key)
//如果此映射包含指定键的映射关系,则返回 true。
boolean containsValue(Object value)
//如果此映射为指定值映射一个或多个键,则返回 true。
NavigableSet<K> descendingKeySet()
//返回此映射中所包含键的逆序 NavigableSet 视图。
NavigableMap<K,V> descendingMap()
//返回此映射中所包含映射关系的逆序视图。
Set<Map.Entry<K,V>> entrySet()
//返回此映射中包含的映射关系的 Set 视图。
Map.Entry<K,V> firstEntry()
//返回一个与此映射中的最小键关联的键-值映射关系;如果映射为空,则返回 //null。
K firstKey()
//返回此映射中当前第一个(最低)键。
Map.Entry<K,V> floorEntry(K key)
//返回一个键-值映射关系,它与小于等于给定键的最大键关联;如果不存在这样 //的键,则返回 null。
K floorKey(K key)
//返回小于等于给定键的最大键;如果不存在这样的键,则返回 null。
V get(Object key)
//返回指定键所映射的值,如果对于该键而言,此映射不包含任何映射关系,则 //返回 null。
SortedMap<K,V> headMap(K toKey)
//返回此映射的部分视图,其键值严格小于 toKey。
NavigableMap<K,V> headMap(K toKey, boolean inclusive)
//返回此映射的部分视图,其键小于(或等于,如果 inclusive 为 true)toKey。
Map.Entry<K,V> higherEntry(K key)
//返回一个键-值映射关系,它与严格大于给定键的最小键关联;如果不存在这样 //的键,则返回 null。
K higherKey(K key)
//返回严格大于给定键的最小键;如果不存在这样的键,则返回 null。
Set<K> keySet()
//返回此映射包含的键的 Set 视图。
Map.Entry<K,V> lastEntry()
//返回与此映射中的最大键关联的键-值映射关系;如果映射为空,则返回 null。
K lastKey()
// 返回映射中当前最后一个(最高)键。
Map.Entry<K,V> lowerEntry(K key)
//返回一个键-值映射关系,它与严格小于给定键的最大键关联;如果不存在这样的 //键,则返回 null。
K lowerKey(K key)
//返回严格小于给定键的最大键;如果不存在这样的键,则返回 null。
NavigableSet<K> navigableKeySet()
//返回此映射中所包含键的 NavigableSet 视图。
Map.Entry<K,V> pollFirstEntry()
//移除并返回与此映射中的最小键关联的键-值映射关系;如果映射为空,则返回 //null。
Map.Entry<K,V> pollLastEntry()
//移除并返回与此映射中的最大键关联的键-值映射关系;如果映射为空,则返回 //null。
V put(K key, V value)
//将指定值与此映射中的指定键进行关联。
void putAll(Map<? extends K,? extends V> map)
//将指定映射中的所有映射关系复制到此映射中。
V remove(Object key)
//如果此 TreeMap 中存在该键的映射关系,则将其删除。
int size()
//返回此映射中的键-值映射关系数。
NavigableMap<K,V> subMap(K fromKey, boolean fromInclusive, K toKey, boolean toInclusive)
//返回此映射的部分视图,其键的范围从 fromKey 到 toKey。
SortedMap<K,V> subMap(K fromKey, K toKey)
//返回此映射的部分视图,其键值的范围从 fromKey(包括)到 toKey(不包括)。
SortedMap<K,V> tailMap(K fromKey)
//返回此映射的部分视图,其键大于等于 fromKey。
NavigableMap<K,V> tailMap(K fromKey, boolean inclusive)
//返回此映射的部分视图,其键大于(或等于,如果 inclusive 为 true)fromKey。
Collection<V> values()
//返回此映射包含的值的 Collection 视图。
g) Collections
static <T> boolean addAll(Collection<? super T> c, T... elements)
//将所有指定元素添加到指定 collection 中。
static <T> Queue<T> asLifoQueue(Deque<T> deque)
//以后进先出 (Lifo) Queue 的形式返回某个 Deque 的视图。
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
//使用二分搜索法搜索指定列表,以获得指定对象。
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
//使用二分搜索法搜索指定列表,以获得指定对象。
static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)
//返回指定有序 set 的一个动态类型安全视图。
static <T> void copy(List<? super T> dest, List<? extends T> src)
//将所有元素从一个列表复制到另一个列表。
static boolean disjoint(Collection<?> c1, Collection<?> c2)
//如果两个指定 collection 中没有相同的元素,则返回 true。
static <T> List<T> emptyList()
//返回空的列表(不可变的)。
static <K,V> Map<K,V> emptyMap()
//返回空的映射(不可变的)。
static <T> Set<T> emptySet()
//返回空的 set(不可变的)。
static <T> Enumeration<T> enumeration(Collection<T> c)
//返回一个指定 collection 上的枚举。
static <T> void fill(List<? super T> list, T obj)
//使用指定元素替换指定列表中的所有元素。
static int frequency(Collection<?> c, Object o)
//返回指定 collection 中等于指定对象的元素数。
static int indexOfSubList(List<?> source, List<?> target)
//返回指定源列表中第一次出现指定目标列表的起始位置;如果没有出现这样的列 //表,则返回 -1。
static int lastIndexOfSubList(List<?> source, List<?> target)
//返回指定源列表中最后一次出现指定目标列表的起始位置;如果没有出现这样的 //列表,则返回 -1。
static <T> ArrayList<T> list(Enumeration<T> e)
//返回一个数组列表,它按返回顺序包含指定枚举返回的元素。
static <T extends Object & Comparable<? super T>>
T max(Collection<? extends T> coll)
//根据元素的自然顺序,返回给定 collection 的最大元素。
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
//根据指定比较器产生的顺序,返回给定 collection 的最大元素。
static <T extends Object & Comparable<? super T>>
T min(Collection<? extends T> coll)
//根据元素的自然顺序 返回给定 collection 的最小元素。
static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
//根据指定比较器产生的顺序,返回给定 collection 的最小元素。
static <T> List<T> nCopies(int n, T o)
//返回由指定对象的 n 个副本组成的不可变列表。
static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
//返回指定映射支持的 set。
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
//使用另一个值替换列表中出现的所有某一指定值。
static void reverse(List<?> list)
//反转指定列表中元素的顺序。
static <T> Comparator<T> reverseOrder()
//返回一个比较器,它强行逆转实现了 Comparable 接口的对象 collection 的自然
//顺序。
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
//返回一个比较器,它强行逆转指定比较器的顺序。
static void rotate(List<?> list, int distance)
//根据指定的距离轮换指定列表中的元素。
static void shuffle(List<?> list)
//使用默认随机源对指定列表进行置换。
static void shuffle(List<?> list, Random rnd)
//使用指定的随机源对指定列表进行置换。
static <T> Set<T> singleton(T o)
//返回一个只包含指定对象的不可变 set。
static <T> List<T> singletonList(T o)
//返回一个只包含指定对象的不可变列表。
static <K,V> Map<K,V> singletonMap(K key, V value)
//返回一个不可变的映射,它只将指定键映射到指定值。
static <T extends Comparable<? super T>> void sort(List<T> list)
//根据元素的自然顺序 对指定列表按升序进行排序。
static <T> void sort(List<T> list, Comparator<? super T> c)
//根据指定比较器产生的顺序对指定列表进行排序。
static void swap(List<?> list, int i, int j)
//在指定列表的指定位置处交换元素。
static <T> Collection<T> synchronizedCollection(Collection<T> c)
//返回指定 collection 支持的同步(线程安全的)collection。
static <T> List<T> synchronizedList(List<T> list)
//返回指定列表支持的同步(线程安全的)列表。
static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
//返回由指定映射支持的同步(线程安全的)映射。
static <T> Set<T> synchronizedSet(Set<T> s)
//返回指定 set 支持的同步(线程安全的)set。
static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
//返回指定有序映射支持的同步(线程安全的)有序映射。
static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
//返回指定有序 set 支持的同步(线程安全的)有序 set。
static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
//返回指定 collection 的不可修改视图。
static <T> List<T> unmodifiableList(List<? extends T> list)
//返回指定列表的不可修改视图。
static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
//返回指定映射的不可修改视图。
static <T> Set<T> unmodifiableSet(Set<? extends T> s)
//返回指定 set 的不可修改视图。
相关文章推荐
- 关于JAVA集合类的一点总结!
- 关于集合类,equals,HashCode,Comparable,Iterator总结
- 关于集合类的个人总结
- 关于集合类的一些总结
- [Multithreading]关于Lock总结
- 关于Intent知识点的总结
- 关于在windows下部署发布QT程序的总结
- 关于NorFlash的一点总结
- 关于stringstream的一些总结
- 关于Z序的总结
- 关于进段时间的工作总结
- SQL关于相关子查询与EXISTS的简单总结
- 关于FSM(有限状态机)的学习3---总结
- 关于C++中的虚拟继承的一些总结
- 关于Eclipse中遇到的经常性参数报错问题总结
- 在重定向,转发中关于路径问题的总结
- 关于hadoop学习的思考(一) —— 小的知识点的总结
- 关于inet_pton等一系列的inet_函数总结
- 关于有环链表的若干问题总结
- 关于premiere中遮罩的几点总结 数媒0802 宋志超