java迭代器 异常_java学习-集合、list、泛型、迭代器、并发异常

一、集合体结构

1.为什么使用集合?

数组容器是定长容器, 当定义出一个数组,必须指定长度;

集合容器,可以存放很多的数据, 但是集合是长度可变的容器(当集合容器中的数据存储空间不够, 系统会为集合进行自动扩容), 在实际开发中, 当并不知道数据有多少,集合就是最优秀的容器选择

2.集合体系结构:

二、Collection集合

2.1 Collection的介绍和常用方法

注意 : 所有集合中存储的元素全部都是引用数据类型:

如果需要存储基本数据类型, 可以将基本类型进行自动装箱, 变成引用存储; 当使用集合中基本类型时, 再通过自动拆箱将数据获取到;

1.Collection集合 : 所有单列集合顶层父接口, 来自于java.util包,所有单列集合都需要实现Collection中的所有方法功能, Collection集合中具有List和Set集合中所有共有方法

2.Collection 是接口,不能实例化对象, 因此需要一个Collection的实现类, 找到ArrayList, 运用接口多态性

Collection coll = new ArrayList();

3.Collection中的常用方法:

1) add(Object obj): 将参数obj添加到集合中, 末尾追加, 方法返回值类型boolean, 添加成功返回true,添加失败返回false

2) remove(Object obj) : 将参数obj元素从集合中删除, 删除成功, 返回true, 如果删除失败, 返回false

3) clear() : 表示清空集合, 将集合中的所有元素全部删除, 集合仍然存在

4) isEmpty() : 验证集合中是否有元素, 如果没有元素,返回true; 如果有元素, 返回false

5) size() : 表示获取到集合中元素的个数(获取集合的大小),返回值类型int类型

6) contains(Objectobj): 验证集合中是否包含参数obj,如果包含返回true. 如果不包含返回false

代码

