---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------
一、集合类
1、集合类的由来
我们知道面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储。集合就是存储对象最常用的一种方式。对象里面封装数据，集合里面封装对象。
2、集合和数据的区别
1）数组中可以存储基本数据类型和对象类型；集合中只能存储对象类型。
2）数组的长度是固定的；集合的长度是可变的。
3）数组中存储的数据类型要一致；集合可以存储不同类型的对象。
当我们在遇到不明确对象数量和类型的情况下，可以选择用集合存储。
二、集合框架的构成及分类
在java中定义了很多集合，每种集合存储数据的方式不同，将其中共性的内容不断的向上抽取，就形成了集合框架。如下图所示：
其中，虚线框中代表的是集合中的接口，实线框代表的是集合中的类。
为什么会出现这么多的集合容器呢？
因为每一个容器对数据的存储方式都有不同，这个存储方式称之为：数据结构。
三、集合框架中的常用接口
集合框架中常用的接口有：Collection接口、Map接口、List接口、Set接口和Iterator接口等。
各自的特点和作用：
Collection接口存储一组不唯一（允许重复）、无序的对象。
Set接口继承Collection接口，存储一组唯一（不允许重复）、无序的对象。
List接口继承Collection接口，存储一组不唯一（允许重复）、有序（以元素插入的次序来放置元素，不会重新排列）的对象。
Map接口存储一组成对的键-值对象，提供key（键）到value（值）的映射。Map中的key不要求有序，不允许重复（如果重复，key对应的value会有覆盖操作）。value同样不要求有序，但允许重复。
Iterator接口是对collection进行迭代的迭代器。
四、Collection接口中的常用方法
首先创建一个集合容器：ArrayList al=new ArrayList();
1、添加
boolean add(element)：向该集合的末尾添加指定的元素。
该方法的参数类型是Object，以便于接收任意类型的对象。集合中存储的并不是对象实体，而是对象的引用（地址）。
al.add("java01");
al.add("java02");
al.add("java03");
System.out.println("原集合al:"+al); //打印结果：原集合al:[java01,java02,java03]
boolean addAll(Collection)：将指定 collection 中的所有元素都添加到此 collection 中。（可以添加一堆元素）
2、移除
boolean remove(Object)：从此 collection 中移除指定元素的单个实例，如果存在的话。
al.remove("java01");
System.out.println("现集合al:"+al); //打印结果：现集合al:[java02,java03]
boolean removeAll(Collection)：移除此collection中那些也包含在指定collection中的所有元素（移除交集）。
boolean retainAll(Collection)：仅保留此 collection 中那些也包含在指定 collection 的元素（仅保留交集）。
void clear()：移除此collection中的所有元素（清空）。
3、判断
boolean contains(Object o)：判断某一元素是否存在于集合中。
System.out.println(al.contains("java03")); //打印结果：true
boolean containsAll(Collection)：如果此collection包含指定collection中的所有元素，则返回true。
ArrayList al2=new ArrayList();
al2.add("java03");
System.out.println(al.containsAll(al2)); //打印结果：true
boolean equals(Object o)：比较此collection与指定对象是否相等。
ArrayList arrl1=new ArrayList();
arrl1.add("java");
arrl1.add(333);
ArrayList arrl2=new ArrayList();
arrl2.add("java");
arrl2.add(333);
System.out.println(arrl1.equals(arrl2)); //打印结果：true
boolean isEmpty()：判断此集合中是否有内容。
4、查询
int size()：返回此collection中的元素数。
System.out.println(al.size()); //返回结果：2
int haseCode()：返回此collection的哈希码值。
5、将集合中的元素存放到某一数组中：Object[] toArray()：
五、List接口中常用类
List集合中的元素是有序的，元素可以重复，是因为该集合体系有索引。
void add(index,element)：在指定的位置添加元素。
al.add(1,"java04");
System.out.println("现集合al:"+al); //打印结果：现集合al:[java01,java04,java02,java03]
System.out.println("现集合al:"+al); //打印结果：现集合al:[java01,java04,java05,java02,java03]
System.out.println("现集合al:"+al); //打印结果：现集合al:[java01,java004,java05,java02,java03]
System.out.println("index="+index); //打印结果：index=4
public static void main(String[] args)
{
//创建一个集合容器
ArrayList al=new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
//使用迭代器遍历过程中，如果通过集合中的方法对集合进行并发操作
//则会发生异常：java.util.ConcurrentModificationException（并发操作异常）
//当方法检测到对象的并发修改，但不允许这种修改时，抛出此异常。
/*for (Iterator in=al.iterator();in.hasNext() ; )
{
Object obj=in.next();
if(obj.equals("java02"))
{
al.add("java04");
}
System.out.println("obj:"+obj);
}*/
//此迭代器没有添加方法
/*for (Iterator in=al.iterator();in.hasNext() ; )
{
Object obj=in.next();
if(obj.equals("java02"))
{
in.remove();
}
System.out.println("obj:"+obj);
}
System.out.println("现集合al:"+al);*/
/*
输出结果：
obj:java01
obj:java02
obj:java03
现集合al:[java01, java03]
问题：为什么"java02"已经删除了，怎么还会打印obj:java02呢？
因为in.remove()方法只是把此元素的引用从集合al中删除了，但是obj的指向仍然在，
所以会打印，但是集合中却没有了此元素。
*/
/*for (ListIterator li=al.listIterator();li.hasNext() ; )
{
Object obj=li.next();
if(obj.equals("java02"))
{
li.add("java04");
//修改元素内容
//li.set("java04");
}
System.out.println("obj="+obj);
}
System.out.println("现集合al:"+al);*/
/*
输出结果：
obj=java01
obj=java02
obj=java03
现集合al:[java01, java02, java04, java03]
此操作会在"java02"的后面添加元素！
*/
ListIterator li=al.listIterator();
//正向遍历集合中的元素
while(li.hasNext())
{
System.out.println(li.next());
}
//逆向遍历集合中的元素
while(li.hasPrevious())
{
System.out.println(li.previous());
}
}七、Set接口中常用类
Set接口中的元素是无序的（存入和取出的顺序不一定一致），元素不可以重复。Set接口的功能和Collection接口是一致的。
HashSet：底层数据结构是哈希表。线程不安全，存取速度快。
什么是哈希表数据结构？
首先判断对象在内存中的地址是否相同，如果相同，那么判断对象是否相同，如果也相同，就不会存储。因为Set接口中的元素是无序的，唯一的。如果不相同，那么在此地址下在顺延一个地址，这两个地址相同，但指向的对象不同。这就是哈希表存储方式。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法：hashCode()和equals()来完成。如果元素的hashcode值相同，才会判断equals是否为true。如果元素的hashcode值不同，不会调用equals()方法。
TreeSet：底层数据结构是二叉树。线程不安全。可以对Set集合中的元素进行排序。不具备比较性的对象是不能存入TreeSet集合的！
什么是二叉树数据结构？
二叉树数据结构的原理就是大元素放右边，小元素放左边，按顺序从小到大打印输出。
TreeSet集合有两种排序方式：
TreeSet集合排序的第一种方式：让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo()方法。这种方式也称为元素的自然排序，或者叫做默认顺序。
TreeSet集合的第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。自定义比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。在集合初始化时，就有了比较方式。当两种排序都存在时，以比较器为主。如何自定义比较器？定义一个类，实现Comparator接口，覆盖compare()方法。
八、泛型
泛型是JDK1.5版本以后出现的新特性。用于解决安全问题，是一个类型安全机制。
1、泛型的好处：
1）将运行时期出现的问题：ClassCastException，转移到了编译时期。方便于程序员解决问题，让运行期间问题减少，安全。
2）避免了强制转换的麻烦。
2、泛型定义的格式：
通过<>来定义要操作的引用数据类型。泛型通常在java的集合框架中很常见，只要见到<>就要定义泛型。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
3、自定义泛型类
当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展，现在定义泛型来完成扩展。
例如：class Utils<MyType>{}
泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。
泛型方法：
为了让不同的方法可以操作不同类型，而且类型还不确定，那么可以将泛型定义在方法上。
静态泛型方法：
静态方法不可以访问类上定义的泛型。泛型类里面不可以定义静态非泛型方法。也就是说只要类是泛型类，那么静态方法也就是静态泛型方法。如果静态方法操作的引用数据类型不确定，可以将泛型定义在方法上。
4、泛型的限定：
？通配符，也可以理解为占位符。
？ extends E ：可以接收E类型或者E类型的子类型。上限。
？ super E ：可以接收E类型或者E类型的父类型。下限。
注意：实例化泛型类或者泛型接口的子类对象时，如果左右两边都用到泛型，那么左右两边类型要一致，否则编译错误！
九、Map集合中常用类
Map集合存储键值对。一对一对的往里存，而且要保证键的唯一性。和Set集合很像，其实Set集合底层就是使用了Map集合。
Map集合中常用的类有：Hashtable,HashMap,TreeMap。
Hashtable：底层是哈希表数据结构，不可以存入null键和null值。线程同步，效率比HashMap低，是从JDK1.0版本中出现的，已被HashMap替代。
HashMap：底层是哈希表数据结构，允许使用null键和null值。线程不同步，效率高，是从JDK1.2版本中出现的。
TreeMap：底层是二叉树数据结构，线程不同步。可以用于给Map集合中的键进行排序。
十、Map集合的常用方法
首先定义一个Map集合对象：Map<String,String> m=new HashMap<String,String>();
1、添加
V put(K key,V value)：将指定的值与此映射中的指定键关联。添加元素，如果键相同，那么后一个值会覆盖前一个值。但是put()方法会返回前一个值！
m.put("01","zhangsan01");
m.put("02","zhangsan02");
m.put("03","zhangsan03");
m.put("04","zhangsan04");
m.put("05","zhangsan05");
m.put("06","zhangsan06");
System.out.println(m); //打印结果：{04=zhangsan04, 05=zhangsan05, 06=zhangsan06, 01=zhangsan01, 02=zhangsan02, 03=zhangsan03}
void putAll(Map<? extends K,? extends V> m)：从指定映射中将所有映射关系复制到此映射中。（添加一堆键值对）
2、删除
void clear()：从此映射中移除所有映射关系。
m.clear();
System.out.println(m); //打印结果：{}
V remove(Object key)：如果存在一个键的映射关系，则将其从此映射中移除。
首先重新添加元素：
m.put("01","zhangsan01");
m.put("02","zhangsan02");
m.put("03","zhangsan03");
m.put("04","zhangsan04");
m.put("05","zhangsan05");
m.put("06","zhangsan06");
m.remove("02");
System.out.println(m); //打印结果：{04=zhangsan04, 05=zhangsan05, 06=zhangsan06, 01=zhangsan01, 03=zhangsan03}
3、判断
boolean containsKey(Object key)：如果此映射包含指定键的映射关系，则返回true。
System.out.println(m.containsKey("04")); //打印结果：true
boolean containsValue(Object value)：如果此映射将一个或多个键映射到指定值，则返回true。
System.out.println(m.containsValue("zhangsan04")); //打印结果：true
boolean isEmpty()：如果此映射未包含键-值映射关系，则返回true。
System.out.println(m.isEmpty()); //打印结果：false
4、获取
V get(Object key)：返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回null。
System.out.println(m.get("04")); //打印结果：zhangsan04
int size()：返回此映射中的键-值映射关系数。
Collection<V> values()：返回此映射中包含的值的Collection视图。
System.out.println(m.values()); //打印结果：[zhangsan04, zhangsan05, zhangsan06, zhangsan01, zhangsan03]
Set<Map.Entry<K,V>> entrySet()：返回此映射中包含的映射关系的Set视图。通常用于遍历集合中的元素。Entry其实也是一个接口，是Map接口中的一个内部接口。
Set<K> keySet()：返回此映射中包含的键的Set视图。通常用于遍历集合中的元素。
package demo1;
import java.util.*;
class MapDemo
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
//创建一个集合容器
Map<String,String> m=new HashMap<String,String>();
//添加元素
//添加元素，如果键相同，那么后一个值会覆盖前一个值，
//但是put()方法会返回前一个值！
m.put("01","zhangsan01");
m.put("02","zhangsan02");
m.put("03","zhangsan03");
m.put("04","zhangsan04");
m.put("05","zhangsan05");
m.put("06","zhangsan06");
sop("原集合："+m);
sop("根据键找值是否存在：03="+m.containsKey("03"));
sop("根据键移除对应的值并返回：03="+m.remove("03"));
sop("根据键返回对应的值，不移除：02="+m.get("02"));
sop("现集合："+m);
//返回m集合中所有的（值）。
Collection<String> coll=m.values();
sop(coll);
/*
根据键找值
Map集合的keySet()方法可以返回集合中所有的键，是一个Set集合
使用迭代器遍历Set集合，然后根据键找值
*/
Set<String> keySet=m.keySet();
for (Iterator<String> it=keySet.iterator();it.hasNext() ; )
{
String key=it.next();
sop(key+"→→"+m.get(key));
}
sop("---------------映射关系获得键和值-----------------");
/*
Map集合的entrySet()方法可以获取集合中所有的映射关系，也是一个Set集合
使用迭代器遍历Set集合，然后根据映射关系查找键和值。
*/
Set<Map.Entry<String,String>> mapEntry=m.entrySet();
for (Iterator<Map.Entry<String,String>> it=mapEntry.iterator(); it.hasNext() ; )
{
Map.Entry<String,String> me=it.next();
String key=me.getKey();
String value=me.getValue();
sop(key+"→→"+value);
}
}
}
十一、Map接口Collection接口的区别
举例：
static <T> List<T> asList(T... a)：将数组变成List集合。
说明一下：如果数组中的元素都是对象，那么变成集合时，数组中的元素就直接转成集合中的元素；如果数组中的元素都是基本数据类型，那么会将该数组作为集合中的元素存在。
把数组变成List集合有什么好处？
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法，因为数组的长度是固定的。如果你使用了增删操作，那么会发生UnsupportedOperationException不支持的操作异常。但可以使用比如：contains(),get(),indexOf(),subList()……等方法。
那么如何把集合变成数组呢？
使用Collection接口的toArray()方法。
为什么要将集合变成数组？
为了限定对元素的操作。不可以增删。
当指定类型的数组长度小于了集合的size，那么该方法内部会创建一个新的数组。长度为集合的size。
当指定类型的数组长度大于了集合的size，那么就不会新创建一个数组，而是使用传递进来的数组。
所以，创建一个长度刚刚好的数组最优。
---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------
详细请查看：<a href="http://edu.csdn.net" target="blank">http://edu.csdn.net</a>
1600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
