java基础——集合框架

关注

原创最新推荐文章于 2025-10-04 00:13:35 发布 597 阅读 AI 写同款· GEO 优化 ›

45、Java集合框架全解析：从基础到实战应用本文全面解析了Java集合框架，从基础概念到实战应用，涵盖了核心接口、通用实现类、常用算法以及基础设施等内容。通过详细的讲解和代码示例，帮助开发者理解不同集合类的区别与性能特点，并学会如何选择合适的数据结构。此外，还介绍了Java 1.4.2风格的集合使用方式以及泛型带来的改进。无论你是初学者还是有经验的Java开发者，都能从中获得有价值的指导。阅读详情

第一讲、集合框架的概述

为什么出现集合类：数据多了用对象存，而对象多了就要用集合存，集合就是存储对象最常用的
一种方式。
数组和集合：数组虽然也可以存放对象，但是数组是固定的，在程序运行时我们无法确定要产生多少个对象，
而集合是可变长度的，但是集合也只能存放对象，而数组可以存放基本数据类型。
集合类特点：长度可变，只能存放对象，可以存放不同类型对象。

代码演示Collection共性方法：

import java.util.*;
/*
add方法的参数类型是Object，以便于接受任意类型对象
集合中存储的都是对象的引用（地址）。
*/
class  CollectionDemo
{
	public static void main(String[] args) 
	{
		//创建一个集合容器，使用collection接口的子类ArrayList
		ArrayList al=new ArrayList();
		//添加元素
		al.add("java01");
		al.add("java02");
		al.add("java03");
		al.add("java04");
		//打印集合
		sop(al);
		//取出元素1
		Iterator it = al.iterator();
		while(it.hasNext()){
			sop(it.next());
		}
		//取出元素2
		for(Iterator it = al.iterator;it.hasNext();)
		{
			sop(it.next());
		}
		//删除元素
		al.remove("java02");
		//al.clear();//清空集合
		sop(al);
		//获取个数，集合长度
		sop("size="+al.size());
		//判断元素
		sop("java03是否存在:"+al.contains("java03"));
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

第二讲 List集合Set集合
List特有方法：凡是可以用角标操作元素的方法都是list特有方法。
增：add(index,element) addAll(index,Collection);
删除：remove(index);
改：set(index,element)
查：get(index) subList(from,to) listIterator();
代码演示:

import java.util.*;
class ListDemo{
	public static void sop(Object obj){
		System.out.println(obj);
	}
	public static void main(String [] args){
		ArrayList al = new ArrayList();
		//添加元素
		al.add("listAdd01");
		al.add("listAdd02");
		al.add("listAdd03");
		sop("原集合： "+al);
		al.add(1,"java005");
		sop(al);
		//删除指定位置元素
		al.remove(3);
		sop(al);
		//修改
		al.set(2,"java008");
		//查		
		sop("获取到: "+al.get(1););
		//获取所有元素
		for(int x=0;x<al.size();x++){
			sop("al["+x+"]="+al.get(x));
		}
		Iterator it = al.iterator();
		while(it.hasNext()){
			sop(it.next());
		}
	}
}

List集合特有的迭代器，ListIterator是Iterator的子接口，
在迭代的时候，不可以使用集合对象的方法来操作元素，（如添加删除等）
这样会发生并发访问异常，
Iterator功能有限只能进行简单的判断删除操作，想要使用其他功能就
只能使用ListIterator来添加修改等,

ListIterator li = new ListIterator();
while(li.hasNext()){
	Object obj = li.next();
	if(obj.equals("java008"))
		//li.add("java0011");
		li.set("java00000");
}
sop(al);

LinkedList:特有方法getFirst();getLast();removeFirst();removeLast();addFirst();addLast();
代码演示：

import java.util.*;
class LinkedListDemo
{
	public static void main(String [] args){
		LinkedList link = new LinkedList();
			link.addFirst("java01");
			link.addFirst("java02");
			link.addFirst("java03");
			link.addFirst("java04");
			sop(link);
			sop(link.removeFirst());
			sop(link.getLast());
			sop(link.getFirst());
			sop(link.size());
			while(!link.isEmpty()){
				sop(link.removeFirst());
			}
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}

JDK1.6出现了替代方法：boolean offer(E e) offerFirst(E e) offerLast(E e) peek() peekFirst() peekLast() poll() pollFirst()
pollLast()

LinkedList的这些方法可以实现模拟堆栈和队列结构。

LinkedList和ArrayList都是线程不安全的，所谓线程不安全就是指可以并发访问。也就是不同步的，（没有加同步）

下面演示ArrayList相关操作。
代码演示去除ArrayList集合的重复元素：

import java.util.*;
class ArrayListTest
{
	public static void main(String [] args){
		ArrayList al = new ArrayList();
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java02");
		al.add("java01");
		al.add("java03");
		sop(al);
		al = singleElement(al);
		sop(al);
	}
	public static void singleElement(ArrayList al){
		//定义一个临时容器。
		ArrayList newal = new ArrayList();
		Iterator it = al.iterator();
		while(it.hasNext())
		{
			Object obj = it.next();
			if(!newal.contains(obj))
				newal.add(obj);
		}
		return newal;
	}
	public static void sop(Object obj){
	System.out.println(obj);
	}
}

接下来介绍Set集合：元素是无序的，不允许存在重复元素，取出元素的顺序如存入的不一定一样，
Set集合的方法与Collection一致，不做过多演示，下面介绍子类对象HashSet和TreeSet
HashSet：底层是哈希表。通过元素的两个方法：HashCode 和equals完成的。如果哈希值相同就判断equals
，如果哈希值不同则不会调用equals。（保证唯一性）
对于判断元素是否存在，或者删除等操作，依赖的方法也是HashCode和equals方法。
TreeSet：底层是二叉树。
代码实例：

import java.util.*;
class HashSetTest
{
	public static void sop(Object obj){
	System.out.println(obj);
	}
	public static void main(String[] args){
		HashSet hs = new HashSet();
		hs.add(new Person("a1",11));
		hs.add(new Person("a1",11));
		hs.add(new Person("a3",13));
		hs.add(new Person("a4",14));
		Iterator it = hs.iterator();
		while (it.hasNext())
		{
			Person p = (Person)it.next();
			sop(p.getName()+"****"+p.getAge());
		}
	}
}//创建一个Person类
class Person
{
	private String name;
	private int age;
	Person(String name,int age){
		this.name = name;
		this.age= age;
	}
	public int hashCode(){//为了尽量保证哈希值唯一性，age乘以一个数。
	return name.hashCode()+age*37;
	}//复写equals方法
	public boolean equals(Object obj){
	if(!obj instanceof Person)
		return false;
	Person p = (Person)obj;
	System.out.println(this.name+"***equals***"+p.name);
	return this.name.equals(p.name)&&this.age==p.age;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
}

下面介绍TreeSet：可以对set集合的元素进行排序（自然顺序ascii），
排序时，当主要条件相同时，一定要判断一下次要条件，底层是二叉树，
保证元素唯一的方法是compareTo和return 0。
TreeSet实现排序的第一种方法：让元素自身具有比较性，元素需要实现Comparable
接口，覆盖compareTo方法。即自然排序或默认顺序。
TreeSet实现排序的第二种方法：当元素自身不具备比较性，或者具备的比较性不是所需要的
这时就需要让集合自身具备比较性。
当两种排序都存在时，以比较器为主，
定义一个比较器方法步骤：1.定义一个类实现Comparator接口，覆盖compare方法。(compareTo是Comparable的方法)
代码演示第一种排序方法：

//演示存储学生对象,按照学生年龄进行排序。
import java.util.*;
class TreeSetTest
{
	public static void main(String [] args){
		TreeSet ts = new TreeSet();
		ts.add(new Student("lisi01",11));
		ts.add(new Student("lisi02",12));
		ts.add(new Student("lisi03",13));
		ts.add(new Student("lisi04",14));
		ts.add(new Student("lisi05",15));
		Iterator it = ts.iterator();
		while(it.hasNext()){
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"**********"+stu.getAge());
		}
	}
}
class Student implements Comparable//该接口强制让学生类具有比较性
{//不实现该接口就会抛出类型转换异常classCastException
	private String name;
	private int age;
	Student(){
		this.name = name;
		this.age = age;
	}
	//需要覆盖比较方法compareTo
	public int compareTo(Object obj){
		if(!(obj instanceof Student))
			throw new RuntimeException("不是学生类对象");
		Student s = (Student)obj;
		if(this.age>s.age)
			return 1;
		if(this.age==s.age)
		{//如果年龄相同，则比较名字
			return this.name.compareTo(s.name);	
		}
		return -1;
	}
	public String getName(){
	return name;
	}
	public int getAge(){
	return age;
	}
}

代码演示第二种排序:

import java.util.*;
class TreeSetDemo
{
	public static void main(String[] args){
		TreeSet ts = new TreeSet(new MyCompare());//使集合初始化时就具有比较性
		ts.add(new Student("lisi01",11));
		ts.add(new Student("lisi02",12));
		ts.add(new Student("lisi03",13));
		ts.add(new Student("lisi04",14));
		ts.add(new Student("lisi05",15));
		Iterator it = ts.iterator();
		while(it.hasNext()){
			Student stu = (Student)it.next();
			System.out.println(stu.getName()+"**********"+stu.getAge());
		}
	}
}//按照姓名排序
class MyCompare implements Comparator
{//需要复写compare方法
	public int compare(Object o1,Object o2){
		Student s1 = (Student)o1;
		Student s2 = (Student)o2;
		int num = s1.getName().compareTo(s2.getName());
		if(num==0){//因为Integer类实现了Compaable接口，所以Integer对象具有比较性。
			return new Integer(s1.getAge()).compareTo(new Integer(s2.getAge()));
//			if(s1.getAge()>s2.getAge())
//				return 1;
//			if(s1.getAge()==s2.getAge())
//				return 0;
//			return -1;
		}
		return num;
	}
}

第三讲 Map集合
Map集合：存放的是键值对，一对一对存放，而且保证键的唯一性，包括
三个子类：HashTable HashMap TreeMap
添加：put(K key,V value) putAll() 删除：clear() remove(Object Key)
判断：containsValue(Object value) containsKey(Object key) isEmpty()
获取：get(Object key) size() value() entrySet() keySet()
Map 其实Set集合底层使用的就是Map集合
|——HashTable底层是哈希值数据结构，不可以有null键和值，是线程同步的。
|——HashMap底层是哈希值数据结构，允许使用null键和值，是线程不同步的。
|——TreeMap底层是二叉树，可以用于给Map集合中的键进行排序，线程不同步。
HashMap和HashTable的区别：null和同步不同步。
代码演示Map共性方法：

import java.util.*;
class MapDemo
{
	public static void main(String [] args){
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan01");//添加
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		System.out.println("containsKey: "+map.containsKey("02"));
		//System.out.println("remove: "+map.remove("02"));
		//System.out.println("get: "+map.get("03"));
		map.put(null,"haha");
		System.out.println("get: "+map.get(null));
		//获取
		Collection <String>coll = map.value();
		System.out.println(coll);
		System.out.println(map);
	}
}

Map集合所有的元素获取：entrySet和keySet
keySet:将map中所有的键存放到Set集合，因为Set集合具备迭代器。然后可以通过迭代获取所有键，
再通过get方法获取所有的值，
代码演示keySet:

import java.util.*;
class MapDemo
{
	public static void main(String [] args){
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan01");//添加
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		//现获取map集合的所有键的Set集合，keySet();
		Set<String>keySet = map.keySet();
		//获取其迭代器
		Iterator<String> it = keySet.iterator();
		while(it.hasNext()){
			String key = it.next();//取得所有的键
			String value = map.get(key);//取得值
			System.out.println("key: "+key+"value: "+value);
		}
}

第二种获取方法：entrySet,将map集合中的映射关系存放到Set集合，
而这个映射关系的数据类型就是：Map.Entry
Map.Entry也是一个接口，是Map接口中的一个内部接口。
代码演示：

import java.util.*;
class MapDemo
{
	public static void main(String [] args){
		Map<String,String> map = new HashMap<String,String>();
		map.put("01","zhangsan01");//添加
		map.put("02","zhangsan02");
		map.put("03","zhangsan03");
		//将map中的映射关系取出，出入到Set集合。
		Set<Map.Entry<String,String>>entrySet = map.entrySet();
		Iterator<Map.Entry<String,String>> it = entrySet.iterator();
		while(it.hasNext()){
			Map.Entry<String,String> me = it.next();
			String key = me.getKey();
			String value = me.getValue();
			System.out.println("key: "+key+"value: "+value);
		}
}

综合示例演示：存储学生信息，并按照姓名排序。

package Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class MapDemo {
	public static void main(String[] args) {
		HashMap<Student,String>hm = new HashMap<Student,String>();
		hm.put(new Student("lisi",20),"beijign");
		hm.put(new Student("lisi",20),"tianjin");
		hm.put(new Student("wangwu",50),"shanghai");
		hm.put(new Student("aliu",25),"taiyuan");
		//第一种取出方式keySet
		Set<Student> keySet = hm.keySet();
		Iterator<Student> it = keySet.iterator();
		while(it.hasNext()){
			Student stu = it.next();
			String addr = hm.get(stu);
			System.out.println(stu+"*******"+addr);
		}
		//第二种取出方式entrySet
		Set<Map.Entry<Student, String>>entrySet = hm.entrySet();
		Iterator<Map.Entry<Student, String>>it2=entrySet.iterator();
		while(it2.hasNext()){
			Map.Entry<Student, String> me = it2.next();
			Student stu = me.getKey();
			String addr2 = me.getValue();
			System.out.println(stu+"############################"+addr2);
		}
	}
}
//要创建多个对象备用的时候需要做如下这些
/*实现(复写compareTo方法)  覆盖两个方法 
 * */
class Student implements Comparable<Student>{
	private String name;
	private int age;
	Student(String name,int age){
		this.name=name;
		this.age=age;
	}//复写compareTo方法，将name和age封装成Student对象传入
	public int compareTo(Student s){
		int num=new Integer(this.age).compareTo(new Integer(s.age));
		if(num==0)
			return this.name.compareTo(s.name);
		return num;
	}
	public String getName(){
		return name;
	}
	public int getAge(){
		return age;
	}
	public String toString(){
		return name+"***"+age;
	}
	public int hashCode(){
		return name.hashCode()+age*34;
	}
	public boolean equals(Object obj){
		if(!(obj instanceof Student))
			throw new ClassCastException("类型不匹配");
		Student s = (Student)obj;
		return this.name.equals(s.name)&&this.age==s.age;
	}
}

第四讲工具类及其他
Collections:专门对结合进行操作的工具类，内部方法都是静态的，定义的排序方法sort需要进行泛型限定，
其泛型类型必须是Comparable的子类，代码示例：
//public static <T extends Comparable<? super T>>void sort(List<T> list){}
代码实例：

import java.util.*;
class CollectionsDemo
{
	public static void main(String [] args){
		List<String> list = new ArrayList<String>();
		list.add("ada");
		list.add("hfaf");
		list.add("ddfas");
		list.add("qas");
		sop(list);
		//Collections.sort(list);//默认排序
		Collections.sort(list,new StrLenComparator());//默认排序
		sop(list);
	}
	public static void sop(Object obj){
		System.out.println(obj);
	}
}//自定义比较器
class StrLenComparator implements Comparator<String>
{
	public int compare(String s1,String s2){
		if(s1.length()>s2.length())
			return 1;
		if(s1.length()<s2.length())
			return -1;
		return s1.compareTo(s2);
	}
}

Arrays:用于操作数组的工具类，里面都是静态方法。
asList:将数组转成集合。
如果数组中的元素都是对象，转换成集合时，数组中的元素直接变成集合中的元素。
如果数组中的元素是基本数据类型，那么会将数组作为集合中的元素存在，
代码演示：

import java.util.*;
class ArraysDemo
{
	public static void main(String[] args){
		String[] arr= {"dsad""acc""add"};
		//将数组变成集合,可以使用集合的方法来操作数组。不可以使用集合的增删，
		List<String>list=Arrays.asList(arr);
		sop("contains: "+list.contains("acc"));
		sop(list);
	}
}

用增强for循环遍历HashMap:方法一

HashMap<Integer,String> hm = new HashMap<Integer,String>();
		hm.put(1,"a");
		hm.put(2,"b");
		hm.put(3,"c");
		Set<Integer> keySet = hm.keySet();
		for(Integer i: keySet)
		{
			System.out.println(i+"***"+hm.get(i));
		}
		//方法二
//		Set<Map.Entry<Integer,String>>entrySet = hm.entrySet();
//		for(Map.Entry<Integer,String> me: entrySet)
	for(Map.Entry<Integer,String> me:hm.entrySet())
	{
		System.out.println(me.getKey()+"*****"+me.getValue());
	}

可变参数使用时注意：一定要定义在参数列表的最后面。

class ParaMethod
{
		public static void main(String[] args){
			show("haha",2,5,45,5);
		}
		public static void show(String str,int... arr){
			System.out.println(arr.length);
		}
}

收录于