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

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

 

集合框架

集合：面向对象语言对事物的体现都是以对象的形式，因此我们会创建大量的对象，为了方便对大量的对象进行操作，java就提供了集合类。

在此之前，我们也学习过数组，数组也可以用来存储大量的对象元素，在此我们来学习一下数组和集合的区别：

1、长度区别：数组的长度一旦确立就不可改变，但是集合是可以改变长度的

2、储存数据类型区别：数组可以存储基本数据类型，也可以存储引用数据类型，而集合只能存储应用数据类型

3、内存区别：数组只能存储同种数据类型的元素，而集合可以存储不同数据类型的元素

下面我们来演示一下集合的体系：

在Collection中有很多方法，其主要功能有添加功能，删除功能，判断功能，获取功能，长度功能，交集功能和将集合转换为数组的功能。

a：添加功能

boolean add（Object obj）添加一个元素

boolean addAll（Collection  c）添加一个集合的元素

b：删除功能

void clear（） 清空集合的元素

boolean remove（Object obj） 移除一个元素

boolean removeAll（Collection c）移除一个集合的元素

c：判断功能

boolean contains（Object obj）判断指定元素是否在集合中

boolean containsAll（Collection c）判断集合中是否包含 指定集合的元素

d：获取功能

Iterator<E> iterator 迭代器

e：长度功能

int size（） 获取集合元素个数

f：交集功能

boolean retainAll（Collection  c）仅保留在此集合中也在指定集合中的元素

g：把集合转换成数组

Object[]  toArray（）

代码实现：

public class Person {//首先定义一个人类，然后将人该有的属性，简略化的描述一下
private String name;
private int age;
public Person() {
super();
}
public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}

注意：在这里一定要复写toString方法，不然在遍历集合打印对象的时候就会打印出对象的地址值。

public class Demo {
public static void main(String[] args) {
Collection c = new ArrayList();
Person p1 = new Person("小明",20);
Person p2 = new Person("小白",21);
Person p3 = new Person("小红",22);
c.add(p1);
c.add(p2);
c.add(p3);
Iterator it = c.iterator();
while( it.hasNext()){
System.out.println(it.next());
}
}
}

解释：因为Collection是接口不能创建对象，我们在这里选用了它的子类ArrayList用多态的形式创建 对象，这里涉及到的一个往集合中添加元素和遍历集合中的元素。在下面我们会重点讲解。

一、Iterator接口

迭代器是一个接口，用于取集合中的元素。

为什么迭代器要定义为接口，我们知道不同的集合有中不同的数据结构，也就是储存结构不同，如果将迭代器定义为一个类，就不能应对不同的集合，如果将其定义为一个抽象类，这样虽然可以通过重写抽象方法来实现对于不同数据类型的合集的迭代，但子类的扩展性就不会很强，所以定义成了接口。

方法摘要

boolean hasNext（）如果仍有元素可以迭代，返回true，也就是说，还有多个元素就返回true

E   next（）   返回迭代的下一个元素

void   remove（） 从迭代器指向的 collection 中移除迭代器返回的最后一个元素

Iterator it = c.iterator();
while( it.hasNext()){
System.out.println(it.next());
}

其迭代方式如上：这一行代码 内部原理 Iterator it = c.iterator()是调用iterator()，返回的本质是一个匿名对象，看源码得知，是返回一个Itr类的匿名对象，而Itr是一个实现了Iterator接口的类，其中根据不同集合类的调用重写了Iterator接口的相应调用类的迭代方法，使其可以成为调用该方法的类的迭代器，进行迭代。

二、List类

List概述和特点：元素有序，并且每一个元素都存在索引，元素可以重复

List是继承了Collection的，但是也有其自己独有的方法

void  add（int index ， E   element）在指定索引处添加元素

E remove（int index） 移除指定索引处的元素

E get（int index） 获得指定索引处的元素

E  set（int index ， E  element）更改指定索引处的元素

也有其特有的迭代器：ListIterator

boolean hasPrevious（）：是否存在前一个元素

E previous（） ：返回列表中的前一个元素

下面代码演示：

import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
public class ListDemo {
public static void main(String[] args) {
List list = new ArrayList();
Person p1 = new Person("小明",20);
Person p2 = new Person("小白",21);
Person p3 = new Person("小红",22);
list.add(p1);
list.add(p2);
list.add(p3);
ListIterator it = list.listIterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("-------------------------");
while(it.hasPrevious()){
System.out.println(it.previous());
}
}
}

运行结果：

Person [name=小明, age=20]
Person [name=小白, age=21]
Person [name=小红, age=22]
-------------------------
Person [name=小红, age=22]
Person [name=小白, age=21]
Person [name=小明, age=20]

解释：首先通过迭代器将元素输出，并且迭代之后指针到了最后一位，然后previous()方法是返回前一个元素，hasPrevious是判断前一个是否有元素，这样经过循环之后指针有回到了开始的位置。

Collection是单列集合体系中的源头，它是一个接口，而在这里我们主要学习它有两个子接口，分别是List和Set，而在本文我们有主要学习List接口，而List接口又有好多个实现该接口的类，我们今天主要学习三个实现List的类，ArrayList，LinkedList和Vector。

