java 集合

<span style="color:#353535;"><span style="font-family:Arial;background-color: rgb(255, 255, 255);">-------------------</span><span style="font-family:Courier New;background-color: rgb(240, 240, 240);">-</span></span><a target=_blank href="http://edu.csdn.net/heima/"><span style="color:#eb00;background: rgb(255, 255, 255);">android<span style="font-family:新宋体;">培训</span></span></a><span style="color:#353535;background: rgb(255, 255, 255);">、</span><a target=_blank href="http://edu.csdn.net/heima"><span style="color:#eb00;background: rgb(255, 255, 255);">java<span style="font-family:新宋体;">培训</span></span></a><span style="color:#353535;background: rgb(255, 255, 255);">、<span style="font-family:Arial;">java</span><span style="font-family:新宋体;">学习型技术博客、期待与您交流！ </span><span style="font-family:Arial;"><span style="font-family:Courier New;background-color: rgb(240, 240, 240);">--------------------</span></span></span><pre class="java" name="code">

1 集合了解 

集合的作用:

面向对象语言对事物的体现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用的一种方式.

集合的特点:

集合只用于存储对象，集合长度是可变的，集合可以存储不同类型的对象.

集合和数组的区别:数组虽然也可以存储对象，但长度是固定的；集合长度是可变的,数组中可以存储基本数据类型，也可以存储对象,集合只能存储对象;数组存储的多个元素是同一种数据类型,集合可以存储多种引用类型的元素.

Collection接口：

Collection接口的有两个子接口:List和Set,List元素有序,元素可以重复,Set元素无序,元素要求唯一.

Collection接口的功能：

1:添加元素

boolean add(Object obj):添加单个元素

boolean addAll(Collection c):添加多个元素

2:判断元素

boolean contains(Object obj):判断元素是否存在

boolean containsAll(Collection c):判断一个集合的元素是否包含在当前集合中

boolean isEmpty():判断集合是否为空 

3:删除元素

void clear():移除所有元素

boolean remove(Object o):移除单个元素,有一个删除，就返回true

boolean removeAll(Collection c):移除多个元素

4:获取元素

Iterator iterator():返回集合上的一个迭代器

5:交集

boolean retainAll(Collection c):交集

6:集合元素个数

int size():元素个数

7:把集合转成数组

Object[] toArray()

 

迭代器Iterator

迭代器，其实就是集合的取出元素的方式。

如同抓娃娃游戏机中的夹子。

迭代器是取出方式，会直接访问集合中的元素。

所以将迭代器通过内部类的形式来进行描述。

通过容器的iterator()方法获取该内部类的对象。

演示代码：

Iterator it = al.iterator();//获取迭代器，用于取出集合中的元素。

while(it.hasNext())//使用接口 Iterator<E>中的hasNext()命令，当仍有元素可以迭代，则返回true，再用while判断，为真就继续执行

{

sop(it.next());//返回迭代的下一个元素。直到没有元素为止。这个命令的输出是从第一个元素开始的，注意

}

Iterator<T> iterator()：迭代器的返回值是一个以Iterator为接口的子类对象，书写形式为Iterator it = al.iterator();为什么这样呢？因为：

集合类中的数据有很多类型，不同的类型返回方式不一样，所以建立一个内部类，内部类方便调用成员函数和成员数据，利用内部类来返回数据。（把取出方式定义在集合内部，这样取出方式就可以直接访问集合内容的元素。这个取出方式就叫做内部类。）

而每个容器的数据结构不同，所以取出的动作细节也不一样，但是都有共性内容的判断和取出。那么可以将其写成共性抽取。这些共性抽取的内部类符合一个规则，该规则就是Iterator接口。想通过集合取出对象就通过接口对外提供的iterator()，这个方便必须通过以Iterator为接口的子类对象来实现。

通过开发要用for函数写这个迭代对象的过程

for(Iterator it = al.iterator(); it.hasNext() ; )

{

sop(it.next());

}

这样写的好处就是Iterator it作为局部变量，用完以后就释放内存。有利于提高内存利用

迭代就是取出集合中元素的一种方式.

迭代器的方法:

boolean hasNext()判断是否还有元素可以迭代

next()返回迭代的下一个元素,获取的元素默认为Object类

注意:1.迭代器在Collcection接口中是通用的，它替代了Vector类中的Enumeration(枚举)

