08.集合框架（一）【集合概述】【接口Collection，Iterator,List,ListIterator】【类LinkedList,ArrayList】

最新推荐文章于 2023-09-10 21:10:19 发布

炳烛以期明

最新推荐文章于 2023-09-10 21:10:19 发布

阅读量815

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/u011374699/article/details/13625921

版权

Java 专栏收录该内容

29 篇文章 1 订阅

订阅专栏

一．集合概述

1. 集合类的由来

对象用于封装特有数据，对象多了需要存储，如果对象个数不确定，就使用集合容

器进行存储。

2. 集合的特点（集合与数组的区别）

1）集合是用于存储对象的容器，存储的对象可以是不同的引用数据类型

数组既可以存储基本数据类型，也可以存储引用数据类型。

2）集合的长度可变

数组的长度是固定的

3）集合不能存储基本数据类型值，只能存储引用数据类型

数组只能存储同一个数据类型的值

3. 集合框架

集合容器因为内部的数据结构（对数据的存储方式）不同，于是就产生了多重具体容器。不断的向上抽取，就形成了集合框架。

二．Collection接口

1. Collection

Collection接口在整个集合框架中处于顶层位置。它是底层不断向上抽取而得的。

Collection接口还有很多子接口，常用的子接口有两个：

List：有序的Collection（也称为序列）。可以存储重复元素，每个元素都有索引。

所谓有序，并不是从大到小或者从小到大排列，而是元素存储顺序和取出顺序

一致。

Set：无序。不可以存储重复元素。因为必须要保证元素的唯一性。

2. Collection接口的常用方法

1）添加

boolean add(E e)：往集合中添加一个元素。

boolean add(Collection<? extends E> c)：将指定集合的所有元素添加到此集合中。

2）删除

void clear():删除此集合中所有的元素。

boolean remove(Objeact o):从集合中删除某一个元素。

boolean removeAll(Collection<?> c):删除此集合中那些包含在指定集合中的元素。

3）判断

boolean contains(Object o):此集合中是否包含指定元素。

boolean containsAll(Collection<?> c):此集合中是否包含指定集合的所有元素。

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

4）获取

int size():获取此集合中的元素个数。

例子：

import java.util.ArrayList;
import java.util.Collection;

public class CollectionDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Collection coll = new ArrayList();
				
		
		show(coll);
		
		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);//将两个集合中的相同元素从调用removeAll的集合中删除。
//		System.out.println("removeAll:"+b);
		
		//演示containsAll
//		boolean b = c1.containsAll(c2);
//		System.out.println("containsAll:"+b);
				
		//演示retainAll
		boolean b = c1.retainAll(c2);//取交集，保留和指定集合相同的元素
										//和removeAll功能相反。
		
		System.out.println("c1:"+c1);
		

		
		
		
		
	}
	
	
	public static void show(Collection coll){
		
		//1.添加元素。add
		coll.add("abc1");
		coll.add("abc2");
		coll.add("abc3");
		
		System.out.println(coll);//变成字符串输出
		
		
		//2.删除元素。remove
//		coll.remove("abc2");//会改变集合的长度。
//		coll.clear();
		
		System.out.println(coll.contains("abc3"));
		
		System.out.println(coll);
		
		
	}
	
}

三．Iterator接口

1.迭代器

此接口就是一个迭代器，用于对集合进行迭代。简单说，就是集合取出元素的方法。

2.迭代器的由来

集合通常将元素的取出方式定义在集合内部，这样方便访问集合的元素，所以取出方式通常被定义内部类。不同的具体的集合容器，其数据结构不同，导致取出元素的方式也不一样。将不同集合中取出方式的共性内容向上抽取，得到Iterator。

3. 迭代器的方法

booleanhasNext():如果仍有元素可以迭代，则返回true。

Enext():返回下一个迭代的元素。

voidremove():从迭代器指向的集合中移除迭代器返回的最后一个元素。

4. 循环迭代时用while循环还是for循环？

用while循环：迭代完之后，迭代器没有被释放，会占内存。

使用范围：如果你还想用这个迭代器，那么就用while循环。

用for循环:for循环结束后，迭代器也跟着被释放。

使用范围：开发时用for循环，节省内存。

5. 使用迭代器的注意事项

