Java学习笔记（15）

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
最后一次:3
get方法获取元素:狗剩
子集合的元素是:[狗剩, 铁蛋, 狗娃]
集合的元素:[狗娃, 狗剩, 铁蛋, 狗娃]

修改：

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<list.size();i++) {
            System.out.print(list.get(i)+",");
        }

        System.out.println("\r\n---------使用迭代器正序遍历---------");
        ListIterator it=list.listIterator();//获取到迭代器
        while (it.hasNext()) {
            System.out.print(it.next()+",");
        }

        System.out.println("\r\n---------使用迭代器逆序遍历---------");
        while (it.hasPrevious()) {
            System.out.print(it.previous()+",");
        }
    }

}

结果：
---------get方法遍历----------
张三,李四,王五,
---------使用迭代器正序遍历---------
张三,李四,王五,
---------使用迭代器逆序遍历---------
王五,李四,张三,

迭代器在迭代元素的时候的时候要注意的事项：

在迭代器迭代元素的过程中，不允许使用集合对象改变集合中的元素个数，如果需要添加或者删除只能使用迭代器的方法进行操作。

如果使用过了集合对象改变集合中的元素个数，那么就会出现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() 删除集合中的末尾元素并返回
如果集合中没有元素，获取或者删除元素抛：NoSuchElementException
2：数据结构
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<size;i++) {
            System.out.println(list.pop());
        }
        System.out.println("----------------------");
        TeamList list2=new TeamList();
        list2.add("马云");
        list2.add("校长");
        list2.add("思聪");
        //System.out.println(list.pop());
        int size2=list2.size();
        for (int i=0;i<size2;i++) {
            System.out.println(list2.remove());
        }
    }

}
//使用LinkedList模拟堆栈的数据结构存储方式
class StackList{
    LinkedList list;
    public StackList() {
        list=new LinkedList();
    }
    //进栈
    public void add(Object o) {
        list.push(o);
    }
    //出栈
    public Object pop() {
        return list.pop();
    }
    //获取元素个数
    public int size() {
        return list.size();
    }
}
//使用LinkedList模拟队列的存储方式
class TeamList{
    LinkedList list;
    public TeamList() {
        list=new LinkedList();
    }
    public void add(Object o) {
        list.offer(o);
    }
    public Object remove() {
        return list.poll();
    }
    //获取元素个数
        public int size() {
            return list.size();
        }
}

结果：
思聪
校长
马云
----------------------
马云
校长
思聪