黑马程序员 java基础之集合框架List

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

List的基类接口是Collection,List集合有三个常见子类ArrayList ,LinkedList, Vector；

ArrayList底层的数据结构式数组结构。特点在于查询速度很快，线程不同步。

Vector底层的数据结构式数组结构。线程时安全的，出现在jdk1.2版本，增删改查速度都很慢，已被ArrayList替代。

LinkedList的底层的数据结构式链表结构。增加，修改，删除元素的速度也是很快的。

List集合特点是：元素时有序的，同时元素是可以重复的，因为该集合体系时有索引。

List集合中的特有方法

void add(int index, Ojbect b) 向指定集合的位置中添加添加元素；

void addAll(int index,Collection c) 向集合中添加集合c

void remove(int index) 删除集合指定位置处的元素

E get(int index) 获取指定位置处的元素

int   indexOf(Object o) 返回集合中第一次出现该元素的索引下标

int  lastIndexOf(Object o) 返回集合中最后一次出现该元素的索引下标，如果集合中没有出现该元素，那么返回-1；

E  set(int index ,Object o) 用指定的元素替换集合指定位置的元素。

ListIterator listIterator() 返回集合中的一个迭代器。

通过上面的方法我们可以发现，List集合中都可以操作索引下标。

/*
List接口中特有的方法
增
add(int index ,Object obj)
addAll(Collection c)
删
remove(int index);
removeAll(Collection c)
改
set(int index,Object obj)
查
get(int index);
subList(int start,int from)
listIterator();

*/
import java.util.*;
class JavaCollection1_2
{
public static void main(String[] args)
{
//创建list接口下的一个子类ArrayList对象。
ArrayList al=new ArrayList();
al.add("java_1");
al.add("java_2");
al.add("java_3");
al.add("java_4");
sop("原集合："+al);
//1 在指定的位置添加元素
al.add(1,"java_5");
sop(al);
// 2删除指定位置的元素。
al.remove(3);
sop(al);
//3修改指定位置的元素。
al.set(0,"java_10");
sop(al);
//4获取所有的元素
//使用List集合的get()方法。使用角标进行遍历。
for(int i=0;i<al.size();i++)
{
sop("al("+i+")="+al.get(i));
}
//5使用迭代器
for(ListIterator lit=al.listIterator();lit.hasNext();)
{
sop(lit.next());
}

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

List集合中Vector的特性用法：

import java.util.*;
/*
ArrayList，LinkedList不支持枚举，统一使用迭代器。
枚举就是Vector特有的取出方式。
枚举和迭代的方式是类似的。
因为枚举的方法名过长，因此被迭代器取代。
*/
class JavaCollection1_3
{
public static void main(String[] args)
{
Vector v=new Vector();
v.add("java_1");
v.add("java_2");
v.add("java_3");
v.add("java_4");
Enumeration e=v.elements();//使用枚举。
while(e.hasMoreElements())
{
sop(e.nextElement());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

List集合中LinkedList的特性用法：

/*
LinkedList特有的方法：
addFirst();向头部添加元素
addLast();向尾部添加元素
getFirst();获取LinkedList集合中头部的元素
getLast();获取LinkedList集合中尾部的元素
这里的getFirst()和getLast()方法都是获取元素，但是不删除元素。
removeFirst();
removeLast();
这里的removeFirst和removeLast方法也可以获取元素，但是元素也同时被删除了

注意事项；
使用上面的方法，如果集合中没有元素，那么就会抛出NoSuchElementException异常
在jdk1.6的版本中出现了替代了方法

offerFirst()
offerLast()

peekFirst()
peekLast()
--获取元素，但是不删除元素，如果集合中没有该元素，那么就会返回null,不会抛出异常

pollFirst()
pollLast()
--返回元素，并且也回删除元素，如果集合中没有该元素，那么也就返回Null，不会抛出异常
*/
import java.util.*;
class JavaCollection1_4
{
public static void main(String[] args)
{
LinkedList ll=new LinkedList();
ll.addFirst("java_1");
ll.addFirst("java_2");
ll.addFirst("java_3");
ll.addFirst("java_4");
sop(ll);
sop(ll.getFirst());
sop(ll.getLast());
//sop(ll.removeFirst());
//sop(ll.removeLast());
//sop(ll);

//不用迭代器使用removeFirst方法也可以取出LinkedList集合中的元素
while(!ll.isEmpty())
{
sop(ll.removeFirst());
}
sop("**************************");
method1();
}
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void method1()
{
LinkedList ll=new LinkedList();
ll.offerFirst("java01");
ll.offerFirst("java02");
ll.offerLast("java03");
ll.offerLast("java04");
sop(ll);
sop(ll.peekFirst());
sop(ll.peekLast());
sop(ll.pollFirst());
sop(ll.pollLast());
sop(ll);
}
}

LinkedList练习：

/*
使用一个LinkedList来简单的模拟堆栈数据结构。
堆栈：先进后出
队列：先进先出
*/
import java.util.*;
class JavaCollection1_5
{
public static void main(String[] args)
{
QueueDemo q=new QueueDemo();
q.add("java_1");
q.add("java_2");
q.add("java_3");
q.add("java_4");
//sop(q.get());
while(!q.Null())
{
sop(q.get());
}

StackDemo s=new StackDemo();
s.add("java_1");
s.add("java_2");
s.add("java_3");
s.add("java_4");
while(!s.Null())
{
sop(s.get());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}
/*模拟队列*/
class QueueDemo
{
private LinkedList link;
QueueDemo()
{
link=new LinkedList();
}
public void add(Object obj)
{
link.offerFirst(obj);
}
public Object get()
{
return link.pollLast();
}
public boolean Null()
{
return link.isEmpty();
}
}
/*模拟堆栈*/
class StackDemo
{
private LinkedList link;
StackDemo()
{
link=new LinkedList();
}
public void add(Object obj)
{
link.offerFirst(obj);
}
public Object get()
{
return link.pollFirst();
}
public boolean Null()
{
return link.isEmpty();
}
}

ArrayList集合练习：

/*
去除ArrayList中重复的元素。
思路：
创建一个新的ArrayList，然后在遍历需要除重的老集合，然后在判断新集合中是否存在当前遍历的元素，如果不存在，就添加到新的集合中，如果存在，那么当前元素就不用添加到新集合中。
遍历结束后，那么新集合就是去重后的集合
*/
import java.util.*;
class JavaCollection1_6
{
public static void main(String[] args)
{
ArrayList al=new ArrayList();
al.add(1);
al.add(2);
al.add(3);
al.add(4);
al.add(4);
al.add(3);
al.add(2);
List list=getSingleArrayList(al);
sop(list);
}
public static List getSingleArrayList(ArrayList al)
{
ArrayList temp_al=new ArrayList();
for(ListIterator it=al.listIterator();it.hasNext();)
{
Object obj=it.next();//注意在循环中it.next()只能使用一次，马上it.hasNext()判断一次，不然就有可能报异常。
if(!temp_al.contains(obj))//如果新集合中不存在该元素，那么便添加该元素。
{
temp_al.add(obj);
}
}
return temp_al;
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}