public classDemo01_Collection常用方法 {public static voidmain(String[] args) {

Collection coll= newArrayList();//1.add(Object obj): 将参数obj添加到集合中, 末尾追加,//方法返回值类型boolean, 添加成功返回true,添加失败返回false

coll.add("a");

coll.add("b");

coll.add("c");

coll.add("hello");

System.out.println(coll);//[a, b, c, hello]

System.out.println(coll.isEmpty());//false

System.out.println(coll.contains("a"));//true

System.out.println(coll.contains("c1"));//false//2.remove(Object obj) : 将参数obj元素从集合中删除, 删除成功, 返回true,//如果删除失败, 返回false

System.out.println(coll.remove("c"));//true

System.out.println(coll);//[a, b, hello]

System.out.println(coll.size());//3//3. clear() : 表示清空集合, 将集合中的所有元素全部删除, 集合仍然存在

coll.clear();

System.out.println(coll);//[]//4. isEmpty() : 验证集合中是否有元素, 如果没有元素,返回true; 如果有元素, 返回false

boolean boo =coll.isEmpty();

System.out.println(boo);//true//5. size():表示获取到集合中元素的个数(获取集合的大小),返回值类型int类型

System.out.println(coll.size());//0

}

2.2 Collection集合的第一种遍历方式

1. 集合遍历 : 表示将集合容器中的元素一个一个获取到

2. 使用Collection中的方法 :

toArray() : 将一个集合中的所有元素放置到一个数组中(集合转数组), 返回值类型Object[], 通过遍历数组相当于遍历集合

注意 : 从Object类型数组中获取到的每一个元素,Object类型，想要转换成集合中数据类型本身, 需要做多态的向下转型

代码

public classDemo02_集合第一种遍历 {public static voidmain(String[] args) {

Collection coll= newArrayList();//12--->自动装箱,Integer

coll.add(12);

coll.add(-78);

coll.add(0);//1. 将集合转换成数组

Object[] objArr =coll.toArray();//2. 遍历数组相当于遍历集合

for(int index = 0; index < objArr.length; index++) {//3. 从Object类型数组中获取到的每一个元素,Object类型//想要转换成集合中数据类型本身, 需要做多态的向下转型

Integer i =(Integer)objArr[index];

System.out.println(i+1);

}

}

}

2.3 Collection中所有带All的方法

1. addAll(Collection c) : 将参数集合c中的所有元素添加到方法调用集合中

2. containsAll(Collection c) : 验证方法调用集合中的元素是否完全包含了参数c集合中的元素,如果完全包含, 返回true; 如果不是完全包含, 返回false

3. removeAll(Collection c) :将参数c集合中的所有元素从方法调用集合中删除掉, boolean类型返回值结果(删除两个集合的交集)

4. retainAll(Collection c) : 将方法调用集合与参数集合c中相同的元素保留下来, 同步到方法调用集合中(保留两个集合的交集)

代码

public classDemo03_Collection中All方法 {public static voidmain(String[] args) {

Collection c= newArrayList();

c.add("a");

c.add("b");

Collection c1= newArrayList();

c1.add("Hello");

c1.add("a");//1. addAll(Collection c) : 将参数集合c中的所有元素添加到方法调用集合中

c.addAll(c1);

System.out.println(c);//[a, b, Hello, a]

System.out.println("--------------");//2. containsAll(): containsAll(Collection c) : 验证方法调用集合中的元素是否完全包含了参数c集合中的元素,如果完全包含, 返回true; 如果不是完全包含, 返回false

boolean boo1 =c.containsAll(c1);

System.out.println(boo1);//true

Collection c2= newArrayList();

c2.add("a1");

c2.add("b");//[a1, b]

System.out.println(c.containsAll(c2));//false

System.out.println(c);//[a, b, Hello, a]

System.out.println(c2);//[a1, b]//3. removeAll(Collection c) :将参数c集合中的所有元素从方法调用集合中删除掉,//boolean类型返回值结果(删除两个集合的交集)

c.removeAll(c2);

System.out.println(c+"----");//[a, Hello, a]//4.retainAll(Collection c) : 将方法调用集合与参数集合c中重叠(相同)的元素保留下来,同步到方法调用集合中(获取两个集合的交集)

Collection cc= newArrayList();

cc.add("ui");

cc.add("world");

Collection cd= newArrayList();

cd.add("ui1");

cd.add("world1");

Collection ce= newArrayList();

ce.add("ui");

ce.add("world____");/*cc.retainAll(cd);

System.out.println(cc);// []*/cc.retainAll(ce);

System.out.println(cc);//[ui]

}

}

2.4 Collection集合第二种迭代器遍历方式

1.迭代 : 表示从一个到下一个的过程, 称为迭代

2.迭代器 : 专门用于将集合中的元素一个一个获取到的对象

3.迭代器对象的获取和使用:

Collection父接口中, 有一个方法 iterator() , 返回值类型Iterator(接口,表示迭代器接口), 因此iterator() 方法实际返回的是Iterator接口的一个实现类对象

Iterator : 迭代器中的方法

1)hasNext() : 判断, 集合中是否还具有下一个元素, 如果有返回true; 如果没有返回false

2)next() : 获取到集合中的下一个元素, 返回值类型Object

3)remove() : 使用迭代器对象将目前正在迭代的元素从集合中删除

代码

public classDemo04_迭代器遍历集合 {public static voidmain(String[] args) {

Collection c= newArrayList();

c.add("a");

c.add("b");

c.add("Hello");//目前对于集合中有集合元素,未知,使用循环一次将元素从集合中获取到//1. 获取一个集合的迭代器对象

Iterator it =c.iterator();//2. 使用迭代器中的nextInt()方法功能判断集合中是否具有下一个元素

while(it.hasNext()) {//3. 集合中有下一个元素,next获取到这个元素

Object obj =it.next();

String s=(String)obj;

System.out.println(s);

}//4. 当集合已经遍历完毕, 但是还要通过next获取集合中的元素//抛出异常 : NoSuchElementException

System.out.println(it.next());

}

}

三、 List集合

3.1 List集合的介绍和特有方法

1.List集合是Collection接口的一个子接口,来自于java.util包

2.List集合的特点:

1) List集合中元素存储有序 : 存入集合的顺序与取出的顺序保持一致

2) List集合中的元素都具有索引位置, 索引范围0---集合长度-1 (size()-1)

3) List集合中存储的元素可以重复

3.List中的特有方法: 都与索引操作有关

1) add(int index, Object obj) : 将参数obj添加到集合指定索引index位置处

2) remove(int index) : 将集合中指定index索引位置的元素删除, 返回值类型Object类型, 将删除的元素值进行返回