2.迭代器的next()方法是自动向下取元素，要避免出现NoSuchElementException

3.迭代器的next方法返回值类型是Object，所以要记得类型转换

2 Set集合

Set:无序，不可以重复元素。

|--HashSet：数据结构是哈希表。线程是非同步的。

证元素唯一性的原理：判断元素的hashCode值是否相同。

如果相同，还会继续判断元素的equals方法，是否为true。

通过new的方式往HashSet里面存的元素的hashCode都不同，但通常我们定义对象，
比如学生对象时，虽然是new的两个学生对象，但是当他们name和age一样时，我们认为是
同一个对象，所以为了保证元素的唯一性，我们通常在往HashSet集合里面存储元素时，
在定义对象的类中通常复写hashCode和equals方法。
public int hashCode()
{
return name.hashCode()+age*39;
}
public boolean equals(Object obj)
{
if(!(obj instanceof Student))
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;
}

HashSet是如何保证元素唯一性的呢？
如果两元素的hashCode值不同，则不会调用equals方法
如果两元素的hashCode值相同，则继续判断equals是否返回true；
hashCode和equals方法虽然定义在自定义对象类里面，但不是我们手动调用
而是往HashSet集合里面存储元素的时候，集合底层自己调用hashCode和equals
它自己拿对象去判断，自己判断两元素是否是同一个元素。

|--TreeSet：可以对Set集合中的元素进行排序。

底层数据结构是二叉树。

保证元素唯一性的依据：compareTo方法return 0.

TreeSet排序的第一种方式：让元素自身具备比较性。

元素需要实现Comparable接口，覆盖compareTo方法。

也种方式也成为元素的自然顺序，或者叫做默认顺序。

 

第二种排序方式:

当元素自身不具备比较性时，或者具备的比较性不是所需要的。

这时就需要让集合自身具备比较性。

在集合初始化时，就有了比较方式。

TreeSet要求往里面存的元素具备比较性，否则会报错。
1. TreeSet排序的第一种方式:让元素自身具备比较性

 

class Student implements Comparable {// 实现Compareble接口
	private String name;
	private int age;

	public Student(String name, int age) {// 构造方法
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}

	public int compareTo(Object obj) {// 复写compareTo方法
		if (!(obj instanceof Student))
			throw new RuntimeException("不是学生对象！");// 运行时异常
		Student stu = (Student) obj;
		int num = this.age - stu.age;// 按年龄比较
		if (num == 0)
			return this.name.compareTo(stu.name);
		return num;
	}
}

2.TreeSet排序的第二种方式:让集合具备比较性 

import java.util.Comparator;
import java.util.TreeSet;

class StringLengthComparator implements Comparator {// 即定义一个类， 实现Comparator接口
	public int compare(Object obj1, Object obj2) {// 覆盖compare方法。
		String s1 = (String) obj1;
		String s2 = (String) obj2;
		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));// 自然顺序比较
		if (num == 0)
			return s1.compareTo(s2);// 自然顺序比较
		return num;
	}
}

class TreeSetTest {
	public static void main(String[] args) {
		TreeSet ts = new TreeSet(new StringLengthComparator());// 让集合具备比较方式
		ts.add("11111");// 添加元素
		ts.add("2222");
		ts.add("3333");
		ts.add("4444");
	}
}

 

基本数据类型或字符串对象均实现了Comparable接口，故同种类型基本数据间具备比较性，即自然顺序。

Set集合总结：
HashSet:
1. 线程不同步，集合里面存放的元素是无序的，唯一的
2. 底层数据结构是哈希表，哈希表结构的数据都是无序的，哈希表结构的操作效率都高效
3.保证元素唯一性的原理是：通过复写hashCode和equals方法，当主要条件一样时，判断次要条件
TreeSet
1.线程不同步，集合可以对存放的元素进行排序，弥补了Set集合元素无序的缺点，且元素是唯一的
2.底层数据结构是二叉树，二叉树结构都是有序的
3.集合要求往集合里存放的元素自身具备比较性，否则会报错
4.集合排序的第一种方式:让元素自身具备比较性，定义元素类实现Compareble接口，覆盖compareTo方法
5.集合排序的第二种方式:让集合具备比较性，定义一个类，实现Comparator接口，覆盖compare方法。
两种排序方式都在时，以比较器为主

3 List集合 

