Java集合框架-1.【集合类】【Collection接口】【List】【ArrayList】【Vector】【LinkedList】

一、集合类(集合框架)

1、集合类：是一种容器。用于封装存储对象，并提供一些功能方法来操作这些对象数据。

2、特点：

①、集合只用于存储对象。

②、集合的长度是可变的。

③、集合可以存储不同类型的对象。

3、数组和集合的区别：

相同点：数组和集合都是容器，都可以用于存储对象。

不同点：数组的长度是固定的，集合的长度是可变的。

数组中可以存储基本数据类型，而集合中只能存储对象。

4、集合框架体系图：



5、集合框架中为什么会出现这么多的容器？

因为每一个容器对数据的存储方式都有所不同，这个存储方式称之为：数据结构。

二、Collection接口

1、是Java的Collection集合框架中的根接口。可以向其中加入多个单值数据。

2、Collection接口中常用的共性方法：

①、添加元素：boolean add(E e)

示例代码：

public static void addMethod()
{
//创建一个集合容器。使用Collection接口的子类。ArrayList
ArrayList al = new ArrayList();
//1、添加元素。
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
System.out.println("集合："+al);  //打印集合。
}

②、获取长度/获取交集：int size() / booleanretainAll(Collection<?> c)

示例代码：

public static void getSize()
{
//创建一个集合容器。使用Collection接口的子类ArrayList。
ArrayList al1 = new ArrayList();
al1.add("java01");
al1add("java02");

ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java03");

System.out.println("集合长度="+al1.size());  //打印集合al1的长度。
System.out.println(“交集：”+al1.retainAll(al2));  //输出集合al1和集合al2的中相同的元素，即取交集。
}

③、删除元素：boolean remove(Object o)

booleanremoveAll(Collection<?> c)

void clear()

示例代码：

public static void delete()
{
//创建一个集合容器。使用Collection接口的子类ArrayList。
ArrayList al1 = new ArrayList();
al1.add("java01");
al1add("java02");
ArrayList al2 = new ArrayList();
al2.add("java01");
al2.add("java03");

al1.remove("java02");       //删除指定的元素。
al1.clear();        //清空集合。
al1.removeAll(al2);        //删除集合al1和集合al2中相同的元素。
}

④、判断元素：boolean contains(Object o)

boolean isEmpty()

示例代码：

public static void isMethod()
{
ArrayList al = new ArrayList();
al.add(“java01”);
al.add(“java02”);
System.out.println(“java02在集合中是否存在？”+al.contains(“java02”));
System.out.println(“集合是否为空？”+al.isEmpty());  //false。
}

3、集合中对象的存储方式：

示例代码：

Person p = new Person();

ArrayList al = new ArrayList();

al.add(p);



总结/注意：

①、add方法的参数类型是Object，以便于接收任意类型对象。

②、集合中存储的都是对象的引用(地址)。

4、迭代器(Iterator)：

①、迭代器：其实就是取出集合中元素的一种方式。

②、迭代器适用范围：Collection接口以及其子类集合对象。

③、迭代器取出元素示例：

public static void method_get()
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");

Iterator it = al.iterator();  //获取迭代器用于取出集合中的元素。
while(it.hasNext()) //使用循环以及hasNext()方法判断集合中是否有元素。
{
System.out.println(it.next());  //使用next()方法取出集合中的元素。
}
}

/*
输出结果：java01
java02
java03
java04
*/

④、迭代器内部实现方式：



迭代器规则：把从容器中取出元素的方式定义在集合的内部，这样取出方式就可以直接访问集合内部的元素，而这种方式就被定义成了内部类。

由于每一个容器的数据结构不同，所以取出的动作细节也不一样，但是它们都有共性的内容：判断和取出。那么就可以将共性内容进行抽取，则这些内部类符合的规则就是迭代器规则。

⑤、迭代器用法：

for(Iterator iter = iterator(); iter.hasNext();)
{
System.out.println(iter.next());
}

Iterator iter = l.iterator();
while(iter.hasNext())
{
System.out.println(iter.next());
}

三、List集合

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

2、List集合体系结构：

Collection

|--List

|--ArrayList：底层的数据结构使用的是数组结构。

|--LinkedList：底层使用的链表数据结构。

|--Vector：底层是数组数据结构。

3、List集合的特有方法：凡是可以操作角标的方法都是List体系特有的方法。

4、List集合中的常用方法：

增

void add(int index, E element)

boolean addAll(int index, Collection<?extends E> c)

删

E remove(int index)

改

E set(int index, E element)

查

E get(int index)

List<E> subList(int fromIndex, inttoIndex)

ListIterator<E> listIterator()

代码示例：

public static void method()
{
List al = new ArrayList();

//添加元素。
al.add("java01");
al.add("java02");
al.add("java03");

System.out.println("原集合是："+al);
//在指定位置添加元素。
al.add(1,"java09");

//删除指定位置的元素。
al.remove(2);

//修改元素。
//al.set(2,"java007");

//通过角标获取元素。
System.out.println("get(1):"+al.get(1));

System.out.println(al);

//获取所有元素。
for(int x=0; x<al.size(); x++)
{
System.out.println("al("+x+")="+al.get(x));
}

Iterator it = al.iterator();
while(it.hasNext())
{
System.out.println("next："+it.next());
}

//通过indexOf获取对象的位置。
System.out.println("index="+al.indexOf("java02"));

List sub = al.subList(1,3);
System.out.println("sub="+sub);
}

