概念
集合同数组一样，是一个容器，它可以存储任意引用数据类型。然而在集合没出现前，数组的一些局限性暴露出来，只能存放单一数据类型，并且在元素长度不确定的情况下，无法动态的增加容量，所以集合出现弥补了这些不足。分支
以所存元素的内部关系不同，集合分为了Collection集合框架体系和Map体系，前者是以单列为存放规则，后者则是以键值对<key,value>体现的双列为存放规则。Collection集合框架
Collection是一个根接口，定义了集合框架的共性功能。例如：1，添加
add(e);确保此 collection 包含指定的元素（可选操作）。
addAll(collection);将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。
2，删除
remove(e);从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。
removeAll(collection);移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。
clear();移除此 collection 中的所有元素（可选操作）。
3，判断
contains(e);如果此 collection 包含指定的元素，则返回 true。
isEmpty();如果此 collection 不包含元素，则返回 true。
4，获取
iterator();返回在此 collection 的元素上进行迭代的迭代器。
size();返回此 collection 中的元素数。
5，获取交集。
retainAll();仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。
6，集合变数组。
toArray();返回包含此 collection 中所有元素的数组。
其中iterator是迭代器，迭代器是取出方式，会直接访问集合中的元素。所以将迭代器通过内部类的形式来进行描述。通过容器的iterator()方法获取该内部类的对象。
public static void method_get()
{
ArrayList al = new ArrayList();
//1，添加元素。
al.add("java01");//add(Object obj);
al.add("java02");
al.add("java03");
al.add("java04");
/*
Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。
while(it.hasNext())
{
sop(it.next());
}
*/
for(Iterator it = al.iterator(); it.hasNext() ; )
{
sop(it.next());
}
}
List接口
作为Collection的子接口，List体系的特点是元素是有序的，元素可以重复。具体实现子类：
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
特有方法：
增add(index,element);在列表的指定位置插入指定元素（可选操作）。
addAll(index,Collection);将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。
删
remove(index);移除列表中指定位置的元素（可选操作）。
改
set(index,element);用指定元素替换列表中指定位置的元素（可选操作）。
查
get(index):返回列表中指定位置的元素。
subList(from,to);返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。
listIterator();返回此列表元素的列表迭代器（按适当顺序）。
int indexOf(obj):获取指定元素的位置。
凡是可以操作角标的方法都是该体系特有的方法。其中ListIterator是该体系的特有迭代器，ListIterator是Iterator的子接口。Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，如果想要其他的操作如添加，修改等，就需要使用其子接口ListIterator。该接口只能通过List集合的listIterator方法获取。
public static void main(String[] args)
{
//演示列表迭代器。
ArrayList al = new ArrayList();
//添加元素
al.add("java01");
al.add("java02");
al.add("java03");
sop(al);
ListIterator li = al.listIterator();
while(li.hasNext())
{
Object obj = li.next();
if(obj.equals("java02"))
//li.add("java009");
li.set("java006");
}
sop(al);
}
LinkedList
特有方法：addFirst();将指定元素插入此列表的开头。
addLast();将指定元素添加到此列表的结尾。
getFirst();返回此列表的第一个元素。
getLast();返回此列表的最后一个元素。
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();移除并返回此列表的第一个元素。
removeLast();移除并返回此列表的最后一个元素。
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();
offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。
Set接口
Set体系的特点是元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。具体实现子类：
|--HashSet：数据结构是哈希表。线程是非同步的。保证元素唯一性的原理：判断元素的hashCode值是否相同。
如果相同，还会继续判断元素的equals方法，是否为true。
|--TreeSet：可以对Set集合中的元素进行排序。
底层数据结构是二叉树。
保证元素唯一性的依据：
compareTo方法return 0.
TreeSet排序的第一种方式：让元素自身具备比较性。
元素需要实现Comparable接口，覆盖compareTo方法。
也种方式也成为元素的自然顺序，或者叫做默认顺序。
class Student implements Comparable//该接口强制让学生具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
//return 0;
if(!(obj instanceof Student))
throw new RuntimeException("不是学生对象");
Student s = (Student)obj;
System.out.println(this.name+"....compareto....."+s.name);
if(this.age>s.age)
return 1;
if(this.age==s.age)
{
return this.name.compareTo(s.name);
}
return -1;
}
public String getName()
{
return name;
}
public int getAge()
{
return age;
}
}TreeSet的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。
这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。
class TreeSetTest
{
public static void main(String[] args)
{
TreeSet ts = new TreeSet(new StrLenComparator());
ts.add("abcd");
ts.add("cc");
ts.add("cba");
ts.add("aaa");
ts.add("z");
ts.add("hahaha");
Iterator it = ts.iterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
class StrLenComparator implements Comparator
{
public int compare(Object o1,Object o2)
{
String s1 = (String)o1;
String s2 = (String)o2;
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num==0)
return s1.compareTo(s2);
return num;
}
}
Map
该集合存储键值对。一对一对往里存。而且要保证键的唯一性。Map中也定义了一些该体系的共性方法，例如：1，添加
put(K key, V value) 将指定的值与此映射中的指定键关联
putAll(Map<? extends K,? extends V> m) 从指定映射中将所有映射关系复制到此映射中
2，删除
clear() 从此映射中移除所有映射关系
remove(Object key) 如果存在一个键的映射关系，则将其从此映射中移除
3，判断
containsValue(Object value) 如果此映射将一个或多个键映射到指定值，则返回 true。
containsKey(Object key) 如果此映射包含指定键的映射关系，则返回 true。
isEmpty() 如果此映射未包含键-值映射关系，则返回 true。
4，获取
get(Object key) 返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
size() 返回此映射中的键-值映射关系数。
values() 返回此映射中包含的值的 Collection 视图。
entrySet() 返回此映射中包含的映射关系的 Set 视图。
keySet() 返回此映射中包含的键的 Set 视图。
Map集合内部不包含有迭代器，所以只能通过把Map集合转化为Set集合，再通过迭代器取出元素。
Map集合的两种取出方式：
1，Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。
所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
//先获取map集合的所有键的Set集合,keySet();
Set<String> keySet = map.keySet();
//有了Set集合。就可以获取其迭代器。
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
//有了键可以通过map集合的get方法获取其对应的值。
String value = map.get(key);
System.out.println("key:"+key+",value:"+value);
}
2，Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry
Entry其实就是Map中的一个static内部接口。
为什么要定义在内部呢？
因为只有有了Map集合，有了键值对，才会有键值的映射关系。
关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。
//将Map集合中的映射关系取出。存入到Set集合中。
Set<Map.Entry<String,String>> entrySet = map.entrySet();
Iterator<Map.Entry<String,String>> it = entrySet.iterator();
while(it.hasNext())
{
Map.Entry<String,String> me = it.next();
String key = me.getKey();
String value = me.getValue();
System.out.println(key+":"+value);
}
具体实现子类：
|--Hashtable：底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序，原理与TreeSet一样。
588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
