迭代器的原理及代码实现
package iterator;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
public static void main(String[] args) {
/*
*集合的取出方式
*取元素,无论是什么数据结构,最终共性的取出方式
*一个一个取,取之前先判断,有,取一个,没有,结束
*这种取出的共性方法:迭代
*/
//1,创建Collection对象
Collection coll =new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
//2,获取容器的迭代器对象,通过iterator方法
// Iterator it = coll.iterator();
//3,使用具体的迭代器对象获取集合中的元素
// while(it.hasNext()){
// System.out.println(it.next());
// }
//开发用这种写法
for (Iterator it = coll.iterator(); it.hasNext();) {
System.out.println(it.next());
}
}
}
Collection使用的细节:
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class CollectionDemo2 {
public static void main(String[] args) {
Collection coll = new ArrayList();
/*
* 细节:
* 1,集合中存储的其实是对象的地址。
* 2,集合中可以存储基本数值吗?不行
* 但是JDK1.5以后可以这么写,但是存储的还是对象(基本数据类型包装器对象)
* 3,存储时提升了Object,取出时要使用元素的特有内容,必须向下转型。
*/
//coll存储对象
// coll.add("abc1");//存储的是对象的引用。
// coll.add(3);//coll.add(Integer.valueOf(3));//自动装箱。
coll.add("itcast1");
coll.add("haha");
coll.add("nba");
for (Iterator it = coll.iterator(); it.hasNext();) {
// System.out.println(it.next());
Object obj =it.next();//取得的都是Object类型,需要使用元素特有方法时
String str =(String)obj;//需要向下转型
System.out.println(str.length());
}
}
}
Collection
|--List: 有序的,带索引的,通过索引就可以精确得操作集合中的元素,元素是可以重复的。
List提供了增删改查动作
增加add(element) add(index,element);
删除remove(element) remove(index)
修改set(index,element)
查询get(index)
|--Vector:可以增长的数组结构,同步的,效率很低,已被Array1List替代。
|--ArrayList:是数组结构,长度是可变的(原理是创建新数组+复制数组),查询速度很快,增删较慢,是不同步的。
|--LinkedList:是链表结构,是不同步的,增删的速度很快,查询速度较慢。
可用于实现堆栈,队列。
List可以存储重复元素的,如果需求中要求容器中的元素必须保证唯一性
学生类的快速编写
使用alt+shift+s快速构造出构造器,get&set方法,重写父类的方法
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
/*
* 建立学生对象判断相同的依据,覆盖equals方法,
* 只要同姓名同年龄就是同一个人,视为重复元素。
*/
public String getName() {
return name;
}
@Override
public boolean equals(Object obj) {
if(this == obj)
return true;
if(!(obj instanceof Student)){
throw new ClassCastException("类型错误");
}
Student stu =(Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
}
集合中重复的概念
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import domin.Student;
public class CollectionTset {
public static void main(String[] args) {
/*
* 往集合中存储自定义的对象。
*/
//1,创建集合对象
Collection coll =new ArrayList();
//2,添加具体的学生对象。
Student stu =new Student("lisi1",21);
coll.add(stu);
coll.add(stu);
coll.add(new Student("lisi2",12));
coll.add(new Student("lisi3",56));
/*
* 什么是重复?都是有判断依据的。
* 依据都是通过方法来完成的。
*/
for (Iterator it = coll.iterator(); it.hasNext();) {
Student student=(Student)it.next();
System.out.println(student.toString());
}
}
}
List接口
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import domin.Student;
public class ListDmeo {
public static void main(String[] args) {
/*
* 使用List,解决插入元素问题,因为add方法是追加。
* list获取元素的方式有两种:一种是迭代,一种是遍历+get
* list接口是支持对元素进行curd增删改查动作的
*/
List list=new ArrayList();
//1,添加元素
list.add(new Student("wangwu1",21));
list.add(new Student("wangwu2",22));
list.add(new Student("wangwu3",23));
//2,插入元素
// list.add(1,new Student("lisi",56));
//3,删除元素
// list.remove(2);
//4,修改元素
list.set(1, new Student("zhangsan",48));
// Object obj = list.get(1);
// System.out.println(obj);
for (int i = 0; i < list.size(); i++) {
System.out.println("get("+i+")"+list.get(i));
}
/* for (Iterator it = list.iterator(); it.hasNext();) {
Student stu = (Student) it.next();
System.out.println(stu);
}*/
}
}
ListIterator
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListIteratorDemo {
public static void main(String[] args) {
List list=new ArrayList();
list.add("abc1");
list.add("abc2");
list.add("abc3");
list.add("abc4");
/*
* 获取集合中的元素
* 如果集合中有元素等于abc2,那么就插入一个新的元素,java.
* 引发了 java.util.ConcurrentModificationException
* 在迭代过程中,使用了集合的方法对元素进行操作,导致迭代器并不知道集合中的变化
* 容易引发数据的不确定性。
*
* 解决:在迭代时,不要使用集合的方法操作元素。
* 那么想要在迭代是对元素操作可以使用迭代器的方法操作。
* 可是迭代器的方法只有hasNext(),next(),remove();
* Iterator中有一个子接口可以解决该问题,如何获取该子接口对象呢?
* 通过List接口中的listIterator()就可以获取,
* 记住:该列表迭代器只有List接口有,而且这个迭代器可以完成在迭代过程中的曾删改查动作
*/
// Iterator it=list.iterator();
// 获取列表迭代器
ListIterator it =list.listIterator();
while(it.hasNext()){
Object obj =it.next();
if("abc2".equals(obj)){
// list.add("java");
it.set("java");
}
}
System.out.println(list);
}
}
LinkedList的特有方法:
import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
/*
* 特点:对头和尾进行操作
*
* addFirst();
* addLast();
*
* getFirst();获取头部元素
* getLast();
*
* removeFirst();获取头部元素,并删除头部元素
* removeLast();
*/
LinkedList link =new LinkedList();
link.addFirst("abc1");
link.addFirst("abc2");
link.addFirst("abc3");
while(!link.isEmpty()){
System.out.println(link.removeFirst());
}
}
}
LinkedList模拟队列结构:
import java.util.LinkedList;
public class LinkedListTest {
public static void main(String[] args) {
/*
* 面试题:用Linkedlist模拟一个堆栈或者队列数据结构。
* 创建一个堆栈或者队列数据结构对象,该对象中使用LinkedList来完成。
*/
//创建一个队列对象
Queue queue =new Queue();
//往队列中添加元素。
queue.myAdd("abc1");
queue.myAdd("abc2");
queue.myAdd("abc3");
queue.myAdd("abc4");
while(!queue.isNull()){
System.out.println(queue.myGet());
}
}
}
/**
*定义一个队列数据结构。Queue
*
*/
class Queue{
//封装了一个链表数据结构。
private LinkedList link;
/*
* 队列初始化时。对链表对象初始化
*/
Queue(){
link =new LinkedList();
}
/**
* 队列的添加元素功能
*/
public void myAdd(Object obj){
//内部使用的就是链表的方法。
link.addFirst(obj);
}
/**
* 队列的获取方法
*/
public Object myGet(){
return link.removeLast();
}
/**
* 判断队列中元素是否空,没有元素就为true。
*/
public boolean isNull() {
return link.isEmpty();
}
}
去除List中重复的元素
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import domin.Student;
public class ArrayListTest {
public static void main(String[] args) {
List list=new ArrayList();
/* list.add("abc1");
list.add("abc2");
list.add("abc1");
list.add("abc2");
list.add("abc3");*/
list.add(new Student("lisi2",13));
list.add(new Student("lisi1",22));
list.add(new Student("lisi2",13));
list.add(new Student("lisi1",22));
list.add(new Student("lisi1",22));
getSingleElement(list);//取出重复元素
System.out.println(list);
}
public static void getSingleElement(List list){
/*
* 案例:去除List集合中的重复元素。
*
* 思路:
* 1,先创建一个临时容器,用于存储唯一性的元素。
* 2,遍历原容器,将遍历到的元素到临时容器中判断,是否存在
* 3,如果存在,不存储到临时容器中,如果不存在,存储到临时容器中
* 4,遍历结束后,临时容器中存储的就是唯一性的元素。
* 5,如果需要将这些唯一性元素保留到原容器中,只要将原容器清空,将临时容器的元素添加到原容器即可。
*/
//1,创建一个临时容器
List temp=new ArrayList();
//2,遍历原容器
for (Iterator it = list.iterator(); it.hasNext();) {
Object obj = it.next();
//对遍历到的每一元素都要到临时容器中进行判断是不是包含
if(!temp.contains(obj)){//如果不存在
temp.add(obj);//添加到临时容器。
}
}
//唯一性元素已将被记录到临时容器中。
//清空原容器中的元素
list.clear();
//把临时容器中元素添加到原容器中
list.addAll(temp);
}
}