JAVA 常见的类集之Collection&List&Queue

最新推荐文章于 2023-03-05 21:17:22 发布

weixin_34168700

最新推荐文章于 2023-03-05 21:17:22 发布

阅读量138

点赞数

文章标签： java 数据结构与算法 python

原文链接：https://my.oschina.net/u/3544533/blog/1830428

版权

2019独角兽企业重金招聘Python工程师标准>>>

今天回顾类集的基本内容：

(一). 类集

实际上就是一个动态的对象数组，与一般的对象数组不同，类集中的对象内容可以任意扩充。

类集的特征：

1.这种框架是高性能的；

2.框架必须允许不同类型的类集以相同的方式和高度互操作方式工作；

3.类集必须是容易扩展和修改的。

（二）类集框架主要接口

No	接口	描述
1	Collection	是存放一组单值的最大接口，所谓的单值是指集合中的每个元素都是一个对象。一般很少会直接使用此接口直接操作。
2	List	是Collection接口的子接口，也是最常用的接口，此接口对Collection接口进行了大量的扩充，里面的内容是允许重复的。
3	Set	是Collection接口的子类，没有对Collection接口进行扩充，里面不允许存放重复内容。
4	Map	Map是存放一对值的最大接口，即，接口中的每个元素都是一对，以keyvalue的形式保存。
5	Iterator	集合的输出接口，用于输出集合中的内容，只能进行从前到后的单向输出。
6	ListIterator	是Iterator的子接口，可以进行双向输出。
7	Enumeration	是最早的输出接口，用于输出指定集合中的内容。
8	SortedSet	单值的排序接口，实现此接口的集合类，里面的内容是可以排序的，使用比较器排序。
9	SortedMap	存放一对值的排序接口，实现此接口的集合类，里面的内容按照key排序，使用比较器排序。
10	Queue	队列接口，此接口的子类可以实现队列操作。
11	Map.Entry	Map.Entry的内部接口，每个Map.Entry对象都保存着一对keyvalue的内容，每个Map接口中都保存多个Map.Entry接口实例。

（三）接口的继承关系

Collection接口:

Map接口：

（四）接口介绍

4.1 Collection接口

4.1.1 Collection接口的定义

Collection是保存单值集合的最大父接口。 Collection接口定义： public interface Collection<E> extends Iterable<E> JDK 1.5之后为Collection接口增加了泛型声明。

4.1.2 Collection接口的方法定义

No.	方法	类型	描述
1	public boolean add(E o)	普通	向集合中插入对象
2	public boolean addAll(Collection<? extends E> c)	普通	将一个集合的内容插入进来
3	public void clear()	普通	清除此集合中的所有元素
4	public boolean contains(Object o)	普通	判断某一个对象是否在集合中存在
5	public boolean containsAll(Collection<?> c)	普通	判断一组对象是否在集合中存在
6	public boolean equals(Object o)	普通	对象比较
7	public int hashCode()	普通	哈希码
8	public boolean isEmpty()	普通	集合是否为空
9	public Iterator<E> iterator()	普通	为Iterator接口实例化
10	public boolean remove(Object o)	普通	删除指定对象
11	public boolean removeAll(Collection<?> c)	普通	删除一组对象
12	public boolean retainAll(Collection<?> c)	普通	保存指定内容
13	public int size()	普通	求出集合的大小
14	public Object[] toArray()	普通	将一个集合变为对象数组
15	public <T> T[] toArray(T[] a)	普通	指定好返回的对象数组类型

4.1.3 Collection接口的使用注意

在一般的开发中，往往很少去直接使用Collection接口进行开发，而基本上都是使用其子接口。子接口主要有：List、Set、Queue、SortedSet。

4.1.4 Collection子接口的定义

Collection接口虽然是集合的最大接口，但是如果直接使用Collection接口进行操作的话，则表示的操作意义不明确，所以在JAVA开发中已经不提倡直接使用Collection接口了，主要的子接口如下：

