黑马程序员——Java基础—集合框架（一）

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

一概述

二Collection

三迭代器

四List

五List子类对象

六HashSet

集合框架（一）

一、概述

1.集合出现的原因

Java中，数据被封装成对象；对象完成了对数据的存储。而集合的出现，完成了对对象的存储，方便对对象进行操作。

2.集合与数组的区别

1）数组虽然可以存储对象，但是长度固定，不利于后期扩展；只能存储同一类型对象；

2）集合的长度是可变的；并且能存储不同类型对象

3.集合的特点

1）长度可变；

2）可以存储不同类型的对象；

3）集合只用于存储对象，不能存储基本数据类型

二、Collection

1.定义

Collection

是集合框架层次结构中的根接口。

Collection

提供了具体的自接口（如

Set

和

List

）实现。这个根接口用来传递

collection

，并提供共性方法，操作这些

collection

。

2.共性方法

1）添加操作

-boolean add(E e)：添加指定元素到集合中

-boolean addAll(Collection<？ extends E> c)：添加指定集合中的所有元素到当前集合中

2）判断操作

-boolean contains(Object o)：判断当前集合中是否包含指定元素

-booean isEmpty()：判断当前集合是否为空

3）删除操作

-void clear()：清空当前集合

-boolean remove(Object o)：移除指定元素

-boolean removeAll(Collection<？> c)：指定一个集合，将该集合中的元素从当前集合中移除

4）获取操作

-int size()：获取当前集合长度

-booean retianAll(Collection<？> c)：取当前集合与指定集合的交集

-Iterator iterator()：迭代器，用于取出集合中元素

3.共性方法演示

演示

Collection

中的共性方法。

示例代码：

package com.heisejiuhuche.Collection;

import java.util.ArrayList;

public class CollectionDemo {
public static void main(String[] args) {
method1();
method2();
}

private static void  method2() {
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");
ArrayList a2 = new ArrayList();
a2.add("java03");
a2.add("java04");
a2.add("java05");
a2.add("java06");
//取交集
al.retainAll(a2);
print(al);
}

private static void method1() {
ArrayList al = new ArrayList();
//添加操作
al.add("java01");
al.add("java02");
al.add("java03");
al.add("java04");

//打印集合，结果为[java01, java02, java03, java04]
print(al);
//删除
al.remove("java03");
print(al);
//是否包含指定对象
print(al.contains("java-2"));
//是否为空
print(al.isEmpty());
//清楚所有对象
al.clear();
print(al);
print(al.size());
}

private static void print(Object obj) {
System.out.println(obj);
}
}

注意：

-add()方法的参数类型是Object，以便于接受任意类型对象；

-集合中存放的不是对象实体，存储的是对象内存地址

三、迭代器

1.定义

迭代器是对

Iterator

接口的实现，用于取出集合中的对象，以便于对对象进行操作。



容器的取出操作，不足以用一个方法描述。每个容器的取出操作过程，都有所不同。因此，容器将取出操作封装成一个对象，对象中提供了多个功能以实现容器对象的取出操作。 每个容器类的内部，都定义了做取出操作的内部类（便于直接访问容器内部的元素），用于取出各容器不同数据结构中的对象。这个取出操作被称为迭代器。无论是什么容器，其迭代器的操作都会有判断和取出的操作，将这些操作提取之后形成了

Iterator

接口。每个容器通过调用

iterator()

方法，获得自身的迭代器。

2.迭代器的使用

iterator()方法返回的是一个Iterator接口的子类对象

1）获取

iterator

迭代器：

Iterator it = arraylist.iterator();

2）调用

next()

方法获取第一个元素并打印：

System.out.println(it.next());

3）调用

hasNext()

方法，循环取出所有元素

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

四、List

1.List集合的特点

List

集合中的元素是有序的，并可以重复。该集合体系有索引。

2.List集合特有方法

凡是操作索引的方法都是该体系特有的方法。

1）添加操作

-void add(int index, E element)：添加指定元素

-boolean addAll(int index, Collection<？ extends E> c)：在指定位置插入指定collection中的元素

2）获取操作

-get(int index)：返回集合中指定位置元素

-int indexOf(Object o)：获取元素的索引，不存在返回-1

-int lastIndexOf(Object o)：反向索引

-ListIterator listIterator()：List集合特有迭代器

-List subList(int fromIndex, int toIndex)：返回子集合

3）删除操作

-remove(int index)：按索引移除元素

4）修改操作

-set(int index, E element)：用指定元素替换指定位置的元素

3.特有方法演示

示例代码：

package com.heisejiuhuche.Collection;

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

public class ListDemo {
public static void main(String[] args) {
ArrayList arr = new ArrayList();

arr.add("java01");
arr.add("java02");
arr.add("java03");
arr.add(1, "java04");

ArrayList arr2 = new ArrayList();

arr2.add("java05");
arr2.add("java06");
arr2.add("java07");

arr.addAll(3, arr2);

arr.remove(0);
arr.set(1, "java10");
System.out.println(arr.get(0));
System.out.println(arr.indexOf("java07"));
System.out.println(arr.lastIndexOf("java01"));

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

List list = arr.subList(1, 5);

for(Iterator it = list.iterator(); it.hasNext();) {
System.out.println("---" + it.next());
}
}
}