Collection:顶层接口
|-->List:列表，元素是有序的(元素带角标索引)，可以有重复元素,可以有null元素。
|-->ArrayList(JDK1.2):底层的数据结构是数组数据结构，特点是查询速度快(因为带角标)，
但是增删速度稍慢,因为当元素多时，增删一个元素则所有元素的角标都得改变
线程不同步。默认长度是10，当超过长度时，按50%延长集合长度。
|-->LinkedList(JDK1.2):底层数据结构式链表数据结构(即后面一个元素记录前一个)，
(1)LinkedList的特有方法：
boolean offerFirst(E e) 在此列表的开头插入指定的元素。
boolean offerLast(E e) 在此列表末尾插入指定的元素。
E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
E pollFirst() 获取并移除此列表的第一个元素；如果此列表为空，则返回 null。
E pollLast() 获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。
(2)通过LinkedList的特有方法，可以实现某些数据特殊方式的存取，比如堆栈和队列。
特点：查询速度慢，因为每个元素只知道前面一个元素，但增删速度快 因为元素再
多，增删一个，只要让其前后的元素重新相连即可线程是不同步的。
|-->Vector(JDK1.0):底层数据结构是数组数据结构.特点是查询和增删速度都很慢。默认长度
是10，当超过长度时,按100%延长集合长度。线程同步。(Vector功能跟ArrayList功
能一模一样，已被ArrayList替代)

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

class ArrayListDemo {
	public static void main(String[] args) {
		ArrayList a = new ArrayList();// ArrayList()：构造一个初始容量为 10 的空列表
		a.add("1111");// 将指定的元素添加到此列表的尾部。
		a.add("2222");
		a.add("3333");
		a.add("4444");
		f2(a);
		System.out.println(a);
		f1(a);
		System.out.println(a);
	}

	private static void f1(ArrayList arr) {
		ArrayList a = arr;
		Iterator it = a.iterator();// 获取迭代器iterator
		while (it.hasNext()) {// 如果仍有元素可以迭代,则返回 true
			Object obj = it.next();// 返回迭代的下一个元素。
			if (obj.equals("4444")) {
				// it.set("999999");//没有为类型 Iterator 定义方法 set（String）
				// it.add("000000");//没有为类型 Iterator 定义方法 add（String）
			}
		}
	}

	private static void f2(ArrayList arr) {
		ArrayList a = arr;
		ListIterator lt = a.listIterator();// 获取迭代器对象listIterator
		while (lt.hasNext()) {// 如果仍有元素可以迭代,则返回 true。
			Object obj = lt.next();// 返回迭代的下一个元素。
			System.out.println(obj);
			if (obj.equals("2222")) {
				lt.set("999999");// 可以修改
				lt.add("7777777777777");// 可以添加
			}
		}
		System.out.println(a);
	}
}

List接口的功能：

1：添加元素

void add(int index, Object element):在指定位置添加指定元素

2：获取元素

Object get(int index):根据指定索引获取元素

3：列表迭代器

ListIterator listIterator() 

4：删除元素

Object remove(int index):返回并删除指定位置的元素

5：修改元素

Object set(int index, Object element):修改指定位置的元素

List特有的迭代器：

列表迭代器ListIterator的方法：

void add(E e) 将指定的元素插入列表（可选操作）。

boolean hasPrevious() 如果以逆向遍历列表，列表迭代器有多个元素，则返回 true。 

int nextIndex() 返回对 next 的后续调用所返回元素的索引。 

E previous() 返回列表中的前一个元素。 

int previousIndex() 返回对 previous 的后续调用所返回元素的索引。 

void set(E e) 用指定元素替换 next 或 previous 返回的最后一个元素（可选操作）。 

注意:ListIterator是Iterator的子接口，在迭代时，不可以通过集合对象的方法操作集合中的元素.

解析：

Iterator li = al.Iterator();

while(li.hasNext())

{

Object obj = li.next();

if(obj.equals("java02"))

li.add("java006");

}

在迭代时，不可以通过集合对象的方法操作集合中的元素。

因为会发生ConcurrentModificationException异常。（上面代码这个异常出现的原因是当遍历这些元素的时候，会把元素放到迭代器中，迭代器正在操作这些元素，如果使用集合中add这些命令来操作这些元素，会出现并发修改异常，不安全所以报错）

所以，在迭代器时，只能用迭代器的方法操作元素，可是Iterator方法是有限的，

