----------android培训、java培训、java学习型技术博客、期待与您交流！ -----------
1，集合的继承体系
collection是顶层接口，子接口有set和list，和集合是同一级别的就是map接口了，它也是顶层接口。它们的实现子类有如下：
public static void construction_collection(){
//从下面可以看出collection接口是list和set的父接口
/*
* list的实现类有ArrayList，LinkedList，Vector
* set的实现类有HashSet，TreeSet
* map是一个独立的接口，实现类有HashMap，TreeMap
* */
List<String> l = new ArrayList<String>();
List<String> l2 = new LinkedList<String>();
List<String> l3 = new Vector<String>();
Set<String> s = new HashSet<String>();
Set<String> s2 = new TreeSet<String>();
Map<String, String> m = new HashMap<String, String>();
Map<String, String> m2 = new TreeMap<String, String>();
Collection<String> c = l;
Collection<String> c2 = s;
}2，集合的常用方法
集合的常用方法有add，removeiterator，size，contain，clear，isEmpty，toArray等方法，
public static void method_collection1(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
c.
sop("c的长度是"+c.size());
sop(c);
//将指定的元素从集合中删除
c.remove("bird01");
sop("删除元素后c的长度是"+c.size());
sop(c);
c.clear();
//判断集合是否为空
sop(c.isEmpty());
}
验证结果：
示例代码：
public static void method_collection2(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
sop("c的长度是"+c.size());
sop("c转换为数组"+c.toArray());
sop("c是否含有bird02"+c.contains("bird02"));
sop(c.isEmpty());
}验证结果：
3，集合的合并，交集，删除，包含的相关操作
两个集合取交集
public static void method_collection3(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
Collection c1 =new ArrayList();
c1.add("bird01");
c1.add("bird02");
c1.add("bird05");
c1.add("bird06");
sop(c);
sop(c1);
//主要用于获取c1中含有c的元素，类似于数学集合运算中的A交B操作
c1.retainAll(c);
sop(c1);
}验证结果：
集合的包含操作，判断一个集合是不是包含另一个集合
public static void method_collection4(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
Collection c1 =new ArrayList();
c1.add("bird01");
c1.add("bird02");
c1.add("bird05");
c1.add("bird06");
sop(c);
sop(c1);
//用于判断c是否是c1的子集
sop(c1.containsAll(c));
}验证结果：
集合的合并操作：
public static void method_collection5(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
Collection c1 =new ArrayList();
c1.add("bird01");
c1.add("bird02");
c1.add("bird05");
c1.add("bird06");
sop(c);
sop(c1);
//主要用于合并c1和c中的元素，类似于数学集合运算中的A并B操作
c1.addAll(c);
sop(c1);
}验证结果：
集合的差集操作：
public static void method_collection6(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
Collection c1 =new ArrayList();
c1.add("bird01");
c1.add("bird02");
c1.add("bird05");
c1.add("bird06");
sop(c);
sop(c1);
//主要用于删除c1中含有c的元素，类似于数学集合运算中的A－B操作
c1.removeAll(c);
sop(c1);
}验证结果：
4，集合的迭代器
集合中比较重要的就是迭代器了，它是遍历集合的有利法宝。
public static void iterator_method(){
/*
* 从模拟代码中可以分析出，mylist类内部封装了一个内部类（实现迭代器接口）
* 迭代器的hasnext()返回boolean类型的，
* 迭代器的next()返回的是一个l引用的对象
* */
List<Object> l = new mylist();
Iterator<Object> iterator = l.iterator();
}下面给出模拟代码，给出主要实现方法，其他方法省略。
class mylist implements List<Object>{
private class myiterator implements Iterator<Object>{
@Override
public boolean hasNext() {
// TODO Auto-generated method stub
return false;
}
@Override
public Object next() {
// TODO Auto-generated method stub
return null;
}
@Override
public void remove() {
// TODO Auto-generated method stub
}
}
@Override
public Iterator<Object> iterator() {
// TODO Auto-generated method stub
return new myiterator（）;
}
}从中可以看出，iterator（）方法的实现是new一个内部类myiterator。
5，list的常用方法
list 是collection的子接口，方法和collection差不多，下面给出一个简单的示例，加深印象。
public static void list_method(){
Collection c =new ArrayList();
c.add("bird01");
c.add("bird02");
c.add("bird03");
c.add("bird04");
List <Object> l = new ArrayList<Object>();
//Appends the specified element to the end of this list
l.add("mingren01");
l.add("mingren02");
l.add("mingren02");
l.add("mingren03");
//Appends all of the elements in the specified collection to the end of this list,
l.addAll(c);
sop(l);
//Removes the element at the specified position in this list
l.remove(0);
sop(l);
//the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element
sop(l.indexOf("mingren02"));
//the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element
sop(l.lastIndexOf("mingren02"));
//Returns a view of the portion of this list between the specified fromIndex, inclusive, and toIndex, exclusive
sop(l.subList(3, 5));
//Returns an iterator over the elements in this list in proper sequence
sop(l.iterator().toString());
//Returns a list iterator over the elements in this list.
sop(l.listIterator());
}验证结果：
补充：sublist含头不含尾。
6，list迭代问题分析
在迭代时可以对list进行增加元素操作吗？看如下代码
public static void list_method1(){
List <Object> l = new ArrayList<Object>();
l.add("mingren01");
l.add("mingren02");
l.add("mingren03");
Iterator<Object> it = l.iterator();
while(it.hasNext()){
//Exception in thread "main" java.util.ConcurrentModificationException
/*分析：看起来没有什么逻辑错误，it应该可以访问到mingren04这个对象，但是程序
* 抛出一个异常，这里主要涉及到两个引用（l.it）对对象的修改，这时就会产生
* 安全隐患，it指向的是原来的数据结构，但是l增加了一个元素，修改了数据结构
* it在每次执行next()方法时会首先调用 checkForComodification();检查list对象是否
* 被修改了即expectedModCount和ModCount的值是否相等如果修改ModCount就自增1， 因为 × expectedModCount值不等与ModCount了
* */
Object temp = it.next();
if(temp.equals("mingren02")){
l.add("mingren04");
}
}
sop(l);
}验证结果：
那么在迭代时，l进行remove操作呢？
public static void list_method2(){
List <Object> l = new ArrayList<Object>();
l.add("mingren01");
l.add("mingren02");
l.add("mingren03");
l.add("mingren04");
Iterator<Object> it = l.iterator();
while(it.hasNext()){
//问题：在迭代到第二个元素时，l把第二个元素删除了，那么it能继续迭代吗？
/*
* 结果：Exception in thread "main" java.util.ConcurrentModificationException
* 分析：按照常理，it可以迭代的，l的后面没有被修改，但是为什么就报异常呢，通过前面的
* 一个例子，结论是一样的，remove后， it调用checkForComodification()方法
* expectedModCount和ModCount值不一样了，所以抛出异常
* */
Object temp = it.next();
if(temp.equals("mingren02")){
l.remove("mingren02");
}
}
sop(l);
}验证结果：
l不行，那么用it看看行不行？
public static void list_method3(){
List <Object> l = new ArrayList<Object>();
l.add("mingren01");
l.add("mingren02");
l.add("mingren03");
l.add("mingren04");
Iterator<Object> it = l.iterator();
while(it.hasNext()){
Object temp = it.next();
if(temp.equals("mingren02")){
it.remove();
}
}
sop(l);
}验证结果：
结果是正确的，原因是什么呢？
分析：因为it的remove()操作是单独的，it指向的对象不存在数据同步问题，根据源码可以看出，it的remove()同时修改了expectedModCount和ModCount的值 * 确保在调用checkForComodification时，不会抛出异常
源码如下：
public void remove() {
if (lastRet == -1)
throw new IllegalStateException();
checkForComodification();
try {
AbstractList.this.remove(lastRet);
if (lastRet < cursor)
cursor--;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException e) {
throw new ConcurrentModificationException();
}
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}7，listIterator
对arraylist遍历操作时，想要在遍历过程中添加一些额外的操作，可以用iterator的子接口ListIterator来扩展功能，如add(Object obj),set(Object obj),hasprevious() 等方法
public static void list_method4(){
List <Object> l = new ArrayList<Object>();
l.add("mingren01");
l.add("mingren02");
l.add("mingren03");
l.add("mingren04");
ListIterator<Object> it = l.listIterator();
while(it.hasNext()){
/*
* 对arraylist遍历操作时，想要在遍历过程中添加一些额外的操作，可以用iterator的
* 子接口ListIterator来扩展功能，如add(Object obj),set(Object obj),hasprevious()
* 等方法
* */
Object temp = it.next();
if(temp.equals("mingren02")){
it.add("mingren05");
}
if(temp.equals("mingren03")){
it.set("mingren006");
}
/*if(temp.equals("mingren04")){
sop(it.previous());
}*/
sop(temp);
}
sop(l);
}验证代码：
----------android培训、java培训、java学习型技术博客、期待与您交流！ -----------
扫一扫
563
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