3.ListIterator列表迭代器

1）定义

List集合特有迭代器，

ListIterator

，是

Iterator

的子接口。迭代器和集合不能对同一组元素进行两种不同的操作（取和增），会发生

ConcurrentModificationException

异常；因此，在迭代时，只能用迭代器的方法操作元素。但是Iterator的方法是有限的，只有判断，取出和删除操作。如果需要添加或者修改的操作，就需要使用

ListIterator

。该接口只能通过

List

集合的

listIterator()

方法获取。

2）列表迭代器特有方法

-void add(E e)：添加指定元素

-set(E e)：修改指定元素

-boolean hasPrevious()：指针位之前有没有元素

五、List子类对象

1.List子类对象组成

List

ArrayList

LinkedList

Vector

List

子类对象包括

ArrayList

，

LinkedList

和

Vector

。

2.List子类对象的特点

1）ArrayList

ArrayList

底层数据结构使用的是数组结构；特点在于查询速度块，但是增加删除操作速度较慢

2）LinkedList

LinkedList

底层数据结构使用的是链表结构；特点在于增加删除操作较快，查询速度较慢

3）Vector

Vector

底层数据结构使用的是数组结构；

Vector

是最早的容器，其特点在与，

Vector

是线程同步的

3.Vector中的枚举

枚举（

Enumeration

）是

Vector

的迭代器，是其特有的取出元素方式。枚举和迭代是一样的，选用迭代的原因是，枚举的代码过长。

示例代码：

package com.heisejiuhuche.Collection;

import java.util.Enumeration;
import java.util.Vector;

public class VectorDemo {
public static void main(String[] args) {
//创建Vector对象
Vector v = new Vector();
//添加元素
v.add("java01");
v.add("java02");
v.add("java03");
v.add("java04");

//使用枚举遍历元素
for(Enumeration e = v.elements();e.hasMoreElements();) {
System.out.println(e.nextElement());
}
}
}

程度输出结果：

java01
java02
java03
java04

4.LinkedList

1）LinkedList中的特有方法

JDK6.0之前方法：

-void addFirst(E e)：将指定元素插入链表开头

-void addLast(E e)：将指定元素插入链表结尾

-getFirst()：获取第一个元素

-getLast()：获取最后一个元素

-removeFirst()：移除第一个元素，并获取该元素，如果元素不存在，抛出NoSuchElementException

-removeLast()：移除最后一个元素，并获取该元素，如果元素不存在，抛出NoSuchElementException

JDK6.0之后新方法：

-E pollFirst():移除第一个元素，并获取该元素，如果元素不存在，返回null

-E pollLast():移除最后一个元素，并获取该元素，如果元素不存在，返回null

-offerFirst():将指定元素插入链表开头

-offerLast():将指定元素插入链表结尾

2）LinkedList练习

使用

LinkedList

模拟堆栈或队列数据结构

堆栈数据结构：先进后出；如同一个桶

队列数据结构：先进先出（

FIFO

）如果水管

队列数据结构示例代码：

package com.heisejiuhuche.Collection;

import java.util.LinkedList;

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

for(;!ml.myEmpty();) {
System.out.println(ml.myGet());
}
}
}

class MyList {
private LinkedList list;

/*
* 初始化MyList
*/
MyList() {
list = new LinkedList();
}

/*
* 声明MyList添加方法，添加到MyList头部
*/
public void myAdd(Object obj) {
list.offerFirst(obj);
}

/*
* 声明MyList获取方法，获取MyList尾部元素
*/
public Object myGet() {
return list.pollLast();
}

/*
* 声明判断MyList是否为空的方法
*/
public boolean myEmpty() {
return list.isEmpty();
}
}

程序输出结果：

java01
java02
java03
java04

堆栈数据结构，只需修改如下代码：

/*
* 声明MyList获取方法，获取MyList头部元素
*/
public Object myGet() {
return list.pollFirst();
}

程序运行结果：

java04
java03
java02
java01

5.ArrayList练习

1）练习1

去除

ArrayList

中的重复元素

示例代码：

package com.heisejiuhuche.Collection;

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

public class ArrayListTest {
public static void main(String[] args) {
ArrayList arrList = new ArrayList();

arrList.add("java01");
arrList.add("java01");
arrList.add("java02");
arrList.add("java02");
arrList.add("java03");
arrList.add("java01");
arrList.add("java03");
arrList.add("java04");

System.out.println("原列表： " + arrList);
arrList = singleElement(arrList);
System.out.println("新列表： " + arrList);
}

private static ArrayList singleElement(ArrayList list) {
ArrayList arrList = new ArrayList();

/* 遍历ArrayList，如果新的容器中没有旧容器中的元素，就将这个元素添加到新容器 */
for(Iterator it = list.iterator(); it.hasNext(); ) {
Object obj = it.next();
if(!arrList.contains(obj)) {
arrList.add(obj);
}
}
/* 返回新容器 */
return arrList;
}
}