1）迭代器在Collection接口中是通用的，它替代了枚举（Enumeration）。

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

3） Next()方法返回值类型是Object，使用时要记得类型转换。

例子：

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中的iteractor()方法，调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
//		Iterator it = coll.iterator();
		
//		while(it.hasNext())//使用hasNext方法,避免异常。
//			System.out.println(it.next());
		
		/*
		 * 但是，while循环，it迭代器没有消失。而且里面为空。占内存，
		 * 如果你还想用这个迭代器，那么就 用while循环。
		 * 否则，就用for循环。for循环结束后，迭代器也跟着消失。
		 * 开发时用for循环。
		 */
		
		for (Iterator it = coll.iterator();it.hasNext(); ) {
			
			System.out.println(it.next());
			
		}
		
	}

}

四．List接口

1. List子体系

List：有序的Collection（也称为序列）。可以存储重复元素，每个元素都有索引。

凡是可以操作角标的，就用list。

list集合是可以完成对元素的增删改查。

2. 实现List接口的常用子类

List:

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

|--ArrayList：内部是数组数据结构，是不同步的。效率高，替代了Vector。多线

程的时候，把方法都放到同一个锁就行了查询的速度快。

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

3. List的常见特有方法：共性的特点就是可以操作角标。

1）添加

voidadd(index,element);添加元素到指定位置。

voidadd(index,collection);添加指定集合中的元素到指定位置。

2）删除

Objectremove(index);删除指定位置的元素。

3）修改

Objectset(index,element);修改指定位置的元素。

4）获取

Objectget(index);根据角标获取元素。

int indexOf(object);根据元素获取第一次出现的角标。没有该元素，返回-1.

int lastIndexOf(object);获取元素最后出现的位置。

ListsubList(from,to);获取列表中指定的from(包括)和to（不包括）之间

的元素。

5）listIterator();List特有的迭代器。封装了多个方法，避免了迭代时操作动作的局

限。

Tip：List集合判断元素是否相同，移除等操作，底层调用的是equals方法。

例子：

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

public class ListDemo2 {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		List list = new ArrayList();
//		show(list);
		
		list.add("abc1");
		list.add("abc2");
		list.add("abc3");
		
		ListIterator it = list.listIterator();
		/*
		 * 获取列表迭代器对象
		 * 迭代器本身只有获取，判断，删除三个方法。但是列表迭代器接口里包含了列表的增删查改等操作。
		 * 所以它可以实现迭代过程中完成对元素的增删查改。
		 * 
		 * 注意：只有list集合具有该迭代功能。
		 */
		
		while(it.hasNext()){
			
			Object obj = it.next();
			
			if(obj.equals("abc2")){
				it.set("abc99");
			}
		}
		System.out.println(list);
		
//		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()){
			
			Object obj = it.next();//java.util.ConcurrentModificationException
							//发生了并发修改，抛出此异常。
							//在迭代器过程中，不要使用集合操作元素，容易出现异常。
						//可以使用Iterator接口的子接口ListIterator来完成在迭代中对元素进行更多的操作。 
			
			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());
		
		for(int i = 0;i<list.size();i++){
			
			System.out.println("get:"+list.get(i));
			
		}
		
	}
}

五．ListIterator接口

1. ListIterator的由来

ListIterator是List集合特有的迭代器，是Iterator的子接口。

Iterator在迭代Collection集合时，只能判断，取出，删除元素，如果要添加元素等操作，很容易造成并发修改，并抛出ConcurrentModificationException异常。为了能

在迭代List集合时实现更多的操作，于是就抽取形成了ListIterator接口。

2. ListIterator接口特有的方法

add(obj)添加

set(obj)修改为指定元素

hasPrevious()判断之前有没有元素

previous()获取前一个元素

六．枚举接口（Enumeration）

Enumeration接口和Iterator接口的功能是一样的，只不过Iterator接口方法名比较

短，实现时优先考虑用Iterator接口。

例子：枚举和Iterator接口

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

