黑马程序员——集合框架

最新推荐文章于 2024-09-14 18:46:05 发布

smile78356

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量318

点赞数

分类专栏： Java学习笔记文章标签： java

本文链接：https://blog.csdn.net/smile78356/article/details/45166021

版权

Java学习笔记专栏收录该内容

10 篇文章 0 订阅

订阅专栏

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

Java Collection框架中包含了大量的集合接口以及这些接口的实现类和操作它们的算法（例如排序、查找、反转、替换、复制、取最小元素、取最大元素等），具体而言，主要提供了List（列表）、Queue（队列）、Set（集合）、Stack(栈)、和Map(映射表，用于存放键值对)等数据结构。其中，List、Queue、Set、Stack、都继承Collection接口。

Collection是整个集合框架的基础，它里面存储一组对象，表示不同类型的Collection，它的作用只是提供维护一组对象的基本接口而已。

下面分别介绍Set、List、Map三个接口。

1）Set表示数学意义上的概念。其主要的特点是集合中的元素不能重复，因此存入Set的每个元素都必须定义equals（）方法来确保对象的唯一性。该接口有两个实现类：HashSet和TreeSet。其中TreeSet实现了SortedSet接口，因此TreeSet容器中的元素是有序的。

2）List又称为有序的Collection。它按对象进入的顺序保存对象，所以他能对列表中的每个元素的插入和删除位置进行精确的控制。同时，它可以保存重复的对象。LinkedList、ArrayList和Vector都实现了List接口。

3）Map提供了一个从键映射到值的数据结构。它用于保存键值对，其中值可以重复，但键是唯一的，不能重复。Java类库中有多个实现该接口的类：HashMap、TreeMap、LinkedHAshMap。虽然它们都实现了相同的接口，但执行效率不完全相同。具体而言，HashMap基于散列表实现的，采用对象的HashCode可以进行快速查询。LinkedHashMap采用列表来维护内部的顺序。TreeMap基于红黑树的数据结构来实现的，内部元素是按需排列的。

Collection的框架类图如下：

Collection定义了集合框架的共性功能。
1）添加
add(e);
addAll(collection);
2）删除
remove(e);
removeAll(collection);
clear();
3）判断。
contains(e);
isEmpty();
4）获取
iterator();
size();
5）获取交集。
retainAll();

al1.retainAll(al2);去交集，al1中只会保留和al2中相同的元素
6）集合变数组。
toArray();

迭代器（Iterator）是一个对象，它的工作是遍历并选择序列中的对象，它提供了一种访问一个容器（container）对象中的各个元素，而又不必暴漏该对象内部细节的方法。

使迭代器的使用要注意的事项：

1）使用容器的iterator（）方法返回一个Iterator，然后通过Iterator的Next方法返回第一个元素。

2）使用Iterator的hasNest（）方法判断容器中是否还有元素，如果有可以使用next（）方法获取下一个元素。

3）可以通过remove（）方法删除迭器返回的元素。


		//创建一个集合容器。使用Collection接口的子类。ArrayList
		ArrayList al = new ArrayList();

		//1，添加元素。
		al.add("java01");//add(Object obj);
		al.add("java02");

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

		while(it.hasNext())
		{
			sop(it.next());
		}

Collection
|--List:元素是有序的，元素可以重复。因为该集合体系有索引。
|--ArrayList:底层的数据结构使用的是数组结构。特点：查询速度很快。但是增删稍慢。线程不同步。
|--LinkedList:底层使用的链表数据结构。特点：增删速度很快，查询稍慢。线程不同步。
|--Vector:底层是数组数据结构。线程同步。被ArrayList替代了。因为效率低。
|--Set：元素是无序，元素不可以重复。
List：
特有方法。凡是可以操作角标的方法都是该体系特有的方法。
增
add(index,element);
addAll(index,Collection);
删

remove(index);
改
set(index,element);
查
get(index):
subList(from,to);
listIterator();
int indexOf(obj):获取指定元素的位置。
ListIterator listIterator();

