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 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) {
            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) {
            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) {
            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();
        }
}

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

 

转载于:https://www.cnblogs.com/zhangwugai/p/10452825.html

你可能感兴趣的:(Java学习笔记(15))