Java集合类

最新推荐文章于 2025-08-11 09:20:14 发布

原创最新推荐文章于 2025-08-11 09:20:14 发布 · 328 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #线程安全 #collection #集合

Java 专栏收录该内容

2 篇文章

订阅专栏

最近在学Java线程，看到了关于集合的线程安全问题，突然想到上一次做集合相关的东西已经是半个月之前了，为了防止自己忘记，在此整理一下集合有关的内容。

首先是一张集合类的图：
图中标识的比较全面，在此只记录我比较常用和了解的几个。
下面的例子中，用到了一个自定义的Student类，并重写了equals、toString和compareTo方法，并自定义了一个MyComparable类实现Comparator接口，具体如下：
MyComparable类：
package demo;

import java.util.Comparator;

public class MyComparable implements Comparator<Student> {

	@Override
	public int compare(Student o1, Student o2) {
		return o1.getName().compareTo(o2.getName());
	}

}

Student类：

package demo;

public class Student implements Comparable<Student> {
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Student other = (Student) obj;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}

	private String name;

	public Student(String name) {
		super();
		this.name = name;
	}
	
	public String getName(){
		return name;
	}
	
	public void showFriend(Student stu){
		System.out.println(stu.name+"是我的好朋友");//此处实在类内部，private失去了意义，所以可以直接用"."访问对象属性，即使不是当前对象
	}

	@Override
	public int compareTo(Student o) {
		return name.compareTo(o.getName());
	}

}

Collection接口

Collection 接口下主要包括List与Set，Collection接口存储的是一组不唯一，无序的对象，而List接口存储一组不唯一，有序的对象，Set接口存储了一组唯一，无序的对象，也就是说List和Set分别对Collection的进行了不同方面的改进。

List接口

实现List接口的类有ArrayList和LinkedList：

ArrayList

实现了长度可变的数组，在内存中分配连续的空间。遍历元素和随机访问元素的效率比较高。

方法：

boolean add(Object o)：添加对象，成功返回true；

void add(int index,Object o)：向下标为index的位置个添加o；

int size()：返回ArrayList长度；

Object get(int index)：获取下标为index的元素，下标从0开始，取出的对象是Object类（不论存储的是什么类型），可以进行强制类型转换；

boolean contains(Object o)：对象o是否在ArrayList中，在则返回true，使用的比较方法是equals()方法，重写对象的该方法可以改变结果；

boolean remove(Object o)：删除元素o，删除成功返回true；

Object remove(int index)：删除下标为index的元素，返回对应元素。

遍历：

package demo;

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

public class Demo05 {

	public static void main(String[] args) {
		ArrayList<Object> arr = new ArrayList<Object>();
		arr.add(12);
		arr.add("abc");
		arr.add(new Student("Jack"));
		arr.add(0, new Student("Rose"));
		//输出对象
		for(int i = 0;i<arr.size();i++){
			if(arr.get(i) instanceof Student){
				Student stu = (Student) arr.get(i);
				System.out.println(stu);
			}
		}
		System.out.println("-----1：for循环遍历-----");
		for(int i=0;i<arr.size();i++){
			System.out.println(arr.get(i));
		}
		System.out.println("-----2：增强型for循环-----");
		for(Object obj:arr){
			System.out.println(obj);
		}
		System.out.println("-----3：迭代器-----");
		Iterator<Object> it = arr.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			System.out.println(obj);
		}
	}

}

ArrayList是线程不安全的，与它功能类似的Vector是线程安全的，但性能要差很多。

LinkedList

LinkedList采用链表的存储方式，删除、插入效率比较高。

方法：

boolean add(Object o)：添加对象，成功返回true；

boolean addFirst(Object o)：添加对象到头，成功返回true；

boolean addLast(Object o)：添加对象到尾，成功返回true；

Object get(int index)：返回下标为index的元素，下标从0开始，取出的对象是Object类（不论存储的是什么类型），可以进行强制类型转换（所有返回元素的方法都有这个特性，后面就不再做说明了）；

Object getFirst()：获取第一个元素；

Object getLast()：获取最后一个元素；

boolean remove(Object o)：删除元素o，删除成功返回true；

Object remove(int index)：删除下标为index的元素并将其返回；

Object removeFirst()：删除第一个元素并将其返回；