List接口：可以存放重复的内容。

Set接口：不能存放重复的内容，所有的重复内容是靠hashCode()和equals()两个方法区分的。

Queue：队列接口。

SortedSet接口：可以对集合中的数据进行排序。

4.2 List接口

4.2.1List接口

List接口是Collection的子接口，里面可以保存各个重复的内容，此接口的定义如下： public interface List<E> extends Collection<E>

4.2.2 List接口的扩展方法

No.	方法	类型	描述
1	public void add(int index, E element)	普通	在指定位置增加元素
2	public boolean addAll(int index, Collection<? extends E> c)	普通	在指定位置增加一组元素
3	E get(int index)	普通	返回指定位置的元素
4	public int indexOf(Object o)	普通	查找指定元素的位置
5	public int lastIndexOf(Object o)	普通	从后向前查找指定元素的位置
6	public ListIterator<E> listIterator()	普通	为ListIterator接口实例化
7	public E remove(int index)	普通	按指定的位置删除元素
8	public List<E> subList(int fromIndex, int toIndex)	普通	取出集合中的子集合
9	public E set(int index, E element)	普通	替换指定位置的元素

4.2.3 List接口的常用子类 —— ArrayList

ArrayList是List子类，可以直接通过对象的多态性，为List接口实例化此类的定义如下：

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable

AbstractList类的定义如下：

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E>

实例操作一：向集合中增加元素

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
public class ArrayListDemo01 {
	public static void main(String[] args) {
		List<String> allList = null ;		// 定义List对象
		Collection<String> allCollection = null ;// 定义Collection对象
		allList = new ArrayList<String>(); // 实例化List对象，只能是String类型
		allCollection = new ArrayList<String>(); // 实例化Collection，只能是String类型
		allList.add("Hello"); 		// 从Collection继承的方法
		allList.add(0, "World");		// 此方法为List扩充的方法
		System.out.println(allList);		// 输出集合中的内容
		allCollection.add("Hello");		// 增加数据
		allCollection.add("Everyone");	// 增加数据
		allList.addAll(allCollection);	// 从Collection继承的方法，增加一组对象
		allList.addAll(0, allCollection);	// 此方法List自定义的，增加一组对象
		System.out.println(allList); 		// 输出对象，调用toString()方法
	}
}

实例操作二：删除元素

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo02 {
	public static void main(String[] args) {
		List<String> allList = null ;	// 声明List对象
		allList = new ArrayList<String>(); // 实例化List对象，只能是String类型
		allList.add("Hello"); 		// 增加元素
		allList.add(0, "World");		// 此方法为List扩展的增加方法
		allList.add("Hello"); 		// 增加元素
		allList.add("everyone");	// 增加元素
		allList.remove(0);		// 删除指定位置的元素
		allList.remove("Hello");		// 删除指定内容的元素
		System.out.println(allList); 	// 输出对象，调用toString()方法
	}
}

实例操作三：输出List中的内容

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo03 {
	public static void main(String[] args) {
		List<String> allList = null ;	// 定义List接口对象
		allList = new ArrayList<String>(); // 实例化List对象，只能是String类型
		allList.add("Hello"); 			// 增加元素
		allList.add("Hello"); 			// 增加元素
		allList.add(0, "World");			// 增加元素
		allList.add("Hello"); 			// 增加元素
		allList.add("Everyone");		// 增加元素
		System.out.print("由前向后输出：");		// 信息输出
		for (int i = 0; i < allList.size(); i++) {	// 循环输出集合内容
			System.out.print(allList.get(i) + "、");// 通过下标取得集合中的元素
		}
		System.out.print("\n由后向前输出：");
		for (int i = allList.size() - 1; i >= 0; i--) {// 循环输出集合内容
			System.out.print(allList.get(i) + "、");// 通过下标取得集合中的元素
		}
	}
}

