Java笔记之list集合--Arraylist和vector<二>

---|List: 有存储顺序, 可重复
                 ---|ArrayList:   数组实现, 查找快, 增删慢
                                    由于是数组实现, 在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

                 ---|LinkedList:  链表实现, 增删快, 查找慢
                                    由于链表实现, 增加时只要让前一个元素记住自己就可以, 删除时让前一个元素记住后一个元素, 后一个元素记住前一个元素. 这样的增删效
　　　　　　　　　　　　　　　　　　　　　率较高但查询时需要一个一个的遍历, 所以效率较低

                 ---|Vector:      和ArrayList原理相同, 但线程安全, 效率略低
                                    和ArrayList实现方式相同, 但考虑了线程安全问题, 所以效率略低

ArrayList实现原理：

数组实现, 查找快, 增删慢

数组为什么是查询快?因为数组的内存空间地址是连续的.

ArrayList底层维护了一个Object[] 用于存储对象，默认数组的长度是10。可以通过 new ArrayList(20)显式的指定用于存储对象的数组的长度。

当默认的或者指定的容量不够存储对象的时候，容量自动增长为原来的容量的1.5倍。

由于ArrayList是数组实现, 在增和删的时候会牵扯到数组增容, 以及拷贝元素. 所以慢。数组是可以直接按索引查找, 所以查找时较快

可以考虑,假设向数组的0角标未知添加元素,那么原来的角标位置的元素需要整体往后移,并且数组可能还要增容,一旦增容,就需要要将老数组的内容拷贝到新数组中.所以数组的增删的效率是很低的.

list集合特有的方法：

  1.增加

 void add(int index, E element) 指定位置添加元素            

 boolean addAll(int index, Collection c) 指定位置添加集合  

import java.util.ArrayList;
import java.util.List;

public class Demo01 {

    public static void main(String[] args) {
        List list =new ArrayList ();
        list.add("风");
        list.add("雨");
        list.add(1,"下雪了");//指定位置添加元素  
        List list02 =new ArrayList ();
        list02.add("雷");
        list02.add("电");    
        list.addAll(0,list02);//往指定索引处添加集合
        System.out.println("list指定位置添加："+list);
        

    }

}

输出结果：

list指定位置添加：[雷, 电, 风, 下雪了, 雨]

2.删除：

E remove(int index) 删除指定位置元素

3.修改

E set(int index, E element)    返回的是需要替换的集合中的元素

public class Demo02 {
    public static void main(String[] args) {
        List list =new ArrayList ();
        list.add("风");
        list.add("雨");
        list.add(1,"下雪了");
        list.remove(0);
        System.out.println("删除指定位置元素："+list);
        list.set(0,"下");
        System.out.println(list);
    }
}

输出结果：

删除指定位置元素：[下雪了, 雨]
[下, 雨]

4.查找：

E get(int index)             注意： IndexOutOfBoundsException

int indexOf(Object o)         // 找不到返回-1

lastIndexOf(Object o)

5.求子集合

 List<E> subList(int fromIndex, int toIndex) // 不包含toIndex

import java.util.ArrayList;
import java.util.List;

public class Demo02 {
    public static void main(String[] args) {
        List list =new ArrayList ();
        list.add("风");
        list.add("雨");        
        list.add("雷");
        list.add("风");
        Object ss= list.get(1);//返回object类型
        System.out.println("第一次出现的位置："+list.indexOf("雨"));
        System.out.println("最后一次出现的位置"+list.lastIndexOf("风"));
        System.out.println("根据索引值获取："+ss);
        List sub= list.subList(1, 2);
        System.out.println("截取后的元素："+sub);
        System.out.println(list);
    }
}

输出结果：

第一次出现的位置：1
最后一次出现的位置3
根据索引值获取：雨
截取后的元素：[雨]
[风, 雨, 雷, 风]

练习：去除List集合中重复元素

循环遍历该集合，每取出一个放置在新的集合中，放置之前先判断新的集合是否以包含了新的元素。

思路:

 存入人的对象.

 1先定义person 类

 2将该类的实例存入集合

 3 将对象元素进行操作. 注意:自定义对象要进行复写toString 和 equals 方法.

 为什么? 因为object 是person 的父类,object 中的toString 返回的是哈希值,object 类中equals

 方法比较的是对象的地址值.

 思路

 1存入字符串对象

 2存入自定义对象 如person

 2创建容器,用于存储非重复元素

 3对原容器进行遍历,在遍历过程中进行判断遍历到的元素是否在容器中存在.(contains)

 4如果存在,就不存入,否则存入.

 5 返回新容器

import java.util.ArrayList;
import java.util.List;

class Person{
    int id;
    String name;
    public Person(int id,String name) {
        this.id=id;
        this.name=name;    
    }
    @Override
    public boolean equals(Object obj) {
        if (!(obj instanceof Person)) {
            return false;
        } else {
            Person person=(Person) obj;
            return this.id==person.id&&this.name.equals(person.name);
        }
        
    }
    @Override
    public String toString() {
        return "编号："+this.id+"  姓名："+this.name;
    }
}
public class Demo03 {

    public static void main(String[] args) {
        List list =new ArrayList ();
        list.add(new Person(110, "孙悟空"));
        list.add(new Person(120, "孙空"));
        list.add(new Person(110, "孙悟空"));
        
        List arr2 = new ArrayList();
        for (int i = 0; i < list.size(); i++) {
            Object obj = list.get(i);
            Person p = (Person) obj;
            if (!(arr2.contains(p))) {
                arr2.add(p);
            }
        }
        System.out.println(arr2);
    }

}

输出结果：

[编号：110  姓名：孙悟空, 编号：120  姓名：孙空]

由于存在重复元素，所以此处新集合中只存入不同对象元素

Vector集合

Vector: 描述的是一个线程安全的ArrayList。

ArrayList： 单线程效率高

Vector   ： 多线程安全的，所以效率低

特有的方法：

 void addElement(E obj)  在集合末尾添加元素

 E elementAt( int index) 返回指定角标的元素

 Enumeration elements()  返回集合中的所有元素，封装到Enumeration对象中

 Enumeration 接口：

  boolean hasMoreElements() 

  测试此枚举是否包含更多的元素。

  E nextElement()

   如果此枚举对象至少还有一个可提供的元素，则返回此枚举的下一个元素。

import java.util.Enumeration;
import java.util.Vector;
public class Demo04 {
　　　　public static void main(String[] args) {


　　    Vector v = new Vector();
        v.addElement("渊虹");
        v.addElement("鲨齿");
        v.addElement("干将莫邪");
        System.out.println( v );
        System.out.println("指定输出的元素："+ v.elementAt(2) );   // 指定输出
        // 遍历Vector遍历
        Enumeration ens = v.elements();
        System.out.println("遍历输出的元素：");
        while ( ens.hasMoreElements() )
        {
            System.out.println( ens.nextElement() );
        }
　　}
}

输出：

[渊虹, 鲨齿, 干将莫邪]
指定输出的元素：干将莫邪
遍历输出的元素：
渊虹
鲨齿
干将莫邪

 其他方法详见   http://www.cnblogs.com/AllenRandolph/p/6940230.html