Java基础15--集合框架

15-1，集合框架-概述

1，集合类的由来：

对象是用于封装特有数据的，对象多了就需要存储起来，如果对象的个数不确定，就使用集合容器进行存储。

2，集合特点：

(1)用于存储对象的容器。

(2)集合的长度是可变的。

(3)集合中不可以存储基本数据类型值。

 

15-2，集合框架-体现&共性功能

1，集合容器因为内部的数据结构不同，有多种具体容器，不断向上抽取，就形成了集合框架。

2，框架的顶层Collection接口：

Collection的常见方法：

(1)添加：

boolean add(Object obj);

boolean addAll(Collection coll);

(2)删除：

boolean remove(Object obj);

boolean removeAll(Collection coll);

void clear();//清空

(3)判断：

boolean contains(Object obj);

boolean containsAll(Collection coll);

boolean isEmpty();//判断是否为空

(4)获取：

int size();//获取大小

Iterator iterator();//取出元素的方式，迭代器

(5)其他：

boolean retainAll(Collection coll);//取交集

Object[] toArray();//将集合转成数组

 

15-3，方法演示

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
	public static void main(String[] args) {
		//Collection为接口，不能new接口，这里需要new一个实现了Collection接口的非抽象类。
		Collection coll = new ArrayList();
		show(coll);
	}
	public static void show(collection coll) {
		//1.添加元素
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		System.out.println(coll);
		//2.删除元素
		coll.remove("abc2");//会改变集合的长度
		//3.非空集合
		coll.clear();
		System.out.println(coll.contains("abc3"));//判断是否包含abc3
	}
}

 

15-4，方法演示2

import java.util.ArrayList;
import java.util.Collection;
public class CollectionDemo {
	public static void main(String[] args) {
		Collection c1 = new ArrayList();
		Collection c2 = new ArrayList();
		show(c1,c2);
	}
	public static void show(Collection c1,Collection c2) {
		//给c1添加元素
		c1.add("abc1");
		c1.add("abc2");
		c1.add("abc3");
		c1.add("abc4");
		//给c2添加元素
		c2.add("abc2");
		c2.add("abc5");
		c2.add("abc6");
		System.out.println("c1 = " + c1);
		System.out.println("c2 = " + c2);
		//演示addAll
		c1.addAll(c2);//将c2中的元素添加到c1中
		//演示removeAll
		boolean b = c1.removeAll(c2);//将两个集合中相同的元素从c1中删除
		System.out.println("b = " + b);
		//演示containsAll
		boolean b1 = c1.containsAll(c2);//是否包含c2的所有元素
		System.out.println("b1 = " + b);
		//演示retainAll
		boolean b2 = c1.retainAll(c2);//取交集，保留和指定集合相同的元素
		System.out.println("b2 = " + b2);
		System.out.println("c1 = " + c1);
	}
}

 

15-5，迭代器使用

通过Iterator来迭代获取集合中的对象，通过集合对象获取其迭代器对象，以示例说明：

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
public class IteratorDemo {
	public static void main(String[] args) {
		Collection coll = new ArrayList();
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		coll.add("abc4");
		System.out.println(coll);
		/*
		这里使用了Collection中的iterator()方法，调用集合中的迭代器方法
		是为了获取集合中的迭代器对象
		*/
		//这种方式获取的迭代器，在循环结束后，变量it仍然占用内存，若循环结束后仍然使用it，则使用这种方式
		Iterator it = coll.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//下面这种方式一般比较常用，it为局部变量，循环结束后自动释放空间
		for(Iterator it = coll.iterator();it.hasNext();) {
			System.out.println(it.next());
		}
	}
}

 

15-6，迭代器原理

Iterator iterator();迭代器，一种取出元素的方式。

这个迭代器对象必须依赖于具体的容器，因为每一个集合数据结构都不同，所以该迭代器对象是在容器中进行内部实现的。查其源码，会发现他的实现是内部类的形式。

对于容器实现者而言，具体的实现不重要，只要通过容器获取到该实现的迭代器对象即可，也就是iterator方法。

Iterator接口就是对所有的Collection容器进行元素取出的公共接口，其实他就是抓娃娃机中的那个夹子，我们只需要投币，操作摇杆即可，并不需要知道里面的夹子是如何工作的，但是由于每个抓娃娃机的内部结构不同，里面的夹子的抓法也不同，但是对于外面操作的我们来说，都只是操作摇杆。

 

15-7，集合框架-List和Set的特点

1，Collection有两个已实现的子接口较为常用，List(列表)和Set(集)。

2，特点：

Collection

 |--List(列表)：有序(存入和取出的顺序一致)；元素内有索引(角标)；元素可以重复。

 |--Set(集)：元素不能重复，无序。

 

