1. 技术文章
  2. JAVA 常见的类集之Collection&List&Queue

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

由 元气小坏坏 提交于 2019-11-30 03:49:51

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

   (一). 类集

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

        类集的特征：

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

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

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

（二）类集框架主要接口

No

接口

描述

1

Collection

是存放一组单值的最大接口，所谓的单值是指集合中的每个元素都是一个对象。一般很少会直接使用此接口直接操作。

2

List

是Collection接口的子接口，也是最常用的接口，此接口对Collection接口进行了大量的扩充，里面的内容是允许重复的。

3

Set

是Collection接口的子类，没有对Collection接口进行扩充，里面不允许存放重复内容。

4

Map

Map是存放一对值的最大接口，即，接口中的每个元素都是一对，以keyvalue的形式保存。

5

Iterator

集合的输出接口，用于输出集合中的内容，只能进行从前到后的单向输出。

6

ListIterator

是Iterator的子接口，可以进行双向输出。

7

Enumeration

是最早的输出接口，用于输出指定集合中的内容。

8

SortedSet

单值的排序接口，实现此接口的集合类，里面的内容是可以排序的，使用比较器排序。

9

SortedMap

存放一对值的排序接口，实现此接口的集合类，里面的内容按照key排序，使用比较器排序。

10

Queue

队列接口，此接口的子类可以实现队列操作。

11

Map.Entry

Map.Entry的内部接口，每个Map.Entry对象都保存着一对keyvalue的内容，每个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() + "、");	// 取出表头
		}
	}
}

 

标签
collection接口
接口
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!