----------------------
ASP.Net+Android+IO开发S、
.Net培训、期待与您交流！ ----------------------
集合框架
概述
为什么出现集合类：
面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式。
数组和集合类同是容器，有何不同：
数组虽然也可以存储对象，但长度是固定的，集合长度是可变的，数组中可以存储基本数据类型，集合只能存储对象。
集合类的特点
集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象。
数据结构：集合框架中有很多种容器类型，每一个容器对数据的存储方式都不同，这个存储方式称为数据结构。
Collection
Collection 层次结构 中的根接口。Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，而另一些则不允许。一些 collection 是有序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实现：它提供更具体的子接口（如 Set 和 List）实现。此接口通常用来传递 collection，并在需要最大普遍性的地方操作这些 collection。
方法的使用：见例1.
迭代器
定义：其实就是集合的取出元素的方式。
方法：
boolean hasNext()
如果仍有元素可以迭代，则返回 true。
E next()
返回迭代的下一个元素。
void remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。
内部设计方式：
集合把取出元素的方式定义在其内部，这样取出方式就可以直接访问集合内部的元素，取出方式就被定义成了内部类。而每一个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容：判断和取出。那么就可以将这些共性抽取。这些内部类都符合一个规则：Iterator。通过一个对外提供的方法：iterator();供外部调用。
注意：在迭代时循环中next调用一次就需要hasNext判断一次。
例1：
import java.util.*;
public class APITest
{
public static void main(String[] ags)
{
public static void sop(Object obj)
{
System.out.println(obj);
}
//建立一个集合容器，使用Collection接口的子类。ArrayList
ArrayList al1 = new ArrayList();
//添加元素
al1.add("java01");
al1.add("java02");
al1.add("java03");
al1.add("java04");
/**/
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java02");
al2.add("java05");
al2.add("java06");
//获取元素个数，集合长度。编译会有提示，可以不用管。
sop("size:"+al1.size());
//删除元素。
al1.remove("java02");
//清空集合
al1.clear();
//判断元素
sop("java03是否存在："+al1.contains("java03"));
sop("集合是否为空？"+al1.isEmpty());
//打印集合
sop(al1);
//取交集。al1中只会保留和al2中相同的元素。
al1.retainAll(al2);
sop("al1与al2的交集："+al1);
//取非交集。al1中会删除和al2中相同的元素。
al1.removeAll(al2);
sop("al1与a2的非交集："+al1);
//迭代器。
Iterator it = al1.iterator();
while(it.hasNext())//指针后还有元素，it.hasNext()的值为true。
{
sop(it.next());//it.next()迭代取出集合中元素。
}
}
}Conllection
|--List ：元素是有序的，元素可以重复，因为该集合体系有索引。
|---- |--ArrayList 底层的数据结构使用的是数组结构。特点：查询速度快，但是增删较慢。1.2版本开始使用。线程不同步，效率高。
|---- |--LinkedList 底层使用的是链表数据结构。特点：增删较快，但是查询较慢。
| ----|--Vector 底层是数组数据结构。1.0版本开始使用。线程同步，效率低。
|
|
|--Set： 元素是无序的，元素不可以重复。
List-------------------
特有方法：凡是可以操作角标的方法都是该体系特有的方法。
增
add(index, element);
addAll(index, Collection);
删
remove(index);
改
set(index, element);
查
get(index);
subList(from,to);
listIterator();
List集合特有的迭代器：
ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生并发异常。所以在迭代器时，只能用迭代器的方法操作元素。可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作。如果想要其他的操作，就需要使用其子接口：ListIterator。该接口只能通过List集合的listIterator方法获取。
例2：列表迭代器
ArrayList a1 = new ArrayList();
a1.add("java01");
a1.add("java02");
a1.add("java03");
ListIterator li = a1.listIterator();
while(li.hasNext());
{
object obj = li.next();
if(obj.equals("java02"))
li.add("java008");//增加
li.set("java009");//修改
}
li.hasPrevious();//判断指针前有没有元素，有则为true无则为false。Vector枚举
枚举就是Vector特有的取出方式，枚举和迭代是一样的。由于枚举的名称以及方法的名称过长，所以被迭代器所取代。
LinkedList-----
特有方法。
void addFirst(E e)
将指定元素插入此列表的开头。
void addLast(E e)
将指定元素添加到此列表的结尾。
┏━E getFirst()
┃ 返回此列表的第一个元素。
┣━E getLast()
┃ 返回此列表的最后一个元素。
┃
┣━E removeFirst()
┃ 移除并返回此列表的第一个元素。
┣━E removeLast()
┃ 移除并返回此列表的最后一个元素。
┗━▶在集合为空的时候，会出现NoSuchElementException异常。
在JDK1.6出现了替代方法。
boolean offerFirst(E e)
在此列表的开头插入指定的元素。
boolean offerLast(E e)
在此列表末尾插入指定的元素。
E peekFirst()
获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast()
获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pollFirst()
获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast()
获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
Set---------------------------
┣━HashSet：底层数据结构是哈希表。线程是非同步的。 ┃┗━TreeSet：可以对set集合中的元素进行排序。底层数据结构是二叉树。
特点
Set集合中元素是无序（存入和去除的顺序不一定一致），元素不可以重复。
Set集合的功能和Collection是一致的。
HashSet------
例：
HashSet hs = new HashSet();
hs.add("java01");//返回值是true，存入成功。
hs.add("java01");//返回值是false，存入失败。
hs.add("java02");
hs.add("java03");
hs.add("java03");
hs.add("java04");HashSet储存自定义对象的方法------
HashSet如何保证元素唯一性的？
是通过元素的两个方法：hashCode和equals来完成。如果元素的HashCode值相同，才会判断equals是否为true。如果不同，就不会调用equals。
例：
/*
姓名年龄相同，则视为同一个人。
*/
class Person
{
private String name;
private int age;
Person(String name,int age)
{
this.name = name;
this.age = age;
}
public int hashCode()//复写hashCode()方法。
{
//姓名和年龄相同，则返回相同的哈希值。27的作用：避免姓名的哈希值与年龄的哈希值相加出现相同值情况。
return this.name.hashCode()+age*27;
}
public boolean equals(Object obj)//复写equals方法。
{
if(!(obj instanceof Person))//需要判断obj对象是否指向Person。
return false;
Person p = (Person) obj;//因为所用到的name与age等参数不是Object中的成员，所以需要转型。
return this.name.equals(p.name)&&this.age == p.age;
}
}注意：判断元素是否存在以及删除等操作，都依赖元素的hashCode和equals方法。先是判断哈希值是否相同，然后通过equals比较元素，最后才可以确认此元素，并进行对应的操作。
TreeSet------
保证元素唯一性的依据：compareTo方法return 0.
注意：当主要条件相同时，一定要判断一下次要条件。
TreeSet排序------
第一种排序方式：让元素自身具备比较性。元素需要实现comparable接口，并复写compareTo方法。
TreeSet存储自定义元素，需要复写compareTo方法。注意：当主要条件相同时，一定要判断一下次要条件。
int compareTo(T o)
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
例：
class Student implements Comparable//该接口强制使Student具备比较性。
{
private String name;
private int age;
Student(String name,int age)
{
this.name = name;
this.age = age;
}
public int compareTo(Object obj)
{
if(!(obj instanceof Student))
throw new RuntimeException("非Student对象");
Student s = (Student)obj;
if(this.age == s.age)
{return this.name.compareTo(s.name);}
return (this.age - s.age);
}
}第二种排序方式：当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时需要让集合自身具备比较性。在集合初始化时就有了比较方式。定义一个比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
比较器定义方法：定义一个类，实现comparator旧口，覆盖compare方法。
注意：当两种排序方法都存在时，以比较器为主。
例：
//定义比较器。
class MyCompare implements Comparator
{
public int compare(Object obj1,Object obj2)
{
Student s1 = (Student)obj1;
Student s2 = (Student)obj2;
int num;
num = s1.getName().compareTo(s2.getName());
if(num == 0)
return (new Integer(s1.getAge()).compareTo(new Integer(s2.getAge())));
return num;
}
}
class TreeSetTest
{
public static void main(String[] args)
{
//将比较器对象作为参数传递给TreeSet集合的构造函数
TreeSet ts = new TreeSet(new MyCompare());
}
}泛型------
JDK1.5版本以后出现的新特性，用于解决安全问题，是一个安全机制。
好处：
1.将运行时期出现问题ClassCastException转移到了编译时期。方便于程序员解决问题，让运行时期问题减少，安全。
2.避免了强制转换麻烦。
泛型格式：
通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。
其实<>就是用来接收类型的。当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。
例：
ArrayList<String> al = new ArrayList<String>();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
Iterator<String> i = hs.iterator();
while (i.hasNext())
{
String s = i.next();//不用强制转换类型。也可以使用length方法。
System.out.println(s + ":"+s.length());
}接口 Comparator<T>------
类型参数：
T - 此 Comparator 可以比较的对象类型
public interface Comparator<T>
强行对某个对象 collection 进行整体排序 的比较函数。
例：
class MyComparator implements Comparator<String>
{
public int compare(String s1,String s2)
{
int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));
if(num == 0)
{
return s1.compareTo(s2);
}
return num;
}
}泛型类------
什么时候使用泛型类？
当类中要操作的引用数据类型不确定的时候，早期定义Object来扩展，现在定义泛型来扩咱。
例：
//非泛型类的定义
class Utils<Object obj>
{
private Object obj;
public void setObject(Object obj)
{
this.obj = obj;
}
public void getObject()
{
return obj;
}
}
//建立对象以及方法调用
Utils u = new Utils();
u.setObject(new Worker());//当传入的对象不是指向Worker类的，编译通过，但运行失败。
Worker w = (Worker)u.getObject();//必须强转类型。
//泛型类的定义。
class Utils<QQ>
{
private QQ q;
public void setObject(QQ q);
{
this.q = q;
}
public void getObject()
{
return q;
}
}
//建立对象以及方法调用
Utils<Worker> u = new Utils<Worker>();
u.setObject(new Worker());//当传入的对象不是指向Worker类的，编译不能通过，将错误转到编译时期。
Worker w = u.getObject();//不用强转类型。泛型方法------
泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，存在局限性。
例：
class Demo<String>
{
public void show()
{
}
}
class GenericDemo
{
Demo<String> d = new Demo<String>();
d.show("java");//传入String型参数，编译通过。
d.show(2);//传入int型参数，编译失败。
}为了让不同方法可以操作不同类型，而且类型不确定，可以将泛型定义在方法上。
例：
class Demo
{
public <T> void show(T t)
{
}
}
class GenericDemo
{
Demo d = new Demo();
d.show("java");//传入String型参数，编译通过。
d.show(2);//传入int型参数，编译通过。但是当Demo是泛型类，且定义为：Demo<T>时，则编译失败。
}特殊之处：
静态方法不可以访问类上定义的泛型。如果静态方法的参数类型不确定，可以将泛型定义在方法上。
例：
class Demo<T>
{
public static <W> show(W w)
{
}
}泛型接口------
interface Inter<>
{
}
class InterImpl<T> implements Inter<T t>
{
}?通配符，也可以理解为占位符。
例：
public void show(ArrayList<?> al)
{
}<?>与<T t>形式的区别：用<?>不可以操作参数，用<T t>形式可以操作参数t。
泛型的限定：
? extends E 可以接受E类型或者E的子类型。上限。
? super E 可以接受E类型或者E的父类型。下限。
例：
public static void show(ArrayList<? extends E> al)//接收上限是E类型。可以接收E类型以及其子类型集合，不可以接收其父类型集合。
{
}
public static void show1(ArrayList<? super E> al)//接收下限是E类型，可以接收E类型以及其父类型集合，不可以接收其子类型集合。
{
}Map集合------
|---Hashtable： 底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0 效率低
|---HashMap 底层是哈希表数据结构，可以存入null键null值。该集合是不同步的。jdk1.2 效率高
|---TreeMap 底层是二叉树数据结构，线程不同步。可以用于给map集合中的键进行排序。
结构和Set很像。其实Set底层就是使用了Map集合。
Map<K,V>
类型参数：K - 此映射所维护的键的类型V - 映射值的类型
特点：该集合存储键值对。一对一对往里存，而且要保证键的唯一性。
主要方法：
1.添加
V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。
添加元素，添加元素，如果出现添加时，相同的键。那么后添加的值会覆盖原有键对应值。并且put方法会返回被覆盖之前的值。
void putAll(Map<? extends K,? extends V> m)
从指定映射中将所有映射关系复制到此映射中（可选操作）。
2.删除
void clear()
从此映射中移除所有映射关系（可选操作）。
V remove(Object key)
如果存在一个键的映射关系，则将其从此映射中移除（可选操作）。
3.判断
boolean containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
boolean equals(Object o)
比较指定的对象与此映射是否相等。
boolean isEmpty()
如果此映射未包含键-值映射关系，则返回 true。
4.获取
V get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
int hashCode()
返回此映射的哈希码值。
int size()
返回此映射中的键-值映射关系数。
Collection<V> values()
返回此映射中包含的值的 Collection 视图。
* Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
* Set<K> keySet()
返回此映射中包含的键的 Set 视图。
Set<K> keySet() ------
将map中所有的键存入到Set集合，因为set具备迭代器，所有可以迭代方式取出所有的键，再根据get方法，获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合，再通过迭代器取出。
例：
Map<String,String> map = new HashMap<String,String>();
map.put("01", "java01");
Set<String> keySet = map.keySet();
Iterator<String> it = keySet.iterator();
while(it.hasNext())
{
String key = it.next();
String value = map.get(key);
System.out.println("key:"+key+"...value:"+value);
}Set<Map.Entry<K,V>>entrySet()------
将map中所有的键与值的关系：Map.Entry 存入到Set集合，就可以通过迭代方式取出所有的关系对象Map.Entry，再通过Map.Entry接口的getKey与getValue方法获取每一个关系中的键与对应的值。
Map.Entry：其实Entry也是一个接口，它是Map接口中的一个内部接口。
例：
Map<String,String> map = new HashMap<String,String>();
map.put("01", "java01");
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);
}Collections------
主要方法：
static <T extends Comparable<? super T>> void sort(List<T> list)
根据元素的自然顺序 对指定列表按升序进行排序。
例：Collections.sort(list);
static <T> void sort(List<T> list, Comparator<? super T> c)
根据指定比较器产生的顺序对指定列表进行排序。
例：Collections.sort(list,new SortComparator());
static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
根据元素的自然顺序，返回给定 collection 的最大元素。
例：Collections.max(list);
static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。
例：Collections.max(list,new MaxComparator());
static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
使用二分搜索法搜索指定列表，以获得指定对象。
例：Collections.binarySearch(list,"aaa");
static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
使用二分搜索法搜索指定列表，以获得指定对象。
例：Collections.binarySearch(list,"aaa",new BSComparator()):
static <T> void fill(List<? super T> list, T obj)
使用指定元素替换指定列表中的所有元素。
例：Collections.fill(list,"qq");
static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
使用另一个值替换列表中出现的所有某一指定值。
例：Collections.replaceAll(list,"aaa","qqq");
static void reverse(List<?> list)
反转指定列表中元素的顺序。
例：Collections.reverse(list);
static <T> Comparator<T> reverseOrder()
返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序。
例：TreeSet ts = new TreeSet(Collections.reverseOrder());
static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
返回一个比较器，它强行逆转指定比较器的顺序。
例：TreeSet ts = new TreeSet(Collections.reverseOrder(new TsComparator()));
static void swap(List<?> list, int i, int j)
在指定列表的指定位置处交换元素。
例：Collections.swap(list,1,2);
static void shuffle(List<?> list)
使用默认随机源对指定列表进行置换。
例：Collections.shuffle(list);
Arrays------
主要方法
static <T> List<T> asList(T... a)
返回一个受指定数组支持的固定大小的列表。
例：List<String> li = Arrays.asList(arr);
List<int[]> li = Arrays.asList(arr);
注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定的。
如果数组中的元素都是对象，那么变成集合时，数组中的对象就转成集合中的元素，如果数组中的元素都是基本数据类型，那么就会将该数组作为集合中的元素存在。
集合变数组------
<T> T[] toArray(T[] a)
返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。
例：String[] arr = al.toArray(new String[0]);
注：1.指定类型的数组到底要定义多长？
当制定类型的数组长度小于集合的size，那么该方法内部会创建一个新的数组，长度为集合的size。
当指定类型的数组长度大于集合的size，就不会新创建了数组，而是使用了传递进来的数组。
所以创建一个刚刚好的数组最优。
2.为什么要将集合变成数组？
为了限定对元素的操作。不需要进行增删。
高级for循环------
格式：
for(数据类型 变量名 : 被遍历的集合(Collection)或者数组)
{
}
对集合进行遍历，只能获取元素，但是不能对集合进行操作。
迭代器除了遍历，还可以进行remove集合中元素的动作。
例：
for(int i:arr)
{
System.out.println(i);
}
传统for循环和高级for循环的区别：
1.高级for有一个局限性，必须有被遍历的目标。
建议在遍历数组的时候，还是希望使用传统for，因为传统for有脚标。
可变参数------jdk1.5
其实就是一种简写形式，它隐式将参数封装成数组。
格式：T...a
例：
show(int...arr){}//定义
show(2,4,5,6);//调用
使用时注意：可变参数一定要定义在参数列表的最后。
StaticImport 静态导入------
静态导入，导入的是类中的所有静态成员。
例：
import static java.util.Arrays.*;
sort(arr);//此时就不用加前缀：Arrays.
注：
当类名重名时，需要指定具体的包名。
当方法重名时，指定具备所属的对象或者类。
---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------详细请查看：http://edu.csdn.net
521
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
