32.List

最新推荐文章于 2023-10-22 08:15:00 发布

weixin_30802171

最新推荐文章于 2023-10-22 08:15:00 发布

阅读量77

点赞数

CC 4.0 BY-SA版权

文章标签： java 数据结构与算法

原文链接：http://www.cnblogs.com/syj1993/p/8326196.html

集合和数组都是存储对象的。
数组长度固定，可以存储基本数据类型
集合长度可变，只能存储对象

1.add方法的参数类型是Object,以便于接收任意类型对象。
2.集合中存储的都是对象的引用(地址)

什么是迭代器呢？
其实就是集合的取出元素的方式。

public class Collection_01 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        //method_2();
        
        //method_get();
        
        base_method();

    }
    
    public static void method_2(){
        ArrayList al1=new ArrayList();
        
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        
        ArrayList al2=new ArrayList();
        
        al2.add("java01");
        al2.add("java02");
        al2.add("java05");
        al2.add("java06");
        
        //al1.retainAll(al2);//取交集，al1中只会保留和al2中相同的元素
        
        //al1.removeAll(al2);//去除al1中和al2相同的元素
        
        al1.addAll(al2);//al1中包含两个集合所有元素
        sop("al1:"+al1);
        sop("al2:"+al2);
    }
    
    public static void method_get(){
        ArrayList al1=new ArrayList();
        
        al1.add("java01");
        al1.add("java02");
        al1.add("java03");
        al1.add("java04");
        
        Iterator it=al1.iterator();//获取迭代器，用于取出集合中的元素
        while(it.hasNext()){
            sop(it.next());
        }
        
        /*for(Iterator it=al1.iterator();it.hasNext();){//循环完毕it不存在了，比while节约内存
            sop(it.next());
        }*/        
    }
    
    public static void base_method(){
        //创建一个集合容器。使用Collection接口的子类。ArrayList
        ArrayList al=new ArrayList();
        
        //1.添加元素
        al.add("java01");//add(Object obj)
        al.add("java02");
        al.add("java03");
        al.add("java04");
        
        //打印集合
        sop(al);
        
        //2.获取个数，集合长度
        sop("al.size="+al.size());
        
        //3.删除元素
        al.remove("java02");
        //删除后的集合
        sop(al);
        //删除后的长度
        sop("al.size="+al.size());
        
        //清空集合
        //al.clear();
        
        //4.判断元素
        sop("java03是否存在"+al.contains("java03"));
        sop("集合是否为空"+al.isEmpty());
    }
    
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

Collection
　　--List:元素是有序的，元素可以重复，因为该集合体系有索引
　　　　--ArrayList:底层的数据结构使用的数组结构。特点：查询速度很快，但是增删稍慢(角标变化)。线程不同步
　　　　--LinkedList：底层使用的是链表数据结构。特点：增删速度很快，查询很慢。
　　　　--Vector：底层是数组数据结构。线程同步(被ArrayList替代了)
　　--Set:元素是无序的，元素不可以重复

List:
特有方法：凡是可以操作角标的方法都是该体系特有的方法。
　　增：
　　　　add(index,element);
　　　　addAll(index,Collection);
　　删：
　　　　remove(index);
　　改：
　　　　set(index,element);
　　查：
　　　　get(index);
　　　　subList(from,to);
　　　　listIterator();

List集合特有的迭代器 ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素，因为会发生ConcurrentModificationException并发修改异常。
所以在迭代时，只能用迭代器的方法操作元素，可是Iterator的方法是有限的，只能对元素进行判断hasNext()、取出next()、删除remove()的操作。
如果想要其他的操作，如添加、修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

public class List_02 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        
        //method();
        
        method_listIterator();

    }
    
    //List特有方法
    public static void method(){
        ArrayList al=new ArrayList();
        
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");    
        sop("原集合是："+al);
        
        //在指定位置添加元素
        al.add(1,"java04");
        sop("添加一个元素后的集合是："+al);
        
        //删除指定位置的元素
        al.remove(2);
        sop("删除一个元素后的集合是："+al);
        
        //修改元素
        al.set(2,"java07");
        sop("修改一个元素后的集合是："+al);
        
        //通过角标获取元素
        sop("获取的元素是："+al.get(1));
        
        //获取所有元素
        for(int x=0;x<al.size();x++){
            sop("al("+x+")="+al.get(x));
        }
        
        //迭代器获取所有元素
        for(Iterator it=al.iterator();it.hasNext();){
            sop("next:"+it.next());
        }
        
        //通过indexOf获取对象的位置
        sop(al.indexOf("java04"));
        
        //子列表
        List sub=al.subList(1, 3);
        sop(sub);
    }
    
    //listIterator(列表迭代器)
    public static void method_listIterator(){
        ArrayList al=new ArrayList();
        
        //添加元素
        al.add("java01");
        al.add("java02");
        al.add("java03");    
        
        sop(al);
        
        /*
        //在迭代过程中，准备添加或删除元素
        Iterator it=al.iterator();
        //Itetator只有hasNext() next() remove()三个方法
        
        while(it.hasNext()){
            Object obj=it.next(); 
            if(obj.equals("java02")){
                //al.add("java08");//同一组元素，既用集合操作，又用迭代器操作，并发修改异常ConcurrentModificationException
                it.remove();//将java02从集合中删除
            }
            sop("obj:="+obj);//引用在集合中移除了，元素在内存当中
        }
        */
        
        ListIterator li=al.listIterator();
        while(li.hasNext()){
            Object obj=li.next();
            if(obj.equals("java02")){
                //添加
                //li.add("java09");
                
                //修改
                li.set("java06");
            }
        }
        
        //逆向遍历
        while(li.hasPrevious()){
            sop("previous:"+li.previous());
        }
        
        sop(al);
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

Enumeration 枚举是Vector特有的取出方式
发现枚举和迭代器很像。
其实枚举和迭代是一样的。枚举的名称以及方法都过长，所以被迭代器取代了。

public class Vector_03 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Vector v=new Vector();
        
        v.add("java01");
        v.add("java02");
        v.add("java03");
        v.add("java04");
        
        Enumeration en=v.elements();
        
        while(en.hasMoreElements()){
            System.out.println(en.nextElement());
        }
    }

}

