JAVA集合（容器）

最新推荐文章于 2025-03-02 12:27:23 发布

原创最新推荐文章于 2025-03-02 12:27:23 发布 · 667 阅读

1 ·

CC 4.0 BY-SA版权

JavaSE基础专栏收录该内容

57 篇文章

订阅专栏

1.集合的引入
存储多个元素时，我们前面讲过数组，数组可以存储。但是数组也有它的弊端，使用的时候，必须先定义好长度，也就是数组的长度是固定，不能根据我们的需求自动变长或者变短。
我们看一个实例，定义一个Student类

public class Student {
	private String name;
	private Integer age;
	public Student() {
		super();
	}
	public Student(String name, Integer age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
}

现在需要存储三个学生信息

public class test {
	public static void main(String[] args) {
		Student student[]=new Student[3];
		student[0]=new Student("小明",18);
		student[1]=new Student("小红",19);
		student[2]=new Student("小刚",20);
		
		for (Student student2 : student) {
			System.out.println(student2.getName()+","+student2.getAge());
		}
	}
}

这里实现了用数组结构存储了三个学生，但是假如我们需要再存储一个学生，就懵逼了，因为长度固定了，这时就引入了可变长度的集合（容器）

2.集合体系
集合的体系结构如下图所示
在这里插入图片描述
下面我们将对几个常用的集合进行讲解
（1）Collection接口
Collection接口定义了存储一组对象的方法，其子接口Set、List和Queue分别定义了不同类型的存储方式。

（2）List接口
List代表元素有序、可重复的集合，集合中每个元素都有对应的顺序索引，允许加入重复元素，通过索引指定元素的位置，具体实现类有ArrayList、LinkedList和Vector三种。

三种实现的区别：
ArrayList: 底层实现是数组，查询快，修改、插入、删除慢，线程不安全，效率高
LinkedList: 底层实现是链表，查询慢，修改、插入、删除慢，线程不安全，效率高
Vector: 底层实现是数组，线程安全，效率低

import java.util.ArrayList;

public class testArrayList {
	//打印集合
	public static void print(ArrayList<String> arrayList) {
		System.out.println("当前元素集合");
		for (String string : arrayList) {
			System.out.println(string);
		}
	}
	public static void main(String[] args) {
		ArrayList<String>list=new ArrayList<>();
		//添加元素
		list.add("小明");
		list.add("小红");
		list.add("小刚");
		print(list);
		
		//在指定位置插入元素
		list.add(1, "小兰");
		print(list);
		
		//替换元素
		list.set(0, "小花");
		print(list);
		
		//删除元素
		list.remove(2);
		print(list);
	}
}

运行结果
在这里插入图片描述

import java.util.LinkedList;

public class testLinkedList {
	//打印集合
	public static void print(LinkedList<String>linkedlist) {
		System.out.println("当前集合元素");
		for (String string : linkedlist) {
			System.out.println(string);
		}
	}
	public static void main(String[] args) {
		LinkedList<String>linkedlist=new LinkedList<>();
		//添加元素
		linkedlist.add("花花");
		linkedlist.add("红红");
		linkedlist.add("兰兰");
		print(linkedlist);
		// indexOf 寻找位置
		int a=linkedlist.indexOf("红红");
		System.out.println("红红的索引为"+a);
		// peekFirst 获取第一个元素
		String str=linkedlist.peekFirst();
		System.out.println("第一个元素为"+str);
		// peekFirst 获取最后一个元素
		String str1=linkedlist.peekLast();
		System.out.println("最后一个元素为"+str1);
		// pollFirst 摘取第一个元素
		linkedlist.pollFirst();
		print(linkedlist);
		// pollLast 榨取最后一个元素
		linkedlist.pollLast();
		print(linkedlist);
	}
}

运行结果
在这里插入图片描述
（3）Set接口
Set继承Collection接口，不能包含重复元素，Set判断两个对象不是使用==来判断，是使用equals方法。Set常用的实现类是HashSet

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

public class testHashSet {
	public static void main(String[] args) {
		HashSet<String> hashset=new HashSet<>();
		hashset.add("小明");
		hashset.add("小兰");
		hashset.add("小红");
		
		//用Iterator遍历容器
		Iterator<String>it=hashset.iterator();
		while(it.hasNext()) {
			String s=it.next();
			System.out.println(s);
		}
	}
}

运行结果
在这里插入图片描述
（4）Map接口
是存放一对值的最大接口，即接口中的每一个元素都是一对，以key->value键值对的形式保存，Map的常用实现类是HashMap

import java.util.HashMap;
import java.util.Iterator;

public class testHashMap {
	public static void main(String[] args) {
		HashMap<Integer,String>hs=new HashMap<>();
		//添加元素put()
		hs.put(1, "小明");
		hs.put(2, "小红");
		hs.put(3, "小蓝");
		// 通过key，获取value
		String s=hs.get(2);
		System.out.println(s);
		System.out.println("####################################");
		//迭代器遍历遍历
		Iterator<Integer> it=hs.keySet().iterator();//获取key的集合，再获取迭代器
		while(it.hasNext()) {
			Integer key=it.next();// 获取key
			String string=hs.get(key);// 通过key获取value
			System.out.println(string);
		}
	}
}

运行结果
在这里插入图片描述
3.集合中的各种遍历方式
List遍历方式
（1）for循环
（2）foreach
（3）Iterator遍历

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

public class test1 {
	public static void main(String[] args) {
		ArrayList<String>list=new ArrayList<>();
		//添加元素
		list.add("小明");
		list.add("小红");
		list.add("小刚");
		
		//for循环遍历
		for (int i = 0; i < list.size(); i++) {
			System.out.println(list.get(i));
		}
		System.out.println("###########################################");
		//foreach遍历
		for (String string : list) {
			System.out.println(string);
		}
		System.out.println("###########################################");
		//Iterator遍历
		Iterator<String>it=list.iterator();
		while(it.hasNext()) {
			String string=it.next();
			System.out.println(string);
		}
	}
}

运行结果
在这里插入图片描述
Set遍历方式
（1）foreach
（2）Iterator遍历

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

public class test2 {
	public static void main(String[] args) {
		HashSet<String> hashset=new HashSet<>();
		hashset.add("小明");
		hashset.add("小兰");
		hashset.add("小红");
		
		//foreach遍历
		for (String string : hashset) {
			System.out.println(string);
		}
		System.out.println("#######################################");
		//Iterator遍历
		Iterator<String>it=hashset.iterator();
		while(it.hasNext()) {
			String string=it.next();
			System.out.println(string);
		}
	}
}

运行结果
在这里插入图片描述
Map遍历方式
（1）根据key获取value
（2）使用entrySet

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

public class test3 {
	public static void main(String[] args) {
		HashMap<Integer,String>hs=new HashMap<>();
		//添加元素put()
		hs.put(1, "小明");
		hs.put(2, "小红");
		hs.put(3, "小蓝");
		//通过key获取value
		Iterator<Integer>it=hs.keySet().iterator();//获取key的集合，再获取迭代器
		while(it.hasNext()) {
			Integer key=it.next();// 获取key
			String string=hs.get(key);// 通过key获取value
			System.out.println(string);
		}
		System.out.println("###########################################");
		//使用entrySet
		Set<Entry<Integer,String>>s=hs.entrySet();
		for (Iterator iter=s.iterator(); iter.hasNext(); ) {
			Entry e=(Entry) iter.next();
			System.out.println(e.getValue());
		}
	}
}

运行结果
在这里插入图片描述
4.Collections工具类
Collections工具类包含了许多对集合操作的方法，下面简单讲解几个

（1）shuffle()将集合中的元素随机打乱

import java.util.ArrayList;
import java.util.Collections;

public class test4 {
	public static void main(String[] args) {
		ArrayList<String>list=new ArrayList<>();
		//添加元素
		list.add("小明");
		list.add("小红");
		list.add("小刚");
		System.out.println("-------------打乱前--------------");
		for (String string : list) {
			System.out.println(string);
		}
		Collections.shuffle(list);//shuffle()打乱
		System.out.println("-------------打乱后--------------");
		for (String string : list) {
			System.out.println(string);
		}
	}
}

运行结果
在这里插入图片描述
（2）revers（）逆序

import java.util.ArrayList;
import java.util.Collections;

public class test5 {
	public static void main(String[] args) {
		ArrayList<String>list=new ArrayList<>();
		//添加元素
		list.add("小明");
		list.add("小红");
		list.add("小刚");
		System.out.println("-------------逆序前--------------");
		for (String string : list) {
			System.out.println(string);
		}
		Collections.reverse(list);//reverse()逆序
		System.out.println("-------------逆序后--------------");
		for (String string : list) {
			System.out.println(string);
		}
	}
}

运行结果
在这里插入图片描述
（3）sort（）排序，binarysearch（）二分查找等方法不再讲解，大家自己测试