List集合学习

List集合学习

 

List:特有的常见方法：有一个共性特点就是都可以操作角标。

1、List接口的方法

1，添加

       void add(index,element);

       void add(index,collection);

2，删除；

       Object remove(index):

3，修改：

       Object set(index,element);

4，获取：

       Object get(index);

       int indexOf(object);

       int lastIndexOf(object);

       List subList(from,to);

2、List接口的功能

list集合是可以完成对元素的增删改查。

3、List接口的实现类

List:

       |--Vector:内部是数组数据结构，是同步的。增删，查询都很慢！

       |--ArrayList:内部是数组数据结构，是不同步的。替代了Vector。查询的速度快。

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

3.1LinkedList

（1）LinkedList（一些方法）

LinkedList:

【1】插入

       addFirst();//将指定元素插入此列表的开头。

       addLast()://将指定元素添加到此列表的结尾。

      jdk1.6

       offerFirst();//在此列表的开头插入指定的元素。

       offerLast();//在此列表末尾插入指定的元素。

【2】返回元素(获取但不移除)

       getFirst();.//返回此列表的第一个元素。【获取但不移除，如果链表为空，抛出NoSuchElementException.】

       getLast();//返回此列表的最后一个元素。【获取但不移除，如果链表为空，抛出NoSuchElementException.】

      jdk1.6

       peekFirst();//获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。

       peekLast()://获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。

【3】移除元素(获取并移除)

       removeFirst();//获取并移除，如果链表为空，抛出NoSuchElementException.

       removeLast();//移除并返回此列表的最后一个元素。

      jdk1.6

       pollFirst();//获取并移除，如果链表为空，返回null.

       pollLast();//获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。

（2）LinkedList应用：模拟一个堆栈或者队列

package collection;
 
import  java.util.Arrays;
import  java.util.LinkedList;
 
/*
 * LinkedList模拟一个堆栈或者队列
 * 1.DuiLie 队列  先进先出
 * 2.zhan   堆栈  先进后出
 */
//模拟队列  先进先出
//1.添加 2..获取
class DuiLie {
    private LinkedList li;
    public DuiLie() {
       this.li =new LinkedList();
    }
 
    // 1.添加
    public void myAdd(Object obj) {
       li.addLast(obj);//添加到最后位置
    }
    // 2.获取
    public Object myGet() {
       return  li.removeFirst();//取出第一个
    }
    // 3.判断是否为空
    public boolean isNull() {
       return  li.isEmpty();
    }
}

// 模拟队列先进先出
//1.添加 2..获取
class Zhan {
    private LinkedList li;
    public Zhan() {
       this.li =new LinkedList();
    }
 
    // 1.添加
    public void myAdd(Object obj) {
       li.addLast(obj);//添加到最后位置
    }
    // 2.获取
    public Object myGet() {
       return  li.removeLast();//取出最后一个
    }
    // 3.判断是否为空
    public boolean isNull() {
       return  li.isEmpty();
    }
}
public class Test {
 
    public static void main(String[] args) {
 
       //队列 先进先出
       //每次添加元素，添加到集合的最后一个位置
       //每次获取元素，获取集合的第一个位置的元素
       DuiLie d=new DuiLie();
       d.myAdd("abc1");
       d.myAdd("abc2");
       d.myAdd("abc3");
       d.myAdd("abc4");
       System.out.println("队列存放的顺序：abc1,abc2,abc3,abc4");
       System.out.print("队列取出的顺序：");
       while(!d.isNull()){
           System.out.print(d.myGet()+",");;
       }
       System.out.println();
       System.out.println("---------------------------------");
      
       //堆栈 先进后出
       //每次添加元素，添加到集合的最后一个位置
       //每次获取元素，获取集合的最后一个位置的元素
       Zhan  z=new Zhan();
       z.myAdd("abc1");
       z.myAdd("abc2");
       z.myAdd("abc3");
       z.myAdd("abc4");
       System.out.println("堆栈存放的顺序：abc1,abc2,abc3,abc4");
       System.out.print("堆栈取出的顺序：");
       while(!z.isNull()){
           System.out.print(z.myGet()+",");
       }
       System.out.println();
    }
   
}

3.2ArrayList角标越界（IndexOutOfBoundsException）之思

【1】越界案例

package  collection;
import  java.util.ArrayList;
import  java.util.List;
public class Basic {
    public static void main(String[] args) {
      
       List list = new ArrayList();//构造一个初始容量为 10的空列表
       System.out.println("列表对象数量："+list.size());//而size存储着列表对象的数量,默认为0
      
       list.add("abc1");
       list.add("abc2");
       list.add("abc3");//此时，容量仍然为10(Capacity=10)，列表对象数量为3(size=3)
      
       //越界异常
       System.out.println(list.get(4));//异常：IndexOutOfBoundsException Index: 3, Size: 3
      
       //IndexOutOfBoundsException - 如果索引超出范围 (index < 0 || index >=size())
       System.out.println("list:" +list);
    }
 
}

【2】ArrayList初始容量和列表对象数量思考

参考来源：博客园

博主：潸何

文章：Java中的ArrayList的初始容量和容量分配

网址：http://www.cnblogs.com/ShanHeDiao/p/4402030.html

详情：请看参考来源

ArrayList自动改变size机制：“自动增长机制”

java引进了Capacity和size概念，以区别数组的length。为了保证用户增加新的列表对象，java设置了最小容量（minCapacity）

，通常情况上，它大于列表对象的数目，所以Capactiy虽然就是底层数组的长度（length），但是对于最终用户来讲，它是无意义的。而size存储着列表对象的数量，才是最终用户所需要的。为了防止用户错误修改，这一属性被设置为private的，不过可以通过size()获取

Capacity初始值（initialCapacity）可以由用户直接指定或由用户指定的Collection集合存储的对象数目确定，如果没有指定，系统默认为10。而size的被声明为int型变量，默认为0

个人总结：

ArrayList中的容量，只是说明可以存多少个元素，并不一定全部容量都存有元素，存多少个，看使用者的意愿！所以capacity和size不一定相等！

如果ArrayList的容量不够时，ArrayList会进行扩容操作！

3.3vector

vector的遍历，是通过枚举进行。而枚举Enumeration和迭代器Iterator功能是类似的

使用实例:

package collection;
 
import  java.util.Enumeration;
import  java.util.Iterator;
import  java.util.Vector;
 
public class VectorDemo {
 
    public static void main(String[] args) {
 
       Vector v=newVector();
       v.addElement("abc1");
       v.addElement("abc2");
       v.addElement("abc3");
       System.out.println(v.capacity());//10 容量为10
       System.out.println(v.size());// 3向量中组件数为3
       //遍历
       for(Enumeration  en=v.elements();en.hasMoreElements();){
           System.out.println(en.nextElement());
       }
      
       //类似
//     for(Iterator  it=v.iterator();it.hasNext();){
//         System.out.println(it.next());
//     }
    }
 
}