List集合特有的迭代器。ListIterator是Iterator的子接口。
在迭代时，不可以通过集合对象的方法操作集合中的元素。因为会发生ConcurrentModificationException异常。
所以，在迭代器时，只能用迭代器的放过操作元素，可是Iterator方法是有限的，只能对元素进行判断，取出，删除的操作，
如果想要其他的操作如添加，修改等，就需要使用其子接口，ListIterator。该接口只能通过List集合的listIterator方法获取。

枚举就是Vector特有的取出方式。枚举和迭代器很像。其实枚举和迭代是一样的。
因为枚举的名称以及方法的名称都过长。所以被迭代器取代了


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

		Enumeration en = v.elements();

		while(en.hasMoreElements())
		{
			System.out.println(en.nextElement());
		}

LinkedList:特有方法：
addFirst();
addLast();
getFirst();
getLast();
获取元素，但不删除元素。如果集合中没有元素，会出现NoSuchElementException
removeFirst();
removeLast();
获取元素，但是元素被删除。如果集合中没有元素，会出现NoSuchElementException
在JDK1.6出现了替代方法。
offerFirst();

offerLast();
peekFirst();
peekLast();
获取元素，但不删除元素。如果集合中没有元素，会返回null。
pollFirst();
pollLast();
获取元素，但是元素被删除。如果集合中没有元素，会返回null。


import java.util.*;
class LinkedListDemo 
{
	public static void main(String[] args) 
	{
		LinkedList link = new LinkedList();

		link.addLast("java01");//添加尾
		link.addLast("java02");//加在java01的后面
		link.addLast("java03");
		link.addLast("java04");

		
		sop(link.getFirst());//头是01
		sop(link.getLast());//尾是04
		
		sop("size="+link.size());

		while(!link.isEmpty())
		{
			sop(link.removeLast());//先把最后一个remove掉，即先输出；倒着输出
		}

	}

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

使用LinkedList模拟一个堆栈或者队列数据结构。
堆栈：先进后出如同一个杯子。
队列：先进先出 First in First out 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.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())
		{
			System.out.println(dl.myGet());
		}
	}
}

定义一个临时容器的方法：


	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;
	}

Set：元素是无序(存入和取出的顺序不一定一致)，元素不可以重复。
|--HashSet:底层数据结构是哈希表。是线程不安全的。不同步。
HashSet是如何保证元素唯一性的呢？
是通过元素的两个方法，hashCode和equals来完成。
如果元素的HashCode值相同，才会判断equals是否为true。
如果元素的hashcode值不同，不会调用equals。
注意,对于判断元素是否存在，以及删除等操作，依赖的方法是元素的hashcode和equals方法。
|--TreeSet：可以对Set集合中的元素进行排序。底层数据结构是二叉树。
保证元素唯一性的依据：compareTo方法return 0.

TreeSet排序的第一种方式：

让元素自身具备比较性。元素需要实现Comparable接口，覆盖compareTo方法。也种方式也成为元素的自然顺序，或者叫做默认顺序。
TreeSet的第二种排序方式。
当元素自身不具备比较性时，或者具备的比较性不是所需要的。这时就需要让集合自身具备比较性。
在集合初始化时，就有了比较方式。

Set集合的功能和Collection是一致的。

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

定义了比较器，将比较器对象作为参数传递给TreeSet集合的构造函数。
当两种排序都存在时，以比较器为主。定义一个类，实现Comparator接口，覆盖compare方法。

泛型：

JDK1.5版本以后出现新特性。用于解决安全问题，是一个类型安全机制。
好处：
1）将运行时期出现问题ClassCastException，转移到了编译时期。方便于程序员解决问题。让运行时问题减少，安全。
2）避免了强制转换麻烦。
泛型格式：通过<>来定义要操作的引用数据类型。
在使用java提供的对象时，什么时候写泛型呢？
通常在集合框架中很常见，只要见到<>就要定义泛型。其实<> 就是用来接收类型的。

当使用集合时，将集合中要存储的数据类型作为参数传递到<>中即可。