3) set(int index, Object obj) : 将集合中指定index索引位置上的元素,使用obj进行替换, 返回值类型Object, 将被替换掉的原值进行返回

4) get(int index) : 将集合中指定index索引位置上的元素获取到, 返回值类型Object

代码

public classDemo01_List特有方法 {public static voidmain(String[] args) {

List list= newArrayList();

list.add("a");

list.add("b");//1. add(int index, Object obj) : 将参数obj添加到集合指定索引index位置处

list.add(0, "第一");

System.out.println(list);//[第一, a, b]//2. remove(int index) : 将集合中指定index索引位置的元素删除, 返回值类型Object类型, 将删除的元素值进行返回

Object obj = list.remove(1);

System.out.println(obj);//a

System.out.println(list);//[第一, b]//3.set(int index, Object obj) : 将集合中指定index索引位置上的元素,使用obj进行替换, 返回值类型Object, 将被替换掉的原值进行返回

Object obj1 = list.set(0, "替换");

System.out.println(obj1);//第一

System.out.println(list);//[替换, b]//4.get(int index) : 将集合中指定index索引位置上的元素获取到, 返回值类型Object

Object obj2 = list.get(0);

System.out.println(obj2);//替换

System.out.println(list.get(1));//b//出现异常 : IndexOutOfBoundsException: Index: 2, Size: 2//System.out.println(list.get(2));

}

}

3.2 List集合第三种遍历方式

本种遍历方式是List集合特有的方法

1.get(int index) : 将集合中指定index索引位置上的元素获取到

2.如果能获取到一个集合的所有索引,那么可以通过get方法获取到集合中的每一个元素(与数组的遍历很相似)

集合的索引范围 : 0---集合长度-1 (size()-1)

代码

public classDemo01_List第三种遍历 {public static voidmain(String[] args) {

List list= newArrayList();

list.add("a");

list.add("b");

list.add("89");//设计循环,获取集合中的每一个索引位置

for(int index = 0; index < list.size(); index++) {//使用get(index)方法即可

System.out.println(list.get(index));

}

}

}

3.3并发修改异常

ConcurrentModificationException 并发修改异常

异常发生原因 :

当使用【迭代器对象】迭代集合同时, 使用【集合对象】向集合中添加或者删除元素, 导致迭代不能保证正确性, 于是报出并发修改异常

3.异常解决方案:

1) 迭代器对象迭代, 也使用迭代器对象修改

2) 使用List集合特有遍历方式 : 索引

4.实际解决方式:

1) 迭代器对象迭代, 也使用迭代器对象修改

在List接口中,有特殊方法:

a :listIterator() : 返回值类型ListIterator(接口), 也是一个迭代器类型,但是在原有的迭代器功能基础上,支持一边迭代集合,一边修改集合中的元素,而避免发生并发修改异常.切记一定要使用迭代器对象修改集合元素

b : ListIterator接口中的方法 :

add(Object obj) : 使用迭代器对象向集合中添加元素obj

2) 使用List集合特有遍历方式 : 索引

因为for循环只是语法结构,不是任何类型 , 因此for循环本身不会发生异常; 并且每次for循环的条件都会实时获取到集合的长度, 也会适当的保证迭代的准确性

需求:定义出一个集合,集合中有三个元素“hello” “world” “ok” ,遍历集合,当元素值匹配”hello”时,向集合中添加元素”add”

代码

public classDemo03_并发修改异常 {/*需求 : 定义出一个集合,集合中有三个元素 “hello” “world” “ok” ,

遍历集合,当元素值匹配”hello”时,向集合中添加元素”add”*/

public static voidmain(String[] args) {

List list= newArrayList();

list.add("hello");

list.add("world");

list.add("ok");/*发生并发修改异常

* Iterator it = list.iterator();

while(it.hasNext()) {

Object obj = it.next();

String s = (String)obj;

if("hello".equals(s)) {

list.add("add");

}

}

System.out.println(list);*/

//并发修改异常第一种避免方案//1. 获取到List集合特有的迭代器对象ListIterator

/*ListIterator it = list.listIterator();

while(it.hasNext()) {

Object obj = it.next();

String s = (String)obj;

if("hello".equals(s)) {

// 2, 让迭代器对象给集合添加元素

// it.add("add");

it.remove();

}

}

System.out.println(list);*/

//并发修改异常第二种避免方案

for(int index = 0; index < list.size(); index++) {

String s=(String)list.get(index);if("hello".equals(s)) {//list.add(0,"add");//[add,add,hello,world,ok] 造成死循环

list.add("add");

}

}

System.out.println(list);//[hello, world, ok, add]

}

}

