黑马程序员————Java基础日常笔记---对集合的理解与总结一

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

黑马程序员————Java基础日常笔记---对集合的理解与总结一

1，集合框架——集合体系
首先需要了解集合类，

为什么会有集合类？
面向对象语言对事物的出现都是以对象的形式，所以为了方便对多个对象的操作，就对对象进行存储，集合就是存储对象最常用
的一种方式。

数组和集合类都是容器， 有什么不同？
a，数组虽然也可以存储对象， 但是长度是固定的， 集合的长度是可变的， 
b，数组中可以存储基本数据类型，只能存储一种数据类型， 这对泛型的出现提供了思路；而集合只能存储对象。

集合类的特点：
集合只用于存储对象， 集合长度可变，集合可以存储不同类型的对象。
所以他的应用更广泛。
集合作为一个容器， 而容器如同水杯，水杯有不同的形状来存储对象，
但是集合（水杯）却有共同的属性和功能， 因此进行不断的共性抽取， 从而产生了一个体系，就叫做集合框架。

 

为什么会出现这么多的容器， 而不把这些对象放到一个容器中呢？
因为每个容器对数据的存储方式都有不同， 这个存储方式称之为：数据结构。

集合框架的构成及分类：

2，集合框架—共性方法

需要了解集合类， 首先需要了解集合的方法， 由于Colection是接口， 其中的方法都是向上抽取的方法， 因此需要先了解：

2.1 添加元素:

 boolean add(E e) :确保此 collection 包含指定的元素（可选操作）。

 boolean addAll(Collection<? extendsE> c) 将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。

2.2 删除元素：

 void clear() 移除此 collection 中的所有元素（可选操作）。

 boolean remove(Object o) 从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。

boolean removeAll(Collection<?> c) 移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。

2.3 判断

boolean contains(Object o) 如果此 collection 包含指定的元素，则返回 true。

boolean containsAll(Collection<?> c) 如果此 collection 包含指定 collection 中的所有元素，则返回true。

boolean equals(Object o) 比较此 collection 与指定对象是否相等。

boolean isEmpty() 判断是否为空

2.4 获取：

 int size() 返回此 collection 中的元素数。

 int hashCode() 返回此 collection 的哈希码值。


 Iterator<E> iterator() 获取集合中的元素

boolean retainAll(Collection<?> c) 取交集，


2.5 集合变数组：

<T> T[]  toArray(T[] a) 返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。

有了这些方法， 实现这个接口的子接口， 都需要实现这些方法， 并可以使用

3，List集合

List集合他继承了Collection接口， 因此上面的共性方法这个集合都可以用， 而且在这个集合中也重载了一些属于自己的特有的方法， 

3.1，添加，

 不多说如图：

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

b, 集合中存储的都是对象的引用（地址）。

特有的方法： 

 void add(int index,E element) 在列表的指定位置插入指定元素

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


3.2 删除元素：

同父类的方法，

3,.3 判断

3.4 获取：

E get(int index) 返回列表中指定位置的元素。

int indexOf(Object o)根据对象查找索引


List<E> subList(int fromIndex, int toIndex) 获取子集合


<T> T[]  toArray(T[] a) 将集合变成数组

 Iterator<E> iterator()

List集合中特有的迭代器：ListIterator<E> listIterator()


3.5 修改：

E set(int index, E element) 




4 集合框架-迭代器 

首先什么是迭代器？

其实就是集合的取出元素的方式。叫迭代动作。

迭代器的由来：

由于数据结构不同， 所以数据存取的方式不同， 实现方法不同，一个取值的方式不足以用一个方法来描述；

首先要判断是否有元素，

然后需要对元素的取出， 但是集合中取出不止一个动作，所以就把取出的动作封装成了一个对象。

因此容器中， 就有一个取出的对象，

由于数据存取的方式不同， 实现取出的方法不同，所以这个取出就需要被描述一下，需要通过一个类来完成，而这个类定义在集合的内部，原因？

因为元素在集合中，操作的是元素，定义在内部， 是最方便取出元素的， 这个内部类对取出动作的定义。

接口 Iterator<E> 集合元素取出，并操作元素

他定义在集合的内部， 集合中提供了对外暴露的方法，返回类型是Iterator。

Iterator<T> it=集合.iterator().

接口的引用，指向这个接口的子类对象，这个对象不是new出来的， 而是通过集合中的方法获取的，

而每个容器中， 都有这个内部类，以后也产生容器，容器中也要定义这个内部类， 那么这些东西都有一个共性，在取出元素的时候， 一般都会做的动作：

1，有没有元素，判断

2，有的话， 取出来，两个动作，

判断， 取出，依赖于每个容器内部的数据结构， 所以就把取出方式定义在集合的内部；

如图：

因此这些内部类都符合一个规则，该规则是Iterator，如何获取集合的取出对象？

通过一个对外提供的方法：iterator(),因此就统一了集合的取出方式。

形象比喻：迭代器就是取布娃娃机器的那个夹子。

4.1 ListIterator------列表迭代器

当方法检测到对象的并发修改，但不允许这种修改是， 抛出此异常。

这两种方式操作的是同一组元素，产生的问题是迭代器在进行取出的操作中，又换了集合的功能在操作元素，就可能产生安全隐患（并发（同时）访问）。