Object removeLast()：删除最后一个元素并将其返回；

遍历：

package demo;

import java.util.Iterator;
import java.util.LinkedList;

public class Demo01 {

	public static void main(String[] args) {
		LinkedList<Object> ll = new LinkedList<Object>();
		ll.add(12);//继承父类Collection
		ll.addFirst("llll");
		ll.addLast(new Student("jack"));
		ll.add("www");
		System.out.println("-----1：for循环遍历-----");
		for(int i=0;i<ll.size();i++){
			System.out.println(ll.get(i));
		}
		System.out.println("-----2：增强型for循环-----");
		for(Object obj:ll){
			System.out.println(obj);
		}
		System.out.println("-----3：迭代器-----");
		Iterator<Object> it = ll.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

}

与ArrayList相同，LinkedList也是线程不安全的。

Stack

Stack表示后进先出的对象栈。

方法：

Object get(int index)：获取下标为index的元素，下标从0开始；

boolean empty()：检测栈是否为空，为空则返回true；

Object peek()：查看栈顶对象，但不移除它；

Object pop()：出栈，删除并返回栈顶元素；

Object push(Object o)：压入栈顶，返回对应元素；

int search(Object o)：查找元素o，返回下标（从1开始），不存在则返回-1；

遍历：

package demo;

import java.util.Iterator;
import java.util.Stack;

public class Demo02 {

	public static void main(String[] args) {
		Stack<Object> st = new Stack<Object>();
		st.push(244);
		st.push("77777");
		st.add(11);
		st.push("222222");
		System.out.println("-----1：迭代器（从栈底开始）------");
		Iterator<Object> it = st.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		System.out.println();
		System.out.println("-----2：for循环get遍历（从栈底开始）------");
		int index = st.size();
		for(int i = 0;i<index;i++){
			System.out.println(st.get(i));
		}
		System.out.println();
		System.out.println("-----3：for-each循环遍历（从栈底开始）-----");
		for(Object o:st){
			System.out.println(o);
		}
		System.out.println();
		System.out.println("-----4：for循环pop遍历，结束后栈为空（从栈顶开始）------");
		for(int i = 0;i<index;i++){
			System.out.println(st.pop());
		}
		System.out.println(st.isEmpty());
	}

}

要注意get和search方法的下规定标起始不同（并不意味着search就少一个！）。

Set接口

Set接口存储一组唯一，无序的对象。

HashSet类

方法：

boolean add(Object o)：添加对象，成功返回true，若集合中已经存在该对象，会保留原有的，并返回false，比较方法使用的是equals()；

boolean isEmpty()：检测集合是否为空，为空则返回true；

boolean remove(Object o)：移除指定对象，成功返回true；

int size()：返回集合长度；

Object[] toArray()：将Set集合变为一个不可变的对象数组；

遍历：

package demo;

import java.util.HashSet;
import java.util.Iterator;

public class Demo03 {

	public static void main(String[] args) {
		HashSet<Object> hs = new HashSet<Object>();
		hs.add(12);
		hs.add(new Student("Rose"));
		hs.add(new String("111"));
		System.out.println(hs.size()+"    "+hs);
		Iterator<Object> it=hs.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
	}

}

HashSet只能使用迭代器遍历。

Set所谓的无序是指不按先进先出之类的规则，它有自己的一套规则，所以相同的一组元素每次顺序都相同。

Queue（队列）接口

队列以先进先出的方式存储元素，队头删除，队尾添加。

LinkedBlockingQueue类

LinkedBlockingQueue类可以在构造时传入队列长度，定义好后不可改变。

方法：

boolean add(Object o)：添加对象o到队尾，若队列已满则抛出异常；

boolean offer(Object o)：添加对象o到队尾，若队列已满则不添加并返回false；

Object peek()：返回但不删除队头，若队列为空返回null；

Object poll()：删除并获取队头，若队列为空返回null；

Object remove()：删除并返回队头，若队列为空则抛出异常；

遍历：

package demo;

import java.util.Iterator;
import java.util.concurrent.LinkedBlockingQueue;

public class Demo04 {

