java基础----集合框架知识点总结（一）

                                   **第一个类   Collention类 **

一、概述。
1、该类是集合类的基本接口，它位于集合类的顶层。Collection接口的定义如下：

public interface Collection<E> extends Iterable<E>

2、此类使用了泛型技术，有利于集合的安全性。
3、此类是List接口和Set接口的父接口
二、方法摘要。
1）向集合中添加一个元素： boolean add(E e)
2) 清除集合中所有的元素： boolean clear()
3) 判断是否存在所指定的元素： boolean contains(Object o)
4) 判断集合是否为空： boolean isEmpty()
5）删除指定的元素： boolean remove(Object o)
6）返回集合中元素的个数： int size()
所有实现Collection接口的类都必须提供两个标准的构造函数：
1）无参数的构造函数。
2）一个带有Collection参数的有参构造函数。

                                   第二个类   List类
一、概述。
1、 List 接口是一个有序的集合，其元素以线性方式存储，集合中允许存放相同的元素。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。
2、List接口的两个实现类为ArrayList和LinkedList。
3、其接口定义如下：

public interface List<E> extends Collection<E>

二、方法摘要。
1）、在集合的指定位置添加元素：void add(int index, E element)
2）、返回集合中指定位置的元素：E get(int index)
3）、移除指定位置的元素： E remove(int index)
4）、替换指定位置的元素： E set(int index, E element)
5）、为ListIterator接口实例化，用户遍历集合中元素（特有方法）：ListIterator listIterator()
6）、返回按适当顺序在列表的元素上进行迭代的迭代器。Iterator iterator() `

示例：

package 泛型;

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

public class ListIteratorTest {

    public static void main(String[] args){
        //List是个接口，可以通过ArrayList类实例化。
        List list=new ArrayList();
        //添加元素
        list.add("haha");
        list.add("xixi");
        list.add("lala");
        list.add("enen");
        sop(list);
        //获取迭代器用于操作元素。
        ListIterator it=list.listIterator();
        //取出集合中的元素
        while(it.hasNext()){
            String s=(String)it.next();
            sop(s);
            //修改元素
            if(s.equals("enen"))
                it.set("heihie");

        }
        it.add("yaya");//通过迭代器添加元素。
        sop(list);
    }

    private static void sop(Object obj) {
        // TODO Auto-generated method stub
        System.out.println(obj);
    }
}

                                   第三个类   ArrayList类和Vector类
一、概要。
1、此类是List接口的实现类。
2、此类的底层数据结构是数组。
3、此类的容量就是数组的大小。
4、此类实现数据的查询速度块，但是实现增、删效率慢。
5、此类是不同步的。
二、构造方法摘要。
1、 ArrayList() 构造一个初始容量为 10 的空列表。
2、`ArrayList(Collection

package 泛型;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

/*
 * Collection
 *      |--List：元素是有序的，元素可以重复，因为该体系有索引
 *          |--ArrayList:底层的数据结构使用的是数组。特点：查询数据很快，但是增，删慢。线程不同步
 *          |--LinkedList：底层使用的是链表。特点：增删的速度快，增删的很慢
 *          |--Vector：底层使用的是数组数据结构。线程同步，速度非常慢，被ArrayList代替
 * List:特有的方法，凡是可以操作角标的地方都是该体系特有的方法
 * 
 * 增：
 *      add(index,element);
 *      addAll(index,Collection)
 * 删：
 *      remove(index);
 * 
 * 改：
 *      set(index,element)
 * 
 * 查：   
 *      get(index)
 *      subList(from,to)
 *      ListIterator();
 * 
 * 
 * 
 */
public class ListDemo {

    public static void main(String[] args){
        ArrayList list=new ArrayList();

        //添加元素

        list.add("1");
        list.add("2");
        list.add("3");
        list.add("4");

        sop(list);

        //增加元素

        list.add(0,"0");
        sop(list);

        ArrayList al=new ArrayList();
        al.add("haha");
        al.add("xixi");
        al.add("wei");
        list.add(0,al);
        sop(list);
        list.addAll(0,al);
        sop(list);

        //删除元素

        list.remove(0);
        sop(list);

        //修改元素

        list.set(2,"haha");
        sop(list);

        //查元素

        sop(list.get(0));

        //遍历
        for(int i=0;i<list.size();i++){
            sop(list.get(i));
        }

        Iterator it=list.iterator();//获取迭代器用于取出集合中的元素，只能进行判断，删除，取出的操作
        while(it.hasNext()){
            sop(it.next());
        }
        //list特有的迭代器功能齐全
        ListIterator li=list.listIterator();
        while(li.hasNext()){
            Object obj=li.next();
            if(obj.equals("1"))
                li.set("aiyouwei");
        }

        sop(list);
        //获取元素的索引

        sop(list.indexOf("wei"));

        List l=list.subList(0, 5);
        sop(l);

        while(li.hasPrevious())//逆向遍历列表
            sop(li.previous());

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

}

Vector类
示例：

package 泛型;
/*
 * 枚举是Vector特有的取出方法
 * 其实枚举和迭代是一样的，因为枚举的名称以及方法的名称都过长，所以被迭代器取代了
 */
import java.util.Enumeration;
import java.util.ListIterator;
import java.util.Vector;

public class VectorDemo {

    public static void main(String[] args){
        Vector v=new Vector();
        v.add("1");
        v.add("2");
        v.add("3");
        v.add("4");

        Enumeration e=v.elements();

        while(e.hasMoreElements())
            System.out.println(e.nextElement());




        ListIterator li=v.listIterator();
        while(li.hasNext()){
            Object obj=li.next();
            if(obj.equals("1"))
                li.set("aiyouwei");
        }

    }
}

                                   第四个类   LinkedList类
一、概要。
1、此类是链表类，采用链表接口保存元素。
2、此类的优点在于删除、插入元素效率较快。
3、此类是不同步的。
二、构造方法摘要。
1、 LinkedList() 构造一个空列表。
2、LinkedList(Collection c) 构造一个包含指定 collection 中的元素的列表
三、方法摘要。
1、void addFirst(E e) 将指定元素插入此列表的开头。
2、void addLast(E e) 将指定元素添加到此列表的结尾。
3、E getFirst() 返回此列表的第一个元素。
4、E getLast() 返回此列表的最后一个元素。
在JDK1.6之后的新方法。
5、boolean offerFirst(E e) 在此列表的开头插入指定的元素。
6、boolean offerLast(E e) 在此列表末尾插入指定的元素。
7、E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，返回为null 。
8、E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空,返回null。
9、E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
10、E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
示例一：

package 泛型;

import java.util.Iterator;
import java.util.LinkedList;

/*
 * LinkList特有的方法：
 * addFirst()
 * addLast()
 * 
 * getFirst()
 * getLast()
 *获取元素但不删除元素，如果集合中没有元素，会抛出NoSuchElementException
 *
 *removeFirst()
 *removerLast()
 *获取元素但是元素被删除，如果集合中没有元素，会出现NoSuchElementException
 *
 *在JDK1.6出现了替代方法
 *
 *offerFirst()
 *offerLast()
 *
 *peekFirst()
 *peekLast()
 *获取元素但不是元素被删除，如果集合中没有元素，会返回null
 *
 *pollFirst()
 *pollLast()
 *获取元素但是元素被删除，如果集合中没有元素，会出现NoSuchElementException
 * 
 */
public class LinkListDemo {

    public static void main(String[] args){
        LinkedList list=new LinkedList();

//      list.add("1");
//      list.add("2");
//      list.add("3");
//      list.add("4");
//      sop(list);

//      list.addFirst("1");
//      list.addFirst("2");
//      list.addFirst("3");
//      list.addFirst("4");
//      sop(list);

        list.addLast("1");
        list.addLast("2");
        list.addLast("3");
        list.addLast("4");
        sop(list);

        sop(list.getFirst());
        sop(list.getLast());

        Iterator it=list.iterator();

         while(it.hasNext())
             sop(it.next());
         sop(list.removeFirst());
         sop(list.removeLast());
         sop(list);
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

示例二：

package 泛型;

import java.util.LinkedList;

/*
 *使用linkedList模拟队列或者堆栈数据结构
 *
 *队列：先进先出
 *堆栈：先进后出
 */
class duiLie{
    private LinkedList link;
    duiLie(){
        link=new LinkedList();
    }
    public void myAdd(Object obj){
        link.addFirst(obj);
    }
    public Object getElement(){

        return link.removeLast();
    }
    public boolean isNull(){
        return link.isEmpty();
    }
}
public class LinkedListTest {

    public static void main(String[] args){
        duiLie link=new duiLie();
        link.myAdd("1");
        link.myAdd("2");
        link.myAdd("3");
        link.myAdd("4");

        while(!link.isNull())
            System.out.println(link.getElement());
    }
}

示例三：

“`
package 泛型;

import java.util.Iterator;
import java.util.LinkedList;

/*
* 去除linkedlist中相同的元素
*
*/
class newLink{
private LinkedList link=null;
public newLink(){
link=new LinkedList();
}
public LinkedList delete(LinkedList obj){
Iterator it=obj.iterator();
while(it.hasNext()){
if(link.contains(it.next())==false)
link.addLast(it.next());

    }
    return link;
}

}
public class LinkedListTest1 {

public static void main(String[] args){
    LinkedList link=new LinkedList();
    link.add("1");
    link.add("1");
    link.add("2");
    link.add("2");
    link.add("3");
    link.add("3");
    link.add("4");
    link.add("4");
    System.out.println(link);
    LinkedList L=new LinkedList();
    L=new newLink().delete(link);

    System.out.println(L);
}

}