程序输出结果：

原列表： [java01, java01, java02, java02, java03, java01, java03, java04]
新列表： [java01, java02, java03, java04]

2）练习2

将自定义元素添加到

ArrayList

集合中，并去除重复元素。例如，存人对象；同姓名同年龄，视为重复元素。

示例代码：

package com.heisejiuhuche.Collection;

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListTest2 {
public static void main(String[] args) {
ArrayList arrayList = new ArrayList();

arrayList.add(new Person("lisi01", 30));
arrayList.add(new Person("lisi02", 31));
arrayList.add(new Person("lisi01", 30));
arrayList.add(new Person("lisi03", 36));
arrayList.add(new Person("lisi03", 36));
arrayList.add(new Person("lisi02", 31));
arrayList.add(new Person("lisi04", 31));

arrayList = singleElement(arrayList);

for(Iterator it = arrayList.iterator(); it.hasNext(); ) {
/*
* 将obj向下转型成Person类型
*/
Person p = (Person)it.next();
System.out.println(p.getName() + "..." + p.getAge());
}
}

private static ArrayList singleElement(ArrayList list) {
ArrayList arrList = new ArrayList();

for(Iterator it = list.iterator(); it.hasNext(); ) {
Object obj = it.next();
if(!arrList.contains(obj)) {
arrList.add(obj);
}
}
return arrList;
}
}

/*
* 声明Person类，以加入ArrayList
*/
class Person {
private String name;
private int age;

Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return this.name;
}

public int getAge() {
return this.age;
}

/* 复写Object类中的equals方法，判断年龄和姓名相等，就是同一对象 */
/* 列表的contains方法会调用equals()方法进行比较 */
public boolean equals(Object obj) {
if(!(obj instanceof Person)) {
return false;
}
Person p = (Person)obj;
return (this.name.equals(p.name)) && (this.age == p.age);
}
}

程序输出结果：

lisi01...30
lisi02...31
lisi03...36
lisi04...31

结论：

-List集合判断元素是否相同，依据的是元素的equals()方法；

-List集合删除元素的时候，依据的是原色的equals()方法判断List中是否有该元素

六、HashSet

1.Set集合的特点

Set

集合的元素是无序的，指的是存入和取出的顺序不一定以致，并且元素不可以重复。

2.Set集合常见子类对象特点

Set

HashSet

TreeSet

1）HashSet

HashSet底层数据结构是哈希表

2）TreeSet

TreeSet底层数据结构是二叉树

3.HashSet使用

示例代码：

package com.heisejiuhuche.Collection;

import java.util.HashSet;
import java.util.Iterator;

public class HashSetDemo {
public static void main(String[] args) {
/*
* 创建HashSet对象
*/
HashSet hs = new HashSet();
/*
* 添加元素
*/
hs.add("java01");
hs.add("java02");
hs.add("java02");
hs.add("java03");
hs.add("java04");
hs.add("java04");
hs.add("java05");

/*
* 打印所有元素
*/
for(Iterator it = hs.iterator(); it.hasNext(); ) {
System.out.println(it.next());
}
}
}

程序运行结果：

java05
java04
java03
java02
java01

高能：

-HashSet集合在存储对象的时候，为保证元素的唯一性，是以对象的哈希值为标准进行判断；如果哈希值不同，则直接进行存储；如果哈希值相同，HashSet集合则启动第二套比较机制，用两个对象equals()方法，对两个对象的属性进行比较，如果此时比较结果不同，则进行存储，相同，则不存储；

-开发时，如果要讲对象存入HashSet，一定要复写hashCode()和equals()方法，以确保对象唯一性

以存储Person类为例，要确保存储的Person对象的唯一性，要复写hashCode()和equals()方法；Person类代码如下：

class Person {
private String name;
private int age;

Person(String name, int age) {
this.name = name;
this.age = age;
}

public String getName() {
return this.name;
}

public int getAge() {
return this.age;
}

/*
* 复写hashCode()方法，以姓名和年龄为依据，计算Person对象的哈希值，并确保唯一
*/
public int hashCode() {
return name.hashCode() + age * 37;
}

/* 复写Object类中的equals方法，判断年龄和姓名相等，就是同一对象 */
public boolean equals(Object obj) {
if(!(obj instanceof Person)) {
return false;
}
Person p = (Person)obj;
return (this.name.equals(p.name)) && (this.age == p.age);
}
}

程序输出结果：

lisi01....20
lisi03....21
lisi02....22

注意：

HashSet在进行判断元素是否存在和删除元素操作的时候，同样依据的是hashCode()方法和equals()方法来保证元素的唯一性

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