只能对元素进行判断，取出，删除的操作，

演示代码：

while(it.hasNext())

{

Object obj = it.next();

if(obj.equals("java02"))

it.remove();//将java02的引用从集合中删除了。此时obj拥有it.next的值，所以可以将结果打印。这段代码不会出错因为remove是迭代器内部的命令，可以使用的

sop("obj="+obj);

}

如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。

该接口只能通过List集合的listIterator方法获取。

演示代码

ListIterator li = al.listIterator();

while(li.hasNext())

{

Object obj = li.next();

if(obj.equals("java02"))

li.set("java006");

}

Vector集合迭代：

枚举就是Vector特有的取出方式。

发现枚举和迭代器很像。其实枚举和迭代是一样的。

因为枚举的名称以及方法的名称都过长。所以被迭代器取代了。枚举郁郁而终了。

Linkedlist集合：

特有方法：

addFirst();从头部填充元素

addLast();从尾部填充元素

getFirst();获得第一个元素，但不删除元素

getLast();获得最后一个元素，但不删除元素

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

removeFirst();

removeLast();和getlast的区别是获得以后并删除该元素

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

在JDK1.6出现了替代方法。

offerFirst();同getFirst()；

offerLast();

peekFirst();获取但是不移除第一个元素

peekLast();获取但是不移除最后一个元素

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

pollFirst();获取并移除列表中的第一个元素

pollLast();获取并移除最后一个元素

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

练习：

使用LinkedList模拟一个堆栈或者队列数据结构。

堆栈：先进后出 如同一个杯子。

队列：先进先出 First in First out FIFO 如同一个水管。

import java.util.*;

class LinkedListTest {
	public static void main(String[] args) {
		DuiLie dl = new DuiLie();// 建立对象dl为new duilie()，并进行初始化
		dl.myAdd("java01");// 填充元素
		dl.myAdd("java02");
		dl.myAdd("java03");
		dl.myAdd("java04");
		while (!dl.isNull())// 当dl内部元素不为空时，就执行下面的指令
		{
			System.out.println(dl.myGet());// 打印元素
		}
	}
}

class DuiLie {
	private LinkedList link;// 私有化一个linklist的对象

	DuiLie() {
		link = new LinkedList();// 构造函数初始化
	}

	public void myAdd(Object obj)// 添加元素函数
	{
		link.addFirst(obj);// 对象为obj，就是任意对象，使用linkaddFirst函数，从头部添加函数
	}

	public Object myGet()// 获得元素函数
	{
		return link.removeFirst();// 返回列表中的第一个元素，并移除
	}

	public boolean isNull() {
		return link.isEmpty();// 判断是否为空。
	}
}

 

去除ArrayList集合中的重复元素：

import java.util.*;
class ArrayListTest
{
public static void sop(Object obj)
{
System.out.println(obj);
}
public static void main(String[] args)
{
ArrayList al = new ArrayList();
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java02");
al.add("java01");
al.add("java03");//填充几个元素，有重复的
/*
在迭代时循环中next调用一次，就要hasNext判断一次。所以下面的代码如果在元素个数为奇数时，会出现错误。
Iterator it = al.iterator();
while(it.hasNext())
{
sop(it.next()+"...."+it.next());
}
*/
sop(al);//打印原集合中元素
sop(singleElement(al));//打印去除重复后的元素
}
public static ArrayList singleElement(ArrayList al)//建立一个类singleElement，当做临时容器，用来放那些不重复的元素
{//对象当然是集合，返回类型也是集合。为了让数据更准确，接收的集合以及返回集合都是ArrayList
//定义一个临时容器。
ArrayList newAl = new ArrayList();//建立一个新对象
Iterator it = al.iterator();//利用Iterator接口的子类对象函数iterator()，利用迭代器来输出里面的对象
while(it.hasNext())//当it有下一个元素时
{
Object obj = it.next();//建立一个对象，为it的下一个元素
if(!newAl.contains(obj))//contains()函数是指若包含某元素返回一个布尔型，这条指令意思是如果newAl这个集合中不包含obj这个元素，那么执行下面的指令
newAl.add(obj);//不包含obj就把obj添加到该林芝容器中。
}
return newAl;//返回临时容器
}
}

 

练习2

将自定义对象作为元素存到ArrayList集合中，并去除重复元素。

比如：存人对象。同姓名同年龄，视为同一个人。为重复元素。

思路：