	public static void main(String[] args) {
		LinkedBlockingQueue<Object> lbq = new LinkedBlockingQueue<Object>(5);
		lbq.offer(111);
		lbq.offer("222");
		lbq.offer(new Student("Jack"));
		lbq.offer(new Student("Rose"));
		lbq.offer(2);
		Iterator<Object> it = lbq.iterator();
		while(it.hasNext()){
			System.out.println(it.next());
		}
		System.out.println();
		System.out.println(lbq.peek());
		System.out.println(lbq.poll());
		System.out.println(lbq.remove());
	}

}

Map接口

Map接口专门处理键值映射数据的存储可以根据键实现对值的操作，其中键不能重复。

HashMap类

方法：

Object put(Object key,Object value)：向集合中添加一对键值对，返回key，与HashSet不同，若key重复则会以新值覆盖旧值；

Object get(Object key)：根据key返回对应元素，key不存在则返回null；

Object remove(Object key)：根据key值删除对应的键值对，返回对应key值，若key不存在则返回null；

int size()：返回集合中元素的个数；

Set keySet()：返回建的集合；

Collection values()：返回值的集合；

boolean containKeys(Object key)：判断集合中是否存在key对应的键值对；

遍历：

package demo;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;

public class Demo05 {

	public static void main(String[] args) {
		HashMap<Object,Object> hm = new HashMap<Object,Object>();
		hm.put(1, "a");
		hm.put(2, "www");
		Student stu1 = new Student("Jack");
		Student stu2 = new Student("Rose");
		hm.put(stu1.getName(), stu1);
		hm.put(stu2.getName(), stu2);
		System.out.println(hm.get("Jack"));
		System.out.println(hm.size());
		System.out.println(hm);
		hm.put("Jack", new Student("JJJJ"));
		System.out.println(hm);
		
		//迭代
		HashMap<Object,Object> hm2 = new HashMap<Object,Object>();
		hm2.put(1, "a");
		hm2.put(2, "www");
		hm2.put(stu1.getName(), stu1);
		hm2.put(stu2.getName(), stu2);
		
		System.out.println("------迭代方式一------");
		Set<Object> keySet = hm2.keySet();//键集合
		Iterator<Object> it = keySet.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			System.out.println(hm2.get(obj));
		}
		
		System.out.println("------迭代方式二------");
		Set<Entry<Object, Object>> entrySet = hm2.entrySet();
		for(Object obj:entrySet){
			Entry<Object, Object> entry = (Entry<Object, Object>)obj;
			System.out.println("key->"+entry.getKey()+"  value->"+entry.getValue());
		}
		
		System.out.println("------迭代方式三------");
		Collection<Object> values = hm2.values();
		for(Object obj:values){
			System.out.println(obj);
		}
	}

}

几个例子：

输入字符串，求各字母出现的次数：

package demo;

import java.util.HashMap;
import java.util.Scanner;

public class Demo06 {

	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.print("输入一串字符串：");
		String str = input.next();
		HashMap<String,Integer> hm = new HashMap<String,Integer>();
		char[] strArr = str.toCharArray();
		for(int i = 0;i<strArr.length;i++){
			String key = Character.toString(strArr[i]);
			if(hm.containsKey(key)){
				int value = hm.get(key);
				hm.put(key, value+1);
			}else{
				hm.put(key, 1);
			}
		}
		System.out.println("各字符出现次数如下：");
		System.out.println(hm);
		input.close();
	}

}

Collections类的sort、max、min和binarySearch方法的应用：

package demo;

import java.util.*;

public class Demo08 {

	public static void main(String[] args) {
		ArrayList<Integer> al = new ArrayList<Integer>();
		for(int i = 0;i<6;i++){
			al.add(new Random().nextInt(100)+1);
		}
		System.out.println(al);
		Collections.sort(al);
		System.out.println(al);
		int i = Collections.binarySearch(al, 20);
		System.out.println(i);
		System.out.println("max:"+Collections.max(al));
		System.out.println("min:"+Collections.min(al));
		
		ArrayList<Student> al2 = new ArrayList<Student>();
		al2.add(new Student("Jack5"));
		al2.add(new Student("Jack4"));
		al2.add(new Student("Jack2"));
		al2.add(new Student("Jack0"));
		al2.add(new Student("Jack3"));
		al2.add(new Student("Jack1"));
		System.out.println("前："+al2);
		Collections.sort(al2);
		System.out.println("后："+al2);
		Collections.sort(al2,new MyComparable());//传入自定义比较器可以实现其他属性比较
	}

}