15-8，List的常见方法

1，List特有的常见方法，有一个共性的特点就是操作角标。

(1)添加：

void add(index,element);//在指定位置添加一个元素

void add(index,collection);//在指定位置添加一堆元素

(2)删除

Object remove(index);//返回被删除的元素

(3)修改

Object set(index,element)//返回被修改的元素

(4)获取

Object get(index);

int indexOf(object);

int lastIndexOf(object);

List subList(from, to);//返回一个区间的元素，包括from不包括to

2，演示

import java.util.ArrayList;
import java.util.List;
public class ListDemo {
	public static void main(String[] args) {
		List list = new ArrayList();//ArrayList也是List的子接口
		show(list);
	}
	public static void show(List list) {
		//添加元素
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		System.out.println(list);
		//插入元素
		list.add(1,"abc9");
		//删除元素
		System.out.println("remove:" + list.remove(2));
		//修改元素
		System.out.println("set:" + list.set(1,"abc8")); //返回abc2，返回被修改的元素
		//获取元素
		System.out.println("get:" + list.get(0));//abc1
		//获取子列表
		System.out.println("sublist:" + list.subList(1,2));//返回abc2，包含头不包含尾
	}
}

 

15-9，ListIterator接口

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
public class ListDemo {
	public static void main(String[] args) {
		List list = new ArrayList();
		//show(list);
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		list.add("abc4");
		System.out.println("list" + list);
		ListIterator it = list.listIterator();//获取列表迭代器对象
		//它可以实现在迭代过程中完成对元素的增删改查
		//注意：只有list集合具备该迭代功能
		while(it.hasNext()) {
			Object obj = it.next();
			if(obj.equals("abc2")) { //如果是abc2则改为abc9
				it.set("abc9");
			}
		}
		//System.out.println("hasNext:" + it.hasNext()); //下一个元素
		//System.out.println("hasPrevious:" + it.hasPrevious()); //前一个元素
		while(it.hasPrevious()) {
			System.out.println("previous : " + it.previous());
		}
		System.out.println("list:" + list);
		/*
		Iterator it = list.iterator();
		while(it.hasNext()) {
			/*
			java.util.ConcurrentModificationException，在迭代器过程中，
			不要使用集合操作元素，容易出现异常，可以使用Iterator接口的子接口
			ListIterator来完成在迭代中对元素进行更多的操作。
			*/
			Object obj = it.next();
			if(obj.equals("abc2")) {
				list.add("abc9");
			} else {
				System.out.println("next:" + obj);
			}
		}
		System.out.println(list);
		*/
	}
	public static void show(List list) {
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		list.add("abc4");
		Iterator it = list.iterator();
		while(it.hasNext()) {
			System.out.println("next:" + it.next());
		}
		//list特有的取出元素的方式之一
		for(int x=0;x<list.size();x++) {
			System.out.println("get:" + list.get(x));
		}
	}
}

在用/* ... */注释掉的内容中，it是Iterator对象，list是List对象，两个对象同时操作可能会引发异常，它上面的方法用的是ListIterator来获取列表迭代器对象，可以用List中的listIterator方法来获取。如：ListIterator it = list.listIterator();方法获取了list列表的列表迭代器对象it，可以用it直接对list中的元素操作，就不会出现异常，因为都是在列表下操作的对象，不涉及操作的并发问题。

 

15-10，List常用子类的特点

1，List：

    |--Vector：内部是数组数据结构，是同步的，增删，查询都很慢。

    |--ArrayList：内部是数组数据结构，是不同步的，替代了Vector，查询的速度很快。

    |--LinkedLst：内部是链表数据结构，是不同步的，增删元素的速度很快。

2，ArrayList：

如果要删除b，则b删除后其后面的元素都要向前移动，若加入一个进来，要将插入位置的后面的元素都向后移动一格，才能插入，牵一发而动全身，增删效率差。

 

LinkedList：（链表）

加入a的地址为22，b的地址为33，c的地址为44，a中的指针为33，将a和b链接起来，b中的指针是44，将b和c链接起来。若要删除b，直接将c的地址44记录到a中替换掉33就可以了；若要把b加入，将b的33记录到a中，c的44记录到b中即可，增删块，但是查询不方便。

 

15-11，数组和链表

ArrayList为什么查询快？

因为ArrayList底层为数组结构，有角标，在堆中是一片连续的内存空间，用角标查询速度快。

 

LinkedList为什么查询慢？

因为LinkedList底层是链表结构，虽然也有角标，但他不是连续的内存空间，查询是仍需要通过内存地址查询，效率低。