public class VectorDemo {
	/*
	 * Enumeration接口和Iteractor接口的功能是重复的。只不过Iteractor接口
	 * 方法名比较短，实现时应优先考虑使用Iteractor接口。
	 */
	public static void main(String[] args) {

		Vector v = new Vector();
		
		v.addElement("abc1");
		v.addElement("abc2");
		v.addElement("abc3");
		v.addElement("abc4");
		
		//Enumeration接口
		Enumeration en = v.elements();
		while(en.hasMoreElements()){			
			System.out.println("next element:"+en.nextElement());			
		}
		
		//Iterator接口
		Iterator it = v.iterator();
		while(it.hasNext()){			
			System.out.println("next:"+it.next());			
		}	
	}
}

七．LinkedList类

LinkedList实现了List接口，其数据结构为链表。

特点：增删速度快，查询稍慢。

1.方法

1）添加

addFirst();

addLast();

2）获取

getFirst();//获取但不移除，如果链表为空，抛出NoSuchElementException

getLast();

3）删除

removeFirst();//获取并移除，如果链表为空，抛出NoSuchException

removeLast();

2.1.6之后的新方法

1）添加

offerFirst();

offerLast();

2）获取

peekFirst();//获取但不移除，如果链表为空，返回null。

peekLast();

3）删除

pollFirst();//获取并移除，如果链表为空，返回null。

pollLast();

例子：

import java.util.LinkedList;

/*
 * 请使用LinkedList来模拟一个堆栈或者队列数据结构。
 * 
 * 堆栈：先进后出。First In Last Out  FILO
 * 		
 * 队列：先进先出。First In First Out  FIFO
 * 		例子：公交车，上车往后走，先上车，先到后门下车。
 * 我们应该描述这样一个容器，给使用者提供一个容器对象完成这两种结构中的一种。
 */
 
public class LinkedTest {

	public static void main(String[] args) {
		
		DuiLie dl = new DuiLie();
		
		dl.myAdd("add1");
		dl.myAdd("add2");
		dl.myAdd("add3");
		dl.myAdd("add4");
		dl.myAdd("add5");
		
		while(!dl.isNull()){
			System.out.println(dl.myGet());
		}
		System.out.println(dl.isNull());
	}
}

DuiLie类

import java.util.LinkedList;

/*
 * 队列（或者堆栈）结构。
 */
public class DuiLie{
	
	private LinkedList link;
	DuiLie(){
		link = new LinkedList();
	}
	
	//添加元素方法
	public void myAdd(Object obj){
		link.addFirst(obj);//从头添加。
	}
	
	//获取元素方法
	public Object myGet(){
		return link.removeLast();//先进先出，队列
	//	return link.removeFirst();//先进后出，堆栈。
	}
	
	//判断是否为空
	public boolean isNull(){
		return link.isEmpty();
	}
}

八．ArrayList类

ArrayList：内部是数组数据结构，是不同步的。效率高，替代了Vector。多线程的时候，把方法都放到同一个锁就行了，查询的速度快。

如果添加或者删除元素，列表长度会改变，其他元素也跟着动。

方法和列表的方法基本相同。

举一个例子：

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

import cn.itcast.p.bean.Person;

public class ArrayListTest {

	public static void main(String[] args) {

		ArrayList al = new ArrayList();
		al.add(new Person("lisi1",21));
		al.add(new Person("lisi2",22));
		al.add(new Person("lisi3",23));
		al.add(new Person("lisi4",24));
		
		Iterator it = al.iterator();
		while(it.hasNext()){
			
//			System.out.println(((Person) it.next()).getName()+"..."+((Person) it.next()).getAge());
		/*
		 * 不要在循环语句里调用两次next(),它会自动往下走，操作的将不是同一个对象，结果出错。
		 * 既然要对一个对象进行多步操作，可以给对象起个名字，方便操作。
		 * 
		 * 注意：
		 * 存自定义对象的时候，一定要考虑到取出动作：强转。
		 * 不强转的话，自动变成字符串输出。有的字符串没有定义字符串方法，会调用父类的toString方法，
		 * 打印的是类型+哈希值。这样没有意义。
		 */
		
		//向下转型，才能使用Person子类的特有方法。
		Person p = (Person) it.next();
		System.out.println(p.getName()+"..."+p.getAge());
		
		}
		
//		al.add(5);//al.add(new Integer(5));自动装箱。
					//装箱：基本数据类型赋值给引用数据类型时会自动装箱，其实就是多态。
					//拆箱：基本数据类型和引用数据类型同时参与运算时。	
	}
}