ArrayList：底层数据结构是数组，查询快，增删慢

线程不安全，但是效率高哦

LinkedList：底层是链表数据结构，查询慢，增删快

线程不安全，但是效率高

Vector： 底层数据结构是数组，查询快，增删慢

线程安全，但是效率低

三、数据结构

数据结构其实就是存储数据的格式

分类：栈，队列，数组，树，哈希表，链表

栈特点：先进后出，后进先出

队列：先进先出，后进后出

数组：查询快，增删慢

链表：查询慢，增删快

四、ArrayList类

ArrayList实现了Collection接口，重写了接口中的抽象方法，其用法和上面的代码有区别，但原理一样。

特点：ArrayList的底层数据结构是数组，因此就有了查询元素快，但是增删元素慢，线程不安全，随之的是效率高。

查阅API可知，ArrayList实现了List的方法。我们用代码来演示一下，同样是Person类创建对象，然后传递到集合中，在用迭代器和for循环两种方式遍历出来。

import java.util.ArrayList;
import java.util.Iterator;
public class ArrayListDemo {
public static void main(String[] args) {
ArrayList a = new ArrayList();
Person p1 = new Person("小明",20);
Person p2 = new Person("小白",21);
Person p3 = new Person("小红",22);
a.add(p1);
a.add(p2);
a.add(p3);
Iterator it = a.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
System.out.println("-------------------------------");
for(int x = 0 ; x < a.size() ; x++){
System.out.println(a.get(x));
}
}
}

运行结果：

Person [name=小明, age=20]
Person [name=小白, age=21]
Person [name=小红, age=22]
-------------------------------
Person [name=小明, age=20]
Person [name=小白, age=21]
Person [name=小红, age=22]

解释：add()方法是将Person对象添加到集合中，而Iterator it = a.iterator()则是建立迭代器，ArrayList是collection的子类，而collection又是Iterator的子类，所以ArrayList重写了iterator()方法，iterator()方法的返回值是一个Itertor类型的对象，如果你看了原码可知，ArrayList重写之后，该方法返回了一个匿名对象，return new Itr()，而Itr又实现了Iterator接口，所以这也是多态的形式，重写了hasnext()和next()方法，再说一下，hasnext()是判断集合中是否有多个元素，next()是返回集合中的元素，然后指针移动向下一位。

五、Vector

概述：Vector的类可以实现增长长度的数组，Vector是同步的

重要方法：

特有功能：

public void  addElement（Eobj）  将指定的组件添加到此向量的末尾，将其大小增加 1

public  EelementAt（int index）返回指定索引处的组件。

public  Enumeration elements（） 返回此向量的组件的枚举。

下面代码实现：

import java.util.Enumeration;
import java.util.Vector;
public class VectorDemo {
public static void main(String[] args) {
Vector v = new Vector();
v.add("hello");
v.add("world");
v.add("java");
Enumeration en = v.elements();
while(en.hasMoreElements()){
System.out.println(en.nextElement());
}
}
}

运行结果：

hello
world
java

解释：创建Vector对象，向集合中添加字符串，然后调用方法创建Vector特有的遍历集合的方法，称为枚举，然后遍历集合，将集合中元素打印出来。下面是Vector枚举方法的原码。

可以看出，elements方法返回的是一个Enumeration的对象，但是查阅API可知，Enumeration是接口，其中有hasMoreElements方法和nextElemnet方法，hasMoreElements方法是判断是否有更多元素，nextElement方法是返回枚举的下一个元素，从上图可以看出，用匿名内部类的方式返回了Enumeration对象并从写了其中的hasMoreElements方法和nextElement方法，使其枚举集合中的元素

注意：Vector类出现的很早，在jdk1.0的时候就已经出现了，那个时候要遍历Vector集合元素就只能用枚举的方法，虽然此类的效率低，但是安全性高，但是现在并不多用了

六、LinkedList

概述：List接口的链接列表实现，此实现不是同步的。

特有方法：

public  void    add Frist（E  e）及addLast（E   e）将指定元素插入到此列表的开头或添加到结尾

publicEgetFrist（）及getLast（） 返回此列表的第一个元素或最后一个元素

publicEremoveFrist及removeLast（）移除并返回列表的第一个元素或最后一个元素

代码实现：

import java.util.LinkedList;
public class LinkedListDemo {
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.add("hello");
list.add("world");
list.add("java");
System.out.println("list = " + list);
list.addFirst("1");
list.addLast("5");
System.out.println("list = " + list);
System.out.println(list.getFirst());
System.out.println(list.getLast());
list.removeFirst();
list.removeLast();
System.out.println("list = " + list);
}
}

运行结果：

list = [hello, world, java]
list = [1, hello, world, java, 5]
1
5
list = [hello, world, java]

总结：此节主要学习了Collection接口，以及List接口和其三个实现子类ArrayList，Vector，LinkedList，其中三个类尤其自己特有方法，也实现了接口的很多方法，大多主要是集合的操作方法，添加，删除，修改，遍历等等。

ArrayList和Vector底层是数组数据结构，但是Vector线程安全，ArrayList线程不安全

LinkedList底层是链表，线程不安全。还有，数组都是查询元素快，增删元素慢。链表都是查询元素慢，增删元素快。