泛型类：当类中要操作的引用数据类型不确定的时候，早期定义Object来完成扩展。现在定义泛型来完成扩展。


class Utils<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}

泛型类定义的泛型，在整个类中有效。如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。为了让不同方法可以操作不同类型，而且类型还不确定。那么可以将泛型定义在方法上。
特殊之处：
静态方法不可以访问类上定义的泛型。
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

Map集合：该集合存储键值对。一对一对往里存。而且要保证键的唯一性。
1）添加。
put(K key, V value)
putAll(Map<? extends K,? extends V> m)
2）删除。
clear()
remove(Object key)

3）判断。
containsValue(Object value)
containsKey(Object key)
isEmpty()
4）获取。
get(Object key)
size()
values()
entrySet()
keySet()

Map
|--Hashtable:底层是哈希表数据结构，不可以存入null键null值。该集合是线程同步的。jdk1.0.效率低。
|--HashMap：底层是哈希表数据结构，允许使用 null 值和 null 键，该集合是不同步的。将hashtable替代，jdk1.2.效率高。
|--TreeMap：底层是二叉树数据结构。线程不同步。可以用于给map集合中的键进行排序。
Map和Set很像，Set底层就是使用了Map集合。

map集合的两种取出方式：
1）Set<k> keySet：将map中所有的键存入到Set集合。因为set具备迭代器。所有可以迭代方式取出所有的键，在根据get方法。获取每一个键对应的值。
Map集合的取出原理：将map集合转成set集合。在通过迭代器取出。
2）Set<Map.Entry<k,v>> entrySet：将map集合中的映射关系存入到了set集合中，
而这个关系的数据类型就是：Map.Entry Entry其实就是Map中的一个static内部接口。
定义在内部原因：
因为只有有了Map集合，有了键值对，才会有键值的映射关系。关系属于Map集合中的一个内部事物。
而且该事物在直接访问Map集合中的元素。

把数组变成list集合的好处：
可以使用集合的思想和方法来操作数组中的元素。
注意：将数组变成集合，不可以使用集合的增删方法。因为数组的长度是固定。

将集合变数组的原因：
为了限定对元素的操作。不需要进行增删了。

集合框架的工具类。
Collections:集合框架的工具类。里面定义的都是静态方法。
Collections和Collection的区别：
Collection是集合框架中的一个顶层接口，它里面定义了单列集合的共性方法。
它有两个常用的子接口，
List：对元素都有定义索引。有序的。可以重复元素。
Set：不可以重复元素。无序。
Collections是集合框架中的一个工具类。该类中的方法都是静态的
提供的方法中有可以对list集合进行排序，二分查找等方法。
通常常用的集合都是线程不安全的。因为要提高效率。
如果多线程操作这些集合时，可以通过该工具类中的同步方法，将线程不安全的集合，转换成安全的。

高级for循环格式：
for(数据类型变量名 : 被遍历的集合(Collection)或者数组)
{

}
对集合进行遍历。只能获取集合元素。但是不能对集合进行操作。迭代器除了遍历，还可以进行remove集合中元素的动作。
如果是用ListIterator，还可以在遍历过程中对集合进行增删改查的动作。
传统for和高级for的区别：
高级for有一个局限性。必须有被遍历的目标。
建议：在遍历数组的时候，还是希望是用传统for。因为传统for可以定义脚标。

JDK1.5版本出现的新特性：方法的可变参数。
在使用时注意：可变参数一定要定义在参数列表最后面。

可变参数：其实就是上一种数组参数的简写形式，不用每一次都手动的建立数组对象。只要将要操作的元素作为参数传递即可。
隐式将这些参数封装成了数组。

StaticImport 静态导入。
当类名重名时，需要指定具体的包名。
当方法重名是，指定具备所属的对象或者类。


import java.util.*;
import static  java.util.Arrays.*;//导入的是Arrays这个类中的所有静态成员。
import static java.util.Collections.*;
import static  java.lang.System.*;//导入了System类中所有静态成员。