API-集合框架(2)-List

迭代器的原理及代码实现

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);

    }
}
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值