但是可以将元素移除， remove.

所以这样的迭代器是有局限性的，

因此引出

接口 ListIterator<E>

这样就可以对集合进行操作了，

枚举：Vector集合中的迭代方法，类似于Iterator，

5 LinkedList中特有方法，共性方法参照List,

5.1,添加：

 void addFirst(E e) 将指定元素插入此列表的开头。 boolean offerFirst(E e)

 void addLast(E e) 将指定元素插入此列表的开头。boolean offerLast(E e)


5.2 获取

E getFirst()返回此列表的第一个元素。
E getLast() 返回此列表的最后一个元素。


E peekFirst() 获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。
E peekLast() 获取但不移除此列表的最后一个元素；如果此列表为空，则返回null。
5.3 移除

E removeFirst()移除并返回此列表的第一个元素 E peekFirst()


E removeLast() 移除并返回此列表的最后一个元素。E peekLast()





总结：

List集合中具体对象的特点：

List:

|-----ArrayList:底层的数据结构使用的是数组结构，有角标，

特点：查询速度很快，但是增删稍慢，线程不同步

|-----LinkedList:底层的数据结构使用的是链表结构，

特点： 增删 很快，但是 查询速度 稍慢，线程不同步

|-----Vector:底层的数据结构使用的是数组结构，线程同步，被ArrayList替代了，

ArryaList长度超过了10的话， new 一个新的，按50%延长，把旧的copy到新的， 后面再添加。可变长度数组。

Vector,是10， 超过了，就100%延长，变成20数组。

这样15好，因为又可以延长， 而且节省空间。

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

代码如下：

<span style="font-family:Microsoft YaHei;font-size:14px;">//使用LinkedList模拟一个堆栈或者队列的数据结构
/*
堆栈：先进后出 如同一个杯子
队列：先进先出 First in First out,如同一个水管。
两种数据结构。
*/
import java.util.*;
class DuiLie
{
	private LinkedList link;
	DuiLie(){
		link=new LinkedList();
	}
	//增加元素
	public void myAdd(Object obj){
		link.addFirst(obj);
	}
	//获取元素
	public Object myGet(){//这里的是Object类
		return link.removeLast();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class DuiZhan
{
	private LinkedList link;
	DuiZhan(){
		link=new LinkedList();
	}
	//增加元素
	public void myAdd(Object obj){
		link.addFirst(obj);
	}
	//获取元素
	public Object myGet(){//这里的是Object类
		return link.removeFirst();
	}
	public boolean isNull(){
		return link.isEmpty();
	}
}
class LinkedListExam 
{
	public static void main(String[] args) 
	{
		DuiZhan dz=new DuiZhan();
		dz.myAdd("java01");
		dz.myAdd("java02");
		dz.myAdd("java03");
		dz.myAdd("java04");
		while(!dz.isNull()){
			sop(dz.myGet());
		}
		sop(dz);//这里得到的是这个容器的地址值
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}</span><span style="font-size:24px;">
</span>

7 去除ArrayList集合中的字符串类型的重复元素

代码如下：

<span style="font-family:Microsoft YaHei;">//去除ArrayList集合中的重复元素
/*
	思路：
		1,定义一个方法， 将含有重复元素的集合作为参数传递进来，
		2，然后在这个方法中，在新建一个临时的容器来存放没有重复的元素，
		3，遍历，调用contains方法，看是否是重复的， 
		4，contains方法底层调用的是equals方法。
*/
import java.util.*;
class ListArrayTest 
{
	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;
	}
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		al.add("java01");
		al.add("java01");
		al.add("java02");
		al.add("java02");
		al.add("java03");
		al.add("java01");
		al.add("java04");
		al.add("java04");
		sop(al);
		al=singleElement(al);
		sop(al);
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}</span>

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

<span style="font-family:Microsoft YaHei;">//去除ArrayList集合中的重复自定义对象元素
//存人这个对象，同姓名同年龄，视为同一个人，
//因此需要修改这个类中的equals方法，
import java.util.*;
class Person
{
	private String name;
	private int age;
	Person(String name,int age){
		this.name=name;
		this.age=age;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Person)){
			return false;
		}
		Person p=(Person)obj;//这里需要强转，得到的Object对象中没有人这个类的特有方法
		System.out.println(this.name+"。。。"+p.name);
		return this.name.equals(p.name)&&(this.age==p.age);
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
}
class ListArrayTest1 
{
	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)){//这个方法底层会自动调用该对象的equals方法
				newAl.add(obj);
			}
		}
		return newAl;
	}
	public static void main(String[] args) 
	{
		ArrayList al=new ArrayList();
		al.add(new Person("lisi01",11));//add(Object obj),obj=new Person("sss",11);
		al.add(new Person("lisi02",12));
		al.add(new Person("lisi03",13));
		al.add(new Person("lisi03",13));
		al.add(new Person("lisi05",15));

		al=singleElement(al);

		Iterator it=al.iterator();
		while(it.hasNext()){//it.next(), 得到的是Object,如果需要得到， 则要向下强转
			Person p=(Person)it.next();
			sop(p.getName()+"..."+p.getAge());
		}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}</span>

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