1，对人描述，将数据封装进人对象。

2，定义容器，将人存入。

3，取出。

List集合判断元素是否相同，依据是元素的equals方法。

"=="和"!="比较的是地址.也可认为"=="和"!="比较的是对象句柄;而equals()比较的是对象内容.或者说,,"=="和"!="比较的是"栈"中的内容,而equals()比较的是"堆"中的内容（包括地址）.

演示代码：

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

class Person {
	private String name;
	private int age;

	Person(String name, int age)// 建立一个类的人，用来存储数据人名和年龄
	{
		this.name = name;
		this.age = age;
	}

	public boolean equals(Object obj)// 覆写equals函数。让equals比较对象的内容。系统自带的equals比较的是地址值。而下面代码中新添加的元素虽然内容都一样，但是在堆内存中建立了新的对象，地址值是不一样的。
	{
		if (!(obj instanceof Person))// 假如obj与person不相同。instanceof是用来判断两个变量(引用)是否是同一个类类型的。如果输入的obj是与person一个类型就执行下个指令。
			return false;// 就返回false
		Person p = (Person) obj;// 强制将obj父类类型转换为person子类类型。上面为什么不用person，而是用obj，首先是因为这个比较方法用在集合中，接收的对象不一定都是person，其实如果只写person，输入的不是person，就会报错，应该是这样解释吧~~~
		// System.out.println(this.name+"....."+p.name);
		return this.name.equals(p.name) && this.age == p.age;// 将对象的name和age与括号中对象p的name和age比较。
	}

	public String getName() {
		return name;
	}

	public int getAge() {
		return age;
	}
}

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

	public static void main(String[] args) {
		ArrayList al = new ArrayList();
		al.add(new Person("lisi01", 30));
		al.add(new Person("lisi02", 32));
		al.add(new Person("lisi02", 32));
		al.add(new Person("lisi04", 35));
		al.add(new Person("lisi03", 33));
		al.add(new Person("lisi04", 35));
		al = singleElement(al);
		sop("remove 03:" + al.remove(new Person("lisi03", 33)));// remove方法底层也是依赖于元素的equals方法。如果前面没有equals的覆写，这条指令也会编译是不，不会移除lisi，33
		Iterator it = al.iterator();// 将重复的对象取出
		while (it.hasNext())// 打印出对象
		{
			Person p = (Person) it.next();
			sop(p.getName() + "::" + p.getAge());
		}
	}

	public static ArrayList singleElement(ArrayList al) {
		// 定义一个临时容器。
		ArrayList newAl = new ArrayList();
		Iterator it = al.iterator();
		while (it.hasNext()) {
			Object obj = it.next();
			if (!newAl.contains(obj))
				newAl.add(obj);
		}
		return newAl;
	}
}

 

List使用注意：
ArrayList:
(1)当往ArrayList里面存入元素没什么要求时，即只要求有序就行时；
(2)当往ArrayList里面存入元素要求不重复时，比如存入学生对象，当同名同姓时
视为同一个人，则不往里面存储。则定义学生对象时，需复写equals方法
public boolean equals(Object obj)//覆写equals方法
{ if(!(obj instanceof Student)) //判断obj是不是Student的子类
return false;
Student stu = (Student)obj;
return this.name.equals(stu.name)&&this.age==stu.age;//根据姓名和年龄判断
}
则往ArrayList集合通过add存入学生对象时，集合底层自己会调用学生类的equals方法，
判断重复学生则不存入。
注：对于List集合，无论是add、contains、还是remove方法，判断元素是否相同，都是通过复写equals方法来判断！

List集合总结：

1. List集合里面的元素因为是带角标，所以List集合里面的元素都是有序的，
另外List集合可以包含重复元素，也可以包含null。 
2. List集合有迭代器Iterator，还有一个特有迭代器列表ListIterator
3.Iterator只能对元素进行判断、取出和删除的操作， ListIterator可对元素进行添加和修改动作等。
4.List集合中判断元素是否相同都是用equals方法，无论contains、remove都依赖equals方法
比如往ArrayList集合里面存放学生，同名同年龄视为同一个人，此时就需要在学生类复
写Object类里面的equals方法
5. 一般情况下，使用哪种List接口下的实现类呢？
如果要求增删快，考虑使用LinkedList
如果要求查询快，考虑使用ArrayList
如果要求线程安全，考虑使用Vector。