3.4 List集合的实现类

List接口, 需要实现类 : 根据底层实现不同,有不同的实现类

List的实现类中,使用比较多的有2个

1) ArrayList : 数组实现(ArrayList底层数组结构), 顺序存储

2) LinkedList : 节点实现(可以利用内存中零散空间), 链式存储

3.4.1ArrayList实现类

ArrayList 实现类 : 数组实现(ArrayList底层数组结构), 顺序存储

ArrayList查询快, 增加删除元素,相对比较慢

3.4.2 LinkedList实现类

1. LinkedList : 节点实现(可以利用内存中零散空间), 链式存储

LinkedList查询慢, 增加删除元素,相对比较快

节点实现 : LinkedList中的元素节点存储, 每一个节点分为两个部分, 其中一个部分用于存储集合中的元素, 另外一个部分存储是下一个元素的地址值

2.LinkedList类型中存储起始点内存地址(第一个元素); 还会存储最后一个节点内存地址(最后一个元素)

因此LinkedList中对于第一个元素位置和最后一个元素的位置有特殊方法

1) addFirst()

2) addLast()

3) removeFirst()

4) removeLast()

5) getFirst()

6) getLast()

上述对于头尾操作的方法,性能比较高

代码

public classDemo04_LinkedList {public static voidmain(String[] args) {

LinkedList list= newLinkedList();

list.addFirst("a");

list.addFirst("1");

list.addLast("end");

list.addLast("end1");

System.out.println(list.getFirst());//1

System.out.println(list.getLast());//end1

list.removeFirst();//1

list.removeLast();//end1

System.out.println(list);//[a, end]

}

}

四、泛型

4.1 泛型的概述和使用(掌握)

泛型 : 表示广泛的类型(泛型是引用数据类型), 定义一个类型时, 对于这个类型中的一些方法参数或者返回值类型无法确定, 于是使用一个符号表示,这个符号称为泛型

泛型的使用:

在类型声明后,使用<>,在菱形尖括号中,写入大写字母, 这些大写字母就表示泛型, 当创建出这个类型对象的时候, 需要确定泛型的具体类型

确定泛型E具体类型时候:

a : 类上定义的泛型,可以在整个类中当做一个已知类型进行使用

b : 举例 : ArrayList , 这个E类型在ArrayList类中可以直接使用

public boolean add(E e){} // E与ArrayList上面的广泛类型一致

ArrayList list = new ArrayList<>();

list容器泛型确定为String类型, add方法参数类型就确定为String,调用时add(String s)

1.泛型的好处:

1) 提高代码的安全性, 将在运行环节会发生的问题提前到代码编译环节

2) 提交代码的简洁性, 在集合中使用泛型,可以避免掉集合数据获取的向下转型操作

3) 使用集合一定要使用泛型

2.泛型写作的注意事项:

1) 一致性 : 前后的泛型类型必须一致

2) 泛型推断 : 从JDK1.7版本开始,后面的泛型可以不写, 只写<>, 默认后面的泛型类型与前面的类型保持一致

代码

public classDemo01_泛型的使用和好处 {public static voidmain(String[] args) {//当创建出一个ArrayList集合容器时, 需要确定这个容器中存储的数据类型//集合类型通过泛型的方式进行确定//list集合中只能存储Integer类型数据

ArrayList list = new ArrayList();

list.add(12);

list.add(13);

list.add(14);

list.add(15);for(int index = 0; index < list.size(); index++) {

Integer i=list.get(index);

System.out.println(i+ 1);

}

ArrayList list2 = new ArrayList<>();

list2.add("abc");/*ArrayList list1 = new ArrayList();

list1.add("a");

list1.add(12);

list1.add(3.14);

for(int index = 0; index < list1.size(); index++) {

Object obj = list1.get(index);

String s = (String)obj;

System.out.println(s);

}*/}

}