实例操作四：将集合变为对象数组

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo04 {
	public static void main(String[] args) {
		List<String> allList = null ;	// 声明List对象
		allList = new ArrayList<String>(); // 实例化List对象，只能是String类型
		allList.add("Hello"); 		// 增加元素
		allList.add(0, "World");		// 增加元素
		allList.add("Hello"); 		// 增加元素
		allList.add("Everyone");	// 增加元素
		String str[] = (String[]) allList.toArray(new String[] {}); // 指定的泛型类型
		System.out.print("指定数组类型：");	// 信息输出
		for (int i = 0; i < str.length; i++) {// 输出字符串数组中的内容
			System.out.print(str[i] + "、");	// 输出每一个元素
		}
		System.out.print("\n返回对象数组：");	// 信息输出
		Object obj[] = allList.toArray();		// 直接返回对象数组
		for (int i = 0; i < obj.length; i++) {	// 循环输出对象数组内容
			String temp = (String) obj[i];	// 每一个对象都是String类型实例
			System.out.print(temp + "、");	// 输出每一个元素
		}
	}
}

实例操作五：集合的其他相关操作

import java.util.ArrayList;
import java.util.List;
public class ArrayListDemo05 {
	public static void main(String[] args) {
		List<String> allList = null ;		// 声明List对象
		allList = new ArrayList<String>(); // 实例化List对象，只能是String类型
		System.out.println("集合操作前是否为空？" + allList.isEmpty());
		allList.add("Hello"); 			// 增加元素
		allList.add(0, "World");			// 增加元素
		allList.add("Hello"); 			// 增加元素
		allList.add("Everyone");		// 增加元素
		System.out.println(allList.contains("Hello") ? 
				"\"Hello\"字符串存在！": "\"Hello\"字符串不存在！");
		List<String> allSub = allList.subList(2, 3);// 取出里面的部分集合
		System.out.print("集合截取：");
		for (int i = 0; i < allSub.size(); i++) {	// 截取部分集合
			System.out.print(allList.get(i) + "、");
		}
		System.out.println("") ;
		System.out.println("Everyone字符串的位置：" + allList.indexOf("Everyone"));
		System.out.println("集合操作后是否为空？" + allList.isEmpty());
	}
}

4.2.4 挽救的子类：Vector

在List接口中还有一个子类：Vector，Vector类属于一个挽救的子类，从整个JAVA的集合发展历史来看，Vector算是一个元老级的类，在JDK 1.0的时候就已经存在类此类。但是到了JAVA 2（JDK 1.2）之后重点强调了集合框架的概念，所以先后定义了很多的新接口（如：List等），但是考虑到一大部分的人已经习惯了使用Vector类，所以JAVA的设计者，就让Vector类多实现了一个List接口，这才将其保留下来。但是因为其是List子类，所以Vector类的使用与之前的并没有太大的区别。

Vector类的定义： public class Vector<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

4.2.4.1Vector子类

import java.util.List;
import java.util.Vector;
public class VectorDemo01 {
	public static void main(String[] args) {
		List<String> allList = null ;		// 声明List对象
		allList = new Vector<String>(); 	// 实例化List对象，只能是String类型
		allList.add("Hello"); 			// 增加元素
		allList.add(0, "World");			// 增加元素
		allList.add("Hello");			// 增加元素
		allList.add("Everyone");		// 增加元素
		for (int i = 0; i < allList.size(); i++) {	// 循环输出
			System.out.print(allList.get(i) + "、");// 通过get()取出每一个元素
		}
	}
}

使用旧的方法

import java.util.Vector;
public class VectorDemo02 {
	public static void main(String[] args) {
		Vector<String> allList = new Vector<String>(); // 实例化Vector对象
		allList.addElement("Hello"); 		// 此方法为Vector自己定义
		allList.addElement("Everyone");		// 此方法为Vector自己定义
		allList.addElement("Yes");		// 此方法为Vector自己定义
		for (int i = 0; i < allList.size(); i++) {		// 循环输出
			System.out.print(allList.get(i) + "、");// 取得集合中的每一个元素
		}
	}
}

