iterator方法
迭代器的作用：就是用于抓取集合中的元素
注：迭代器返回的一个接口类型的实现类，是一种多态的用法，而不是接口在调用方法
public class Demo2 { public static void main(String[] args) { // TODO Auto-generated method stub Money m=test(); m.makeMoney(); } public static Money test(){ return new Worker(); }}interface Money{ public void makeMoney();}class Worker implements Money{ @Override public void makeMoney() { // TODO Auto-generated method stub System.out.println("工人在赚钱..."); }}结果：工人在赚钱... 这里就用了多态，返回了一个Money的实现类
hasNext() 问是否有元素可以遍历，若可以，则返回true
如果仍有元素可以迭代，则返回 true。 next() 获取元素 返回迭代的下一个元素。 remove() 从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）import java.util.ArrayList;public class Demo1 { public static void main(String[] args) { // TODO Auto-generated method stub Collection c=new ArrayList(); c.add("狗娃"); c.add("狗剩"); c.add("铁蛋"); c.add("美美"); //遍历集合的元素：--------->方式一：可以使用toArray方法 /*Object[] arr=c.toArray();//把集合的元素存储到一个Object的数组中返回 System.out.println("集合的元素为:"+Arrays.toString(arr)); */ //要求使用iterator迭代器遍历 Iterator it=c.iterator();//返回一个迭代器 System.out.println("有元素可以遍历吗？"+it.hasNext()); while (it.hasNext()) { System.out.println("元素:"+it.next());//获取元素 } it.remove(); System.out.println("集合的元素:"+c); } }结果：有元素可以遍历吗？true元素:狗娃元素:狗剩元素:铁蛋元素:美美集合的元素:[狗娃, 狗剩, 铁蛋]
作业2：使用集合实现注册登陆功能，
第一步： 提示用户选择功能， A（注册） B(登陆) 。 要求： 功能选择 的时候要忽略大小写。
注册： 1. 提示用户输入注册的账号(数字)与密码，如果输入的id号已经存在集合中，提示用户重新输入。 注册完毕之后，把集合中的所有用户信息打印出来。(使用：toArrry()方法)登陆：
提示用户输入登陆的账号与密码,如果账号与密码这个用户已经存在集合中，那么登陆成功，否则登陆失败。import java.util.ArrayList;public class Demo3 { static Scanner sc=new Scanner(System.in); static Collection users=new ArrayList();//使用该集合保存所有的用户信息 public static void main(String[] args) { // TODO Auto-generated method stub while (true) { System.out.println("请选择功能： A（注册） B（登陆） "); String option=sc.next(); if ("a".equalsIgnoreCase(option)) { reg(); } else if ("b".equalsIgnoreCase(option)) { login(); } else { System.out.println("你的选择有误，请重新输入！"); } } } public static void login() { System.out.println("你选择了登录功能..."); System.out.println("请输入账号:"); int id=sc.nextInt(); System.out.println("请输入密码:"); String password=sc.next(); //判断集合的用户是否存在该用户名与密码 //遍历集合的元素,查看是否存在该用户信息 boolean isLogin=false;//定义一个变量用于记录是否登录成功的信息,默认是没有登录成功的 Iterator it=users.iterator(); while (it.hasNext()) { User user=(User)it.next(); if (user.getId()==id&&user.getPassword().equals(password)) { //存在该用户信息,登录成功 isLogin=true; } } if (isLogin) { System.out.println("欢迎登录..."); } else { System.out.println("用户名或者密码错误，登录失败..."); } } public static void reg() { User user =null; while (true) { System.out.println("请输入账号"); int id=sc.nextInt(); user =new User(id,null); //System.out.println(id); if (users.contains(user)) { //如果存在 System.out.println("该账号已经存在，请重新输入账号"); } else { //如果不存在 break; } } //System.out.println(user.getId()); System.out.println("请输入密码:"); String password=sc.next(); user.setPassword(password); //把user对象保存到集合中 users.add(user); System.out.println("注册成功！"); System.out.println("当前注册的人员:"+users); }}class User{ private int id; private String password; public int getId() { return id; } public void setId(int id) { this.id = id; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public User() {} public User(int id,String password) { this.id=id; this.password=password; } @Override public boolean equals(Object obj) { // TODO Auto-generated method stub User user=(User)obj; return this.id==user.id; } @Override public String toString() { // TODO Auto-generated method stub return "{账号:"+this.id+" 密码:"+this.password; }}结果：请选择功能： A（注册） B（登陆） a请输入账号110请输入密码:gouwa注册成功！当前注册的人员:[{账号:110 密码:gouwa]请选择功能： A（注册） B（登陆） b你选择了登录功能...请输入账号:110请输入密码:gouwa欢迎登录...请选择功能： A（注册） B（登陆） c你的选择有误，请重新输入！请选择功能： A（注册） B（登陆） b你选择了登录功能...请输入账号:110请输入密码:gou用户名或者密码错误，登录失败...请选择功能： A（注册） B（登陆）
List接口：有序，可重复
有序：集合的有序不是指自然顺序，而是指添加进去的顺序与元素出来的顺序是一致的。
ctrl+shift+/ 添加多行注释
ctrl+shift+\ 取消多行注释
添加：
add(int index, E element) 把元素添加到集合的指定索引值位置上
addAll(Collection<? extends E> c) 把参数集合的元素添加到调用者集合指定索引值的位置上public class Demo2 { public static void main(String[] args) { // TODO Auto-generated method stub List list=new ArrayList(); list.add("狗娃"); list.add("狗剩"); list.add("铁蛋"); /*list.add(1, "本山");*/ List list2=new ArrayList(); list2.add("本山"); list2.add("沈阳"); list.addAll(2, list2); System.out.println("集合的元素:"+list); }}结果：集合的元素:[狗娃, 狗剩, 本山, 沈阳, 铁蛋] 获取：
get(int index) 根据索引值获取集合中的元素
indexOf(Object o) 找出指定元素第一次出现在集合中的索引值 lastIndexOf(Object o) 找指定的元素最后一次出现在集合中的索引值 subList(int fromIndex, int toIndex) 指定开始与结束的索引值截取集合中的元素public class Demo2 { public static void main(String[] args) { // TODO Auto-generated method stub List list=new ArrayList(); list.add("狗娃"); list.add("狗剩"); list.add("铁蛋"); list.add("狗娃"); /*list.add(1, "本山"); List list2=new ArrayList(); list2.add("本山"); list2.add("沈阳"); list.addAll(2, list2);*/ System.out.println("找出指定元素在集合中的索引值:"+list.indexOf("狗剩")); System.out.println("找到本山:"+list.indexOf("本山")); System.out.println("最后一次:"+list.lastIndexOf("狗娃")); System.out.println("get方法获取元素:"+list.get(1)); List subList=list.subList(1, 4); System.out.println("子集合的元素是:"+subList); System.out.println("集合的元素:"+list); }}结果：找出指定元素在集合中的索引值:1找到本山:-1最后一次:3get方法获取元素:狗剩子集合的元素是:[狗剩, 铁蛋, 狗娃]集合的元素:[狗娃, 狗剩, 铁蛋, 狗娃] 修改：
set(int index, E element) 使用指定的元素替换指定索引值位置的元素
public class Demo2 { public static void main(String[] args) { // TODO Auto-generated method stub List list=new ArrayList(); list.add("狗娃"); list.add("狗剩"); list.add("铁蛋"); list.add("狗娃"); list.set(3, "本山"); System.out.println("集合的元素:"+list); }}结果：集合的元素:[狗娃, 狗剩, 铁蛋, 本山] List接口中特有的方法具备的特点：操作的方法都存在索引值
只有List接口下面的集合类才具备索引值，其他接口下面的集合类都没有索引值
迭代：
listIterator() 返回List接口中特有的迭代器
hasPrevious() 判断是否存在上一个元素
previous() 获取上一个元素 当前指针先向上移动一个单位，然后再取出当前指针指向的元素next（） 先取出当前指针指向的元素，然后指针向下移动一个单位
————————————————————add(E e) 把当前元素插入到当前指针指向的位置上
set(E e) 替换迭代器最后一次返回的元素public class Demo3 { public static void main(String[] args) { // TODO Auto-generated method stub List list=new ArrayList(); list.add("狗娃"); list.add("狗剩"); list.add("铁蛋"); list.add("美美"); ListIterator it=list.listIterator(); /*System.out.println("有上一个元素吗？"+it.hasPrevious()); it.next(); System.out.println("获取上一个元素:"+it.previous()); it.next(); it.next(); it.add("张三");*/ it.next(); it.next(); it.set("张三"); System.out.println("集合的元素:"+list); }}结果：集合的元素:[狗娃, 张三, 铁蛋, 美美] 使用三种遍历方式遍历集合中的元素：
import java.util.ArrayList;import java.util.List;import java.util.ListIterator;public class Demo4 { public static void main(String[] args) { // TODO Auto-generated method stub List list=new ArrayList(); list.add("张三"); list.add("李四"); list.add("王五"); System.out.println("---------get方法遍历----------"); for (int i=0;i 迭代器在迭代元素的时候的时候要注意的事项：
在迭代器迭代元素的过程中，不允许使用集合对象改变集合中的元素个数，如果需要添加或者删除只能使用迭代器的方法进行操作。
如果使用过了集合对象改变集合中的元素个数，那么就会出现ConcurrentModificationException异常。
迭代器迭代元素的过程中：迭代器一旦创建到使用的时间。
List：有序，可重复
常用的：
----------------| ArrayList ArrayList底层是维护了一个Object数组实现的，特点：查询速度快，增删慢。
----------------| LinkedList
----------------| Vector（了解即可）
ArrayList特有的方法:
ensureCapacity(int minCapacity) 指定容量trimToSize() 把数组中无用的删除 比如初始容量为10 只用了3个 那么就把剩下的7个删除
笔试题目：使用ArrayList无参的构造函数创建一个对象时，默认的容量是多少？如果长度不够使用时又自动增长多少？
ArrayList底层是维护了一个Object数组实现的，使用无参构造函数时，Object数组默认的容量是10，当长度不够时，自动增长0.5倍
private int newCapacity(int minCapacity) { // overflow-conscious code int oldCapacity = elementData.length; int newCapacity = oldCapacity + (oldCapacity >> 1);//左移一位就是除以2，所以就是+0.5 if (newCapacity - minCapacity <= 0) { if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) return Math.max(DEFAULT_CAPACITY, minCapacity); if (minCapacity < 0) // overflow throw new OutOfMemoryError(); return minCapacity; } return (newCapacity - MAX_ARRAY_SIZE <= 0) ? newCapacity : hugeCapacity(minCapacity); } 查询速度快：因为维护的数组元素与元素之间的内存地址是连续的，所以就像一个线性表，只需要知道首元素地址，就可以很方便的找到后面的元素了
增加：创建一个新的数组 将原数组复制进去
删除：删除待删除元素 然后把后面的全部向前移动一位
什么时候使用ArrayList：如果目前的数据是查询比较多 增删比较少的时候，就用ArrayList存储这批数据 比如：高校的图书馆
需求：编写一个函数清除集合中的重复元素 如果书号一样就是重复的元素。要求：遍历集合元素时必须使用迭代器
package cn.itcast.list;import java.util.ArrayList;import java.util.Iterator;import java.util.ListIterator;//需求：编写一个函数清除集合中的重复元素 如果书号一样就是重复的元素。要求：遍历集合元素时必须使用迭代器public class Demo7 { public static void main(String[] args) { // TODO Auto-generated method stub ArrayList list=new ArrayList(); list.add(new Book(110,"Java编程思想")); list.add(new Book(220,"Java核心技术")); list.add(new Book(330,"深入JavaWeb")); list.add(new Book(110,"Java神书")); ArrayList list2=clearRepeat(list); System.out.println("新集合的元素是:"+list2); } public static ArrayList clearRepeat(ArrayList list) { ArrayList newList =new ArrayList();//创建一个新的集合 //获取迭代器 Iterator it=list.iterator(); while (it.hasNext()) { Book book=(Book)it.next();//从旧集合中获取的元素 if (!newList.contains(book)) { //如果新集合没有包含该书籍，那么就存储到新集合中 newList.add(book); } } return newList; }}class Book{ int id; String name; public Book(int id, String name) { super(); this.id = id; this.name = name; } @Override public String toString() { // TODO Auto-generated method stub return "{书号:"+this.id+" 书名:"+this.name+" }"; } @Override public boolean equals(Object obj) { // TODO Auto-generated method stub Book book=(Book)obj; return this.id==book.id; }}结果：新集合的元素是:[{书号:110 书名:Java编程思想 }, {书号:220 书名:Java核心技术 }, {书号:330 书名:深入JavaWeb }]
LinkedList：LinkedList底层是使用了链表数据结构实现的 特点：查询速度慢，增删快
LinkedList特有的方法：
LinkedList特有的方法:
1：方法介绍 addFirst(E e) 把元素加到集合的首位置上 addLast(E e) 把元素添加到集合的末尾处 getFirst() 获取集合中首位置的元素 getLast() 获取集合中末尾处的元素 removeFirst() 删除集合中的首位置元素并返回 removeLast() 删除集合中的末尾元素并返回如果集合中没有元素，获取或者删除元素抛：NoSuchElementException2：数据结构 1：栈 （1.6）：主要用于实现堆栈数据结构的存储方式 先进后出 push() pop() 2：队列（双端队列1.5）：主要是为了让我们可以使用LinkedList模拟队列数据结构的存储方式 先进先出 offer() poll()3：返回逆序的迭代器对象 descendingIterator() 返回逆序的迭代器对象
import java.util.LinkedList;public class Demo8 { public static void main(String[] args) { // TODO Auto-generated method stub LinkedList list=new LinkedList(); list.add("张三"); list.add("李四"); list.add("王五"); list.addFirst("狗娃"); list.addLast("狗剩"); System.out.println("获取集合中首位置的元素:"+list.getFirst()); System.out.println("获取集合中末尾的元素:"+list.getLast()); System.out.println("删除集合中的首位置元素并返回:"+list.removeFirst()); System.out.println("删除集合中的末尾元素并返回:"+list.removeLast()); System.out.println("集合中的元素:"+list); }}结果：获取集合中首位置的元素:狗娃获取集合中末尾的元素:狗剩删除集合中的首位置元素并返回:狗娃删除集合中的末尾元素并返回:狗剩集合中的元素:[张三, 李四, 王五] 需求：使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式
package cn.itcast.list;import java.util.LinkedList;/* 1：栈 （1.6）:主要用于实现堆栈数据结构的存储方式 先进后出 push() pop() 2：队列（双端队列1.5）：主要是为了让我们可以使用LinkedList模拟队列数据结构的存储方式 先进先出 offer() poll()需求：使用LinkedList实现堆栈数据结构的存储方式与队列的数据结构存储方式*/public class Demo9 { public static void main(String[] args) { // TODO Auto-generated method stub StackList list=new StackList(); list.add("马云"); list.add("校长"); list.add("思聪"); //System.out.println(list.pop()); int size=list.size(); for (int i=0;i