集合框架-List

List：

    1.是有序的,存入的顺序和取出的顺序一致。

    2.元素是有索引的。

    3.元素可以重复。

 

了解List接口的特有方法，注意：这些特有方法都是围绕着角标定义的。

    1.add(index,element);

    2.remove(index):

    3.set(index,element);

    4.get(index);


package cn.itcast.p5.list;
 
import java.util.ArrayList;
import java.util.List;
 
 
 
public class ListDemo {
     
    /**
     * @param args
     */
    public static void main(String[] args) {
    //创建list集合的对象。
    List list = new ArrayList();
    listDemo(list);
    }
    /*
     * 演示List接口。
     */
    public static void listDemo(List list){
        //1，添加元素。
        list.add("abc3");
        list.add("abc9");
        list.add("abc1");
        list.add("abc4");
        //2,指定位置增加元素。
        //list.add(2,"abc2");
        //3,删除指定角标元素。
        //list.remove(4);
        //4,修改指定位置的元素。
        //list.set(2,"abc77");
        //5,获取指定位置的元素。
        System.out.println(list.get(1));
        System.out.println(list);
    }
 
}
 
 
 
package cn.itcast.p5.list;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class ListDemo2 {
 
    public static void main(String[] args) {
     
        /*
         * 取出list中的所有元素。
         * 
         */
        List list = new ArrayList();
        list.add("abc1");
        list.add("abc3");
        list.add("abc2");
        list.add("abc6");
        
        //for(Iterator it = list.iterator(); it.hasNext(); ){
            //System.out.println(it.next());
        //}
        
        //List特有的取出所有元素的方式。
        for (int i = 0; i < list.size(); i++) {
            System.out.println("get("+i+"):"+list.get(i));
            


/*
 * 列表迭代器是List集合的特有迭代器，可以在迭代过程中实现增删改查。
 */  
            
        ListIterator it = list.listIterator();
        while(it.hasNext()){
            Object obj = it.next();
          //如果用Iterateror()会有ConcurrentModificationException不能在迭代过程实现增删
            if(obj.equals("abc2")){
                 //list.add("abc9");
                  it.add("abc9");
            }
        }
   ｝
｝

List接口支持

 

List

    |--Vector:数组结构的,是同步的。被ArrayList替代，因为效率低。

 

    |--ArrayList:数据结构是数组结构，是不同步的。查询速度很快。


    |--LinkedList:数据结构是链表结构，是不同步的。增删速度很快。


ArrayList存储自定义对象

  ArrayList查询速度快，最为常用的集合之一，使用集合的时候，查询的功能用的多。

package cn.itcast.p7.arraylist;
 
import java.util.ArrayList;
import java.util.Iterator;
 
import cn.itcast.bean.Person;
 
public class ArrayListDemo {
    public static void main(String[] args) {
        //创建一个ArrayList集合对象。
        ArrayList al = new ArrayList();
        //添加Person对象,到集合中，其实集合中记录是对象的引用。
        al.add(new Person("lisi1",21));//add(Object obj)
        al.add(new Person("lisi6",26));
        al.add(new Person("lisi2",22));
        al.add(new Person("lisi7",27));
        //取出所有Person对象。
        for (Iterator it = al.iterator(); it.hasNext();) {
               //System.out.println(it.next());
               //调用了Object的toString()方法可以在Person中重载
         
        Person p = (Person)it.next();//取元素时，要强转才可以使用子类特有方法。
        System.out.println(p.getName()+","+p.getAge());
        }
    }
}


LinkedList特有方法

package cn.itcast.p8.linkedlist;
import java.util.LinkedList; 
public class LinkedListDemo {
    public static void main(String[] args) {
        /*
         * LinkedList特有。
         * 
         * addFirst();
         * addLast();
         * 
         * getFirst();
         * getLast();
         * 
         * removeFirst();
         * removeLast();
         */
        //创建一个链表对象。
        LinkedList link = new LinkedList();
        link.addFirst("abc1");
        link.addFirst("abc2");
        link.addFirst("abc3");
        link.addFirst("abc4");
        //System.out.println(link.removeFirst());
        //System.out.println(link.removeFirst());
        //System.out.println(link.getFirst());
        //System.out.println(link.getFirst());
        //System.out.println(link);
        while(!link.isEmpty()){
            System.out.println("link:"+link.removeLast());
        }
    }
}


LinkedList模拟堆栈结构

LinkedList:数据结构是链表结构，是不同步的。增删速度很快

/**用LinkedList模拟堆栈或者队列数据结构。*/

//描述一个具备先进后出的数据结构堆栈。  
class MyStack{
    private LinkedList link;
    MyStack(){
        link = new LinkedList();
    }
    /**
     * 提供一个存储元素的方法。
     */
    public void myAdd(Object obj){
        link.addLast(obj);
    }
    /**
     *  提供一个获取元素的方法。
     */
    public Object myGet(){
        return link.removeLast();
    }
    /**
     * 判断容器中是否有元素。
     */
    public boolean isNull(){
        return link.isEmpty();
    }
}    

package cn.itcast.p8.linkedlist;
import java.util.LinkedList;
public class LinkedListTest {
    public static void main(String[] args) {
        //创建一个自定义个堆栈容器。
        MyStack stack = new MyStack();
        stack.myAdd("abc1");
        stack.myAdd("abc2");
        stack.myAdd("abc3");
        stack.myAdd("abc4");
        stack.myAdd("abc5");
        while(!stack.isNull()){
            System.out.println(stack.myGet());
        }
    }
}


集合List练习

定义功能，去除ArrayList集合中的重复元素。

//第一种方式
public static List getSingleElement(List list){
    //1，创建一个新的容器。
    List temp = new ArrayList();
    //2，遍历已有集合中的元素。并将其存储到新的集合中，在存储时进行判断。新容器中是否包含该元素。
    for(Iterator it = list.iterator(); it.hasNext(); ){
        Object obj = it.next();
        if(!temp.contains(obj)){
            temp.add(obj);
        }
    }
    return temp;
}

//第二种方式。
public static void getSoingleElmement2(List list){
    for(int x=0; x<list.size(); x++){
        Object obj = list.get(x);
        for(int y=x+1; y<list.size(); y++){
            if(obj.equals(list.get(y))){
                list.remove(y);
                y--;
            }
        }
    }
｝