5、ListIterator迭代器

是List集合特有的迭代器，是Iterator的子接口。

注意：在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，只能对元素进行判断、取出、删除的操作。

如果想要操作其它的操作，如：添加、修改等，就需要使用其子接口ListIterator。该接口只能通过List集合的listIterator方法获取。

代码示例：

public static void method()
{
//演示列表迭代器。
List al = new ArrayList();

//添加元素。
al.add("java01");
al.add("java02");
al.add("java03");

System.out.println("原集合："+al);

ListIterator li = al.listIterator();
System.out.println("hasPrevious():"+li.hasPrevious());     //true

while(li.hasNext())
{
Object obj = li.next();

if(obj.equals("java02"))
{
//li.add("java0009");
li.set("java006");
}
}

while(li.hasPrevious())  //通过hasPrevious方法逆向判断集合中的元素。
{
System.out.println("pre:"+li.previous());  //通过previous方法逆向取出元素。
}
//System.out.println("hasNext():"+li.hasNext());  //false
//System.out.println("hasPrevious():"+li.hasPrevious());  //true
System.out.println(al);

/*
//在迭代过程中，准备添加获取删除元素。
Iteratorit = al.iterator();
while(it.hasNext())
{
//System.out.println("next："+it.next());

Objectobj = it.next();
if(obj.equals("java02"))
//al.add("java008");
it.remove();

System.out.println("obj="+obj);
}
System.out.println(al);
*/
}

6、ArrayList的特点：

底层的数据结构使用的是数组结构。
查询速度很快，但是增删速度稍慢。
JDK1.2版本出现，线程不同步，不安全，但效率高，可以手动加锁。
默认初始长度为10，当超过10个元素的长度以后，它会new一个新的数组，做50%的延长变成长度为15，再将多出来的元素添加到新数组里去。

7、Vector的特点：

底层是数组数据结构。
查询速度慢，已经被ArrayList所取代。
JDK1.0版本出现，线程同步，安全，但效率很低。
默认初始化长度为10，超过10个元素之后，新new的数组做100%延长变成20，比较浪费内存空间。

Vector的特有操作——枚举Enumeration

import java.util.*;
class VectorDemo
{
public static void main(String[] args)
{
Vector v = newVector();

v.add("java01");  //往Vector集合中添加元素。
v.add("java02");
v.add("java03");
v.add("java04");

Enumeration en = v.elements();  //使用枚举从集合中取出元素。
while(en.hasMoreElements())  //通过hasMoreElements方法判断集合中是否有元素。
{
System.out.println(en.nextElement());  //通过nextElement方法取出元素。
}
}
}

总结：枚举就是Vector特有的取出方式。和迭代器的功能是一样的。（由于枚举的名称和方法名称过长，所以被Iterator迭代器所取代了）

8、LinkedList的特点：

底层使用的是链表数据结构。
增删速度快，查询稍慢。
线程不同步，不安全。

LinkedList特有方法：

①、添加元素

addFirst();

addLast();

②、获取元素

getFirst();

getLast();

注：获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException异常。

③、删除元素

removeFirst();

removeLast();

注：获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException异常。

代码示例：

import java.util.*;
class LinkedListDemo
{
public static void main(String[] args)
{
LinkedList link = new LinkedList();
link.addLast("java01");
link.addLast("java02");
link.addLast("java03");
link.addLast("java04");

sop(link);
sop(link.getFirst());     //java01
sop(link.getLast());     //java04
sop(link.removeFirst());      //java01
sop(link.removeLast());      //java04

sop("size="+link.size());
while(!link.isEmpty())
{
sop(link.removeFirst());  //循环取出，并删除集合中的元素。
//sop(link.removeLast());  //逆向循环取出并删除集合中的元素。
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

在JDK1.6中出现了替代方法：

①、添加元素

offerFirst();

offerLast();

②、删除元素：

注：获取元素，但是不删除元素。如果集合中没有元素，会返回null。

peekFirst();

peekLast();

注：获取元素，但是元素被删除。如果集合中没有元素，会返回null。

pollFirst();

pollLast();

LinkedList集合的队列和堆栈数据结构：

队列：先进先出。Firstin First out--->FIFO。如同水管里的球，先进去的先出来。

堆栈：先进后出。如同水杯里的球，先进去的后出来。

FIFO代码示例：

import java.util.*;
class DuiLie
{
private LinkedList link;
DuiLie()
{
link = new LinkedList();
}
public void myAdd(Object obj)
{
link.addFirst(obj);
}
public Object myGet()
{
return link.removeLast();       //将先存进去的元素先取出来。
//return link.removeFirst();      //演示先进后出。先存进去的元素后取出来。
}
public boolean isNull()      //判断集合是否为空。
{
return link.isEmpty();
}
}

class LinkedListTest
{
public static void main(String[] args)
{
DuiLie dl = new DuiLie();
dl.myAdd("java01");
dl.myAdd("java02");
dl.myAdd("java03");
dl.myAdd("java04");

while(!dl.isNull())
{
sop(dl.myGet());
}
}
public static void sop(Object obj)
{
System.out.println(obj);
}
}

输出结果：java01
java02
java03
java04
验证了先存进集合中的元素先取出来了。