4.2.4.2 子类的差异：ArrayList与Vector的区别

No.	比较点	ArrayList	Vector
1	推出时间	JDK 1.2之后推出的，属于新的操作类	JDK 1.0时推出，属于旧的操作类
2	性能	采用异步处理方式，性能更高	采用同步处理方式，性能较低
3	线程安全	属于非线程安全的操作类	属于线程安全的操作类
4	输出	只能使用Iterator、foreach输出	可以使用Iterator、foreach、Enumeration输出

4.3 LinkedList子类

4.3.1 LinkedList 子类

LinkedList表示的是一个链表的操作类，此类定义如下：

public class LinkedList<E> extends AbstractSequentialList<E>implements List<E>, Queue<E>, Cloneable, Serializable

4.3.2 LinkedList中操作链表的部分方法:

No.	方法	类型	描述
1	public void addFirst(E o)	普通	在链表开头增加元素
2	public void addLast(E o)	普通	在链表结尾增加元素
3	public boolean offer(E o)	普通	将指定元素增加到链表的结尾
4	public E removeFirst()	普通	删除链表的第一个元素
5	public E removeLast()	普通	删除链表的最后一个元素

实例操作一：在链表的开头和结尾增加数据

import java.util.LinkedList;
public class LinkedListDemo01 {
	public static void main(String[] args) {
		LinkedList<String> link = new LinkedList<String>();
		link.add("A"); 				// 向链表中增加数据
		link.add("B"); 				// 向链表中增加数据
		link.add("C"); 				// 向链表中增加数据
		System.out.println("初始化链表：" + link);	// 输出链表内容，调用toString()
		link.addFirst("M");			// 在链表的表头增加内容
		link.addLast("N");			// 在链表的表尾增加内容
		System.out.println("增加头和尾之后的链表：" + link);	// 输出链表内容，调用toString()
	}
}

4.4 Queue接口定义的方法

4.4.1 Queue定义：

Queue接口是Collection的子接口，此接口定义如下：

public interface Queue<E> extends Collection<E>

4.4.2 Queue接口定义的方法：

No.	方法	类型	描述
3	public E element()	普通	找到链表的表头
4	public boolean offer(E o)	普通	将指定元素增加到链表的结尾
5	public E peek()	普通	找到但并不删除链表的头
6	public E poll()	普通	找到并删除此链表的头
7	public E remove ()	普通	检索并移除表头

实例操作一：找到链表头

import java.util.LinkedList;
public class LinkedListDemo02 {
	public static void main(String[] args) {
		LinkedList<String> link = new LinkedList<String>();
		link.add("A"); 					// 向链表中增加数据
		link.add("B"); 					// 向链表中增加数据
		link.add("C"); 					// 向链表中增加数据
		System.out.println("1-1、element()方法找到表头：" + link.element());
		System.out.println("1-2、找完之后的链表内容：" + link);
		System.out.println("2-1、peek()方法找到表头：" + link.peek());
		System.out.println("2-2、找完之后的链表内容：" + link);
		System.out.println("3-1、poll()方法找到表头：" + link.poll());
		System.out.println("3-2、找完之后的链表内容：" + link);
	}
}

实例操作二：以先进先出的方式取出全部的数据

import java.util.LinkedList;
public class LinkedListDemo03 {
	public static void main(String[] args) {
		LinkedList<String> link = new LinkedList<String>();
		link.add("A"); 				// 向链表中增加数据
		link.add("B"); 				// 向链表中增加数据
		link.add("C"); 				// 向链表中增加数据
		System.out.print("以FIFO的方式输出：");	// 信息输出
		for (int i = 0; i < link.size() + 1; i++) {// 循环输出
			System.out.print(link.poll() + "、");	// 取出表头
		}
	}
}

转载于:https://my.oschina.net/u/3544533/blog/1830428