LinkedList特有方法：
　　addFirst();
　　addLast();

　　getFirst(); 获取元素，但不删除元素
　　getLast();

　　removeFirst(); 获取元素，并删除元素。如果集合中没有元素，会出现NoSuchElementException
　　removeLast();

　　JDK1.6出现了替代方法。
　　offerFirst();
　　offerLast();

　　peekFirst();
　　peekLast();

　　pollFirst();
　　pollLast();

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        LinkedList link=new LinkedList();
        
        link.addFirst("java01");
        link.addFirst("java02");
        link.addFirst("java03");
        link.addFirst("java04");
        
        sop(link);
        
        //sop(link.getFirst());
        
        //link.removeLast();
        //sop(link);
        
        while(!link.isEmpty()){
            sop(link.removeFirst());
        }
        
        link.removeLast(); //NoSuchElementException
        
    }
    
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

练习：使用LinkedList模拟堆栈或者队列数据结构
堆栈：先进后出如同一个杯子
队列：先进先出如同一个水管，先进管子先出来

public class LinkedList_05 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        DuiLie dl=new DuiLie();
        
        dl.myAdd("java01");
        dl.myAdd("java02");
        dl.myAdd("java03");
        dl.myAdd("java04");
        
        sop(dl.myGet());
        sop(dl.myGet());
        sop(dl.myGet());
        sop(dl.myGet());
        
        sop(dl.isNull());
        
        sop("-------------------");
        
        DuiZhan dz=new DuiZhan();
        
        dz.myAdd("java01");
        dz.myAdd("java02");
        dz.myAdd("java03");
        dz.myAdd("java04");
        
        sop(dz.myGet());
        sop(dz.myGet());
        sop(dz.myGet());
        sop(dz.myGet());
    }
    
    
    
    public static void sop(Object obj){
        System.out.println(obj);
    }

}

class DuiLie{
    private LinkedList link;
    
    DuiLie(){
        link=new LinkedList();
    }
    
    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    
    public Object myGet(){
        return link.removeLast();
    }
    
    public boolean isNull(){
        return link.isEmpty();
    }
}

class DuiZhan{
    private LinkedList link;
    
    DuiZhan(){
        link=new LinkedList();
    }
    
    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    
    public Object myGet(){
        return link.removeFirst();
    }
}

去除ArrayList中重复元素

public class ArrayList_06 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList al=new ArrayList();
        
        al.add("java01");
        al.add("java02");
        al.add("java03");    
        al.add("java01");
        al.add("java04");
        al.add("java05");
        al.add("java03");
        al.add("java04");
        al.add("java06");    
        
        System.out.println(al);
        
        
        System.out.println(singleElement(al));
    }

    public static ArrayList singleElement(ArrayList al){
        
        //定义一个临时容器
        ArrayList newAl=new ArrayList();
        
        Iterator it=al.iterator();
        while(it.hasNext()){
            Object obj=it.next();
            
            if(!newAl.contains(obj)){
                newAl.add(obj);
            }
        }
        return newAl;
    }
        
}

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象，同姓名同年龄，视为同一人,为重复元素

思路：
　　1.对人描述，将数据封装进入人对象
　　2.定义容器，将人存入
　　3.取出

List集合判断元素是否相同，依据的是元素的equals方法。调一次contains，运行一次equals。remove调用的仍然是equals

public class ArrayList_07 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList al=new ArrayList();
        
        al.add(new Person("lisi01",22)); //al.add(Object obj);==> Object obj=new Person("lisi",33);
        al.add(new Person("lisi02",23));
        al.add(new Person("lisi03",24));
        al.add(new Person("lisi04",25));
        al.add(new Person("lisi02",22));
        al.add(new Person("lisi04",25));
        
        al=singlePerson(al); //比较对象，用的是Object的equals方法，比较的地址值，而每个对象地址都不一样，所以全获取
        
        //打印所有
        Iterator it=al.iterator();
        while(it.hasNext()){
            Person p=(Person) it.next();
            sop("姓名是："+p.getName()+",年龄为："+p.getAge());
        }
    }
    
    public static ArrayList singlePerson(ArrayList al){
        ArrayList newAl=new ArrayList();
        
        Iterator it=al.iterator();
        while(it.hasNext()){
            Object obj=it.next();
            
            if(!newAl.contains(obj)){
                newAl.add(obj);
            }    
        }
        return newAl;
    }
    
    
    public static void sop(Object obj){
        System.out.println(obj);
    }

}
class Person{
    private String name;
    private int age;
    
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
    
    public String getName(){
        return name;
    }
    
    public int getAge(){
        return age;
    }
    
    public boolean equals(Object obj){ //该方法自动被调用
        
        if(!(obj instanceof Person)){
            return false;
        }
        Person p=(Person) obj;
        System.out.println(this.name+"..."+p.name);
        
        return this.name.equals(p.name) && this.age == p.age;
    }
    /* 每个进来的对象都与之前的元素比较一遍
    lisi02...lisi01
    lisi03...lisi01
    lisi03...lisi02
    lisi04...lisi01
    lisi04...lisi02
    lisi04...lisi03
    lisi02...lisi01
    lisi02...lisi02
    lisi04...lisi01
    lisi04...lisi02
    lisi04...lisi03
    lisi04...lisi04
     */
}