Java集合框架（List、Set、Map、Queue）

最新推荐文章于 2021-02-12 18:10:29 发布
最新推荐文章于 2021-02-12 18:10:29 发布
阅读量612 收藏 1
点赞数
分类专栏： Java高级特性 文章标签： java 语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37465004/article/details/74992153
版权

Java集合框架：Java.util

                               ---------》List接口---------》ArrayList实现类、LinkedList实现

collection接口

      ----------》Set接口---------》HashSet实现类、TreeSet实现类


     ----------》HashMap实现类

Map接口

                            -----------》TreeMap实现类

ArrayList用法：

特点：有序可重复，底层实现是数组，线程不安全，效率高，查询快，修改、删除、插入慢

/**
 * 测试ArrayList
 */
import java.util.ArrayList;
import java.util.List;

public class TestArraylist {

	public static void main(String[] args) {
		Dog ouou = new Dog("欧欧", "雪纳瑞");
		Dog yaya = new Dog("丫丫", "拉布拉多");
		Dog meimei = new Dog("美美", "雪纳瑞");
		Dog feifei = new Dog("菲菲", "土狗");
		Penguin qiqi = new Penguin("奇奇", "帝企鹅");
		List pets = new ArrayList();//创建ArrayList对象
		pets.add(ouou);//添加对象
		pets.add(yaya);
		pets.add(meimei);
		pets.add(2, feifei);
		pets.add(qiqi);
		// 删除前
		System.out.println(pets.size());//获取列表元素个数
		System.out.println("分别是：");
		for (int i = 0; i < pets.size(); i++) {
			Pet pet = (Pet) pets.get(i);
			if (pet instanceof Dog) {
				Dog dog = (Dog) pet;//默认为Object类型
				System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
			} else {
				Penguin penguin = (Penguin) pet;
				System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
			}
		}
		pets.remove(0);//移除
		System.out.println(pets.size());
		System.out.println("分别是：");
		for (int i = 0; i < pets.size(); i++) {
			Pet pet = (Pet) pets.get(i);
			if (pet instanceof Dog) {
				Dog dog = (Dog) pet;
				System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
			} else {
				Penguin penguin = (Penguin) pet;
				System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
			}
		}
		pets.remove(feifei);
		System.out.println(pets.size());
		// 删除后

		System.out.println("分别是：");
		for (int i = 0; i < pets.size(); i++) {
			Pet pet = (Pet) pets.get(i);
			if (pet instanceof Dog) {
				Dog dog = (Dog) pet;
				System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
			} else {
				Penguin penguin = (Penguin) pet;
				System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
			}
		}
		if (pets.contains(ouou)) {
			System.out.println("存在");
		} else {
			System.out.println("不存在");

		}
	}

}

LinkedList用法：

特点：有序可重复，底层实现是链表，线程不安全，效率高，查询慢，修改、删除、插入快

import java.util.LinkedList;


/**
 * 测试LinkedList
 * 
 * @author 30869
 *
 */
public class TestLinkedList {


public static void main(String[] args) {
Dog ouou = new Dog("欧欧", "雪纳瑞");
Dog yaya = new Dog("丫丫", "拉布拉多");
Dog meimei = new Dog("美美", "雪纳瑞");
Dog feifei = new Dog("菲菲", "土狗");
Penguin qiqi = new Penguin("奇奇", "帝企鹅");
LinkedList pets = new LinkedList();
pets.add(ouou);
pets.add(yaya);
pets.addFirst(meimei);
pets.add(2, feifei);
pets.addLast(qiqi);
System.out.println("分别是：");
for (int i = 0; i < pets.size(); i++) {
Pet pet = (Pet) pets.get(i);
if (pet instanceof Dog) {
Dog dog = (Dog) pet;
System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
} else {
Penguin penguin = (Penguin) pet;
System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
}
}
Dog dog = (Dog) pets.getFirst();
System.out.println("查看第一条内容：" + dog.getName() + "\t" + dog.getStrain());
Penguin penguin = (Penguin) pets.getLast();
System.out.println("查看最后一条内容：" + penguin.getName() + "\t" + penguin.getStrain());
pets.removeFirst();// 删除第一条
System.out.println("删除第一条");
for (int i = 0; i < pets.size(); i++) {
Pet pet = (Pet) pets.get(i);
if (pet instanceof Dog) {
dog = (Dog) pet;
System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
} else {
penguin = (Penguin) pet;
System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
}
}
pets.removeLast();// 删除最后一条
System.out.println("删除最后一条");
for (int i = 0; i < pets.size(); i++) {
Pet pet = (Pet) pets.get(i);
if (pet instanceof Dog) {
dog = (Dog) pet;
System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
} else {
penguin = (Penguin) pet;
System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
}
}
}


}

HashSet的用法：

特点：无序，不可重复，可以存储相同的元素，但是size()和Iterator.next()方法只返回不同元素的个数和值，底层实现是HashMap,

    add()方法的参数作为HashMap的key,Value为常量

优点：查询效率比较高
/**
 * 测试HashSet
 */
import java.util.HashSet;
import java.util.Set;


public class TestHashSet {


public static void main(String[] args) {
Dog ouou = new Dog("欧欧", "雪纳瑞");
Dog yaya = new Dog("丫丫", "拉布拉多");
Dog meimei = new Dog("美美", "雪纳瑞");
Dog feifei = new Dog("菲菲", "土狗");
Penguin qiqi = new Penguin("奇奇", "帝企鹅");
Set pets = new HashSet();
pets.add(ouou);
pets.add(yaya);
pets.add(meimei);
pets.add(feifei);
pets.add(qiqi);
for (Object pet : pets) {
if (pet instanceof Dog) {
Dog dog = (Dog) pet;
System.out.println("名字：" + dog.getName() + "\t品种：" + dog.getStrain());
} else {
Penguin penguin = (Penguin) pet;
System.out.println("名字：" + penguin.getName() + "\t品种：" + penguin.getStrain());
}
}
}


}



HashMap用法：

特点：存储方式为key-value(键值对)，key无序，不可重复，value无序，可重复，底层实现是数组+链表（每个索引位置包含一个链表）

优点：查询指定元素效率比较高



/**
 * 测试HashMap
 */
import java.util.HashMap;
import java.util.Map;


public class TestHashMap {


public static void main(String[] args) {
Map countrys = new HashMap();
countrys.put("CN", "中国");
countrys.put("FN", "法国");
countrys.put("AN", "美国");
System.out.println("CN对应的是：" + countrys.get("CN"));
System.out.println("FN对应的是：" + countrys.get("FN"));
System.out.println("元素个数：" + countrys.size());
System.out.println("是否包含AN键:" + countrys.containsKey("AN"));
countrys.remove("AN");
System.out.println("移除之后是否包含AN键:" + countrys.containsKey("AN"));
System.out.println("键：" + countrys.keySet());
System.out.println("值：" + countrys.values());
System.out.println("是否为空：" + countrys.isEmpty());
countrys.clear();
System.out.println("清空后是否为空：" + countrys.isEmpty());
}


}

 

HashTable与HashMap的区别：

1、HashMap 线程不安全，非同步，效率相对高

      HashTable线程安全，同步，效率先对低

2、HashMap父类是AbstractMap

      HashTable父类是Dictionary

3、HashMap键可以有一个null，值可以有多个null

      HashTable键值都不能为null


关于WeakHashMap的特点:

强引用类型：字符串常量   String str="xxx";

弱引用类型：字符串对象   String str=new String("xxx");

如果key弱引用类型，通知gc则立即回收，适合用于内容过多，需要释放内存的Map

gc回收方法：

System.gc();

System.runfinalization();



关于 IdentityHashMap的特点：

key比较的是地址、去重

如果key为常量池的字符串，则value会覆盖

IdentityHashMap<String, String> iHashMap=new IdentityHashMap<String,String>();
iHashMap.put("a", "a1");
iHashMap.put("a", "a2");
iHashMap.put("a", "a3");
System.out.println(iHashMap.size());//结果是1
System.out.println(iHashMap.get("a"));

//输出结果是a3



IdentityHashMap<String, String> iHashMap=new IdentityHashMap<String,String>();
iHashMap.put(new String("a"), "a1");
iHashMap.put(new String("a"), "a2");
iHashMap.put(new String("a"), "a3");
System.out.println(iHashMap.size());//结果是3
}


关于EnumMap:

import java.util.EnumMap;

/**
 * 测试EnumMap
 * @author 30869
 *要求key必须是枚举值
 */
public class TestEnumMap {

	public static void main(String[] args) {
		EnumMap<Season, String> enumMap=new EnumMap<Season, String>(Season.class);
		enumMap.put(Season.SPRING, "春困");
		enumMap.put(Season.SUMMER, "夏无力");
		enumMap.put(Season.AUTUMN, "秋乏");
		enumMap.put(Season.WINTER, "冬眠");
		System.out.println(enumMap.size());
	}

}
/**
 * 季节枚举
 * @author 30869
 *
 */
enum Season{
	SPRING,SUMMER,AUTUMN,WINTER
}



TreeSet:





public class Person {
private final String name;//名字   final类型，TreeSet元素排序后不可更改
private final int handsome;//帅气指数 
public Person() {
name=null;
handsome=0;
}
public Person(String name, int handsome) {
super();
this.name = name;
this.handsome = handsome;
}
public String getName() {
return name;
}

public int getHandsome() {
return handsome;
}

@Override
public String toString() {
return "姓名："+this.name+"，帅气指数："+this.handsome+"\n";//重写toString，为了打印输出直观
}
}




import java.util.TreeSet;


/**
 * TreeSet容器  使用解耦方式 实现业务排序类
 * 数据特点：去重（不可重复）
 * 不要修改数据，可能造成数据重复
 * @author 30869
 *
 */


public class TreeSet_Test_function1 {


public static void main(String[] args) {
Person persons1=new Person("李林",1000);
Person persons2=new Person("杨洋",999);
Person persons3=new Person("陈学冬",1001);
Person persons4=new Person("鹿晗",1002);
Person persons5=new Person("王俊凯",999);
//将数据放进TreeSet中
TreeSet<Person> treeSet=new TreeSet<Person>(
//需要使用排序的业务类（匿名内部类）
new java.util.Comparator<Person>(){


public int compare(Person o1, Person o2) {
return o1.getHandsome()-o2.getHandsome();
}

}
);
//TreeSet在添加数据是排序
treeSet.add(persons1);
treeSet.add(persons2);
treeSet.add(persons3);
treeSet.add(persons4);
treeSet.add(persons5);

System.out.println(treeSet);
/* //改变数据,排序顺序依然不变（因为TreeSet是在添加时进行排序）
persons2.setHandsome(10000);
//修改数据造成重复
persons4.setHandsome(10000);
persons4.setName("杨洋");
System.out.println(treeSet);*/

}


}




import java.util.TreeSet;


/**
 * TreeSet 实体类实现Comparable的应用
 * @author 30869
 *
 */
public class TreeSet_Test_function2 {


public static void main(String[] args) {
Worker w1=new Worker("垃圾回收员",12000);
Worker w2=new Worker("程序员",6000);
Worker w3=new Worker("架构师",15000);
Worker w4=new Worker("工厂职员",5000);
TreeSet<Worker> workers=new TreeSet<Worker>();
workers.add(w1);
workers.add(w2);
workers.add(w3);
workers.add(w4);
System.out.println(workers);

}


}

TreeMap:


import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;


public class TreeMap_Test_function1 {
/**
* TreeMap容器  使用解耦方式 实现业务排序类(匿名内部类)
* 数据特点：去重（不可重复）
* 不要修改数据，可能造成数据重复
* @author 30869
*
*/
public static void main(String[] args) {
Person persons1=new Person("李林",1000);
Person persons2=new Person("杨洋",999);
Person persons3=new Person("陈学冬",1001);
Person persons4=new Person("鹿晗",1002);
Person persons5=new Person("王俊凯",999);
//将数据放进TreeMap中
TreeMap<Person,String> treeMap=new TreeMap<Person,String>(
//需要使用排序的业务类（匿名内部类）
new java.util.Comparator<Person>(){


public int compare(Person o1, Person o2) {
return o1.getHandsome()-o2.getHandsome();
}

}
);
//TreeMap在添加数据时排序
treeMap.put(persons1,"李林");
treeMap.put(persons2,"李林");
treeMap.put(persons3,"李林");
treeMap.put(persons4,"李林");
treeMap.put(persons5,"李林");
Set<Person> persons=treeMap.keySet();//查看键
System.out.println(persons);


}


}






import java.util.Set;
import java.util.TreeMap;


/**
 * TreeMap 实体类实现Comparable的应用
 * @author 30869
 *
 */
public class TreeMap_Test_function2 {


public static void main(String[] args) {
Worker w1=new Worker("垃圾回收员",12000);
Worker w2=new Worker("程序员",6000);
Worker w3=new Worker("架构师",15000);
Worker w4=new Worker("工厂职员",5000);
TreeMap<Worker, String> treeMap=new TreeMap<Worker, String>();
treeMap.put(w1, "李林");
treeMap.put(w2, "李林");
treeMap.put(w3, "李林");
treeMap.put(w4, "李林");
Set<Worker> workers=treeMap.keySet();//查看键
System.out.println(workers);
}


}


Queue:

特点：分为单向队列和双向队列

单向：

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * 测试队列Queue接口，单向队列ArrayDeque，FIFO（先进先出）
 * 模拟银行存款
 * @author 30869
 *
 */
public class TestQueue {

	public static void main(String[] args) {
		Queue<Request> queue=new ArrayDeque<Request>();//创建Queue接口的实现类ArrayDeque对象
		//办理业务
		for(int i=0;i<10;i++){
			final int num=i;//匿名内部类只能访问常量属性，所以用num接收i即可
			queue.offer(new Request() {//这里相当于创建一个实现Request接口的匿名类对象，将对象插入ArrayDeque
				
				@Override
				public void deposit() {//实现接口的抽象存款方法
					System.out.println("第"+(num+1)+"个人办理业务，存款金额"+(Math.random()*10000));
				}
			});
		}
		dealwith(queue);//调用静态方法处理业务，传入队列对象
	}
	/**
	 * 处理业务，也就是获取并移除queue中的元素，使用ArrayDeque的poll()方法
	 * @param queue 队列
	 */
	public static void dealwith(Queue<Request> queue){
		Request request=null;//需要定义一个对应的空属性接收
		while(null!=(request=queue.poll())){
			request.deposit();//调用对象的方法，输出信息
		}
	}

}
interface Request{//请求
	void deposit();//存款
}

双向：

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * 使用双向队列实现自定义堆栈（1、弹栈 ，2、压栈、3、获取头）
 * @author 30869
 *
 * @param <E>
 */
public class MyStack<E> {
	private Deque<E> deque=new ArrayDeque<E>();//存储字符串的双向队列
	private int cap;//队列容量
	/**
	 * 压栈
	 * @return  超出容量返回false,否则添加元素至最后位置
	 */
	public boolean push(E e){
		if(deque.size()+1>cap){
			return false;
		}
		return deque.offerLast(e);
	}
	/**
	 * 弹栈
	 * @return  获取并移除的最后一个元素
	 */
	public E pop(){
		return deque.pollLast();
	}
	/**
	 * 获取头
	 * @return 
	 */
	public E peek(){
		return deque.peekLast();
	}
	/**
	 * 获取队列元素个数
	 * @return
	 */
	public int size(){
		return deque.size();
	}
	public MyStack() {
	}
	
	/**
	 * 构造方法只需要指定容量
	 * @param cap
	 */
	public MyStack(int cap) {
		super();
		this.cap = cap;
	}
}












/**
 * 测试使用双向队列Deque接口自定义的堆栈
 * @author 30869
 *
 */
public class TestMystack {

	public static void main(String[] args) {
		MyStack<String> myStack=new MyStack<String>(3);//容量为3的堆栈
		myStack.push("www.baidu.com");
		myStack.push("www.google.com");
		myStack.push("www.sina.com");
		myStack.push("www.lilin.com");//指定了容量，所以这条信息不会压
		System.out.println("大小："+myStack.size());
			String str=null;//接收弹栈信息
			int count=0;
			while(null!=(str=myStack.pop())){
				System.out.println(str);
		}
	}

}











                

        

        

    

  


    

      

        

            

              
                
                  qq_37465004
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
Java四大集合List、Set、Queue、Map特点

				
			

			

				

					qq_44724453的博客
				

				

					12-23
					
					1187
					
				

			

		

		

			
				
集合类主要由Collection和Map两个接口派生出来的
Collection又派生出3个接口，List、Set、Queue
共四大类
List


ArrarList

可调整大小的数组实现
初始容量Math.max(DEFAULT_CAPACITY, minCapacity)最小是10或指定>10的
阈值size()
扩容 int newCapacity = oldCapacity + (oldCapacity >> 1)  1.5倍
有序，可重复
线程不安全
允许有null
查找时

			
		

	



                

              
                



	

		

			

				
					
Java集合框架-List、Set、Map

				
			

			

				

					weixin_67224308的博客
				

				

					07-31
					
					657
					
				

			

		

		

			
				
Map与Collection并列存在。用于保存具有映射关系的数据:key-value。Map 中的 key 和 value 都可以是任何引用类型的数据。Map 中的 key 用Set来存放，不允许重复，即同一个 Map 对象所对应的类，须重写hashCode()和equals()方法。常用String类作为Map的“键”。key 和 value 之间存在单向一对一关系，即通过指定的 key 总能找到唯一的、确定的 value。

			
		

	



                


  
              

                


	

		

			

				
					
java集合框架总结（List、Set、Map）

				
			

			

				

					taotao12312的博客
				

				

					05-22
					
					815
					
				

			

		

		

			
				
从上面的集合框架图可以看到，Java集合框架主要包括两种类型的容器，一种是集合（Collection），存储一个元素集合，另一种是图（Map），存储键/值对映射。Collection接口又有3种子类型，List、Set和Queue。Set的集合里不允许对象有重复的值，List允许有重复，Map不允许key重复。常用的集合框架有ArrayList、LinkedList、Vector、HashSet、H

			
		

	





	

		

			

				
					
Java 常用集合框架List、Set、Map和Queue等体系汇总

				
			

			

				

					360°顺滑
				

				

					04-10
					
					1150
					
				

			

		

		

			
				
一、集合框架二、Collection接口1、List接口（1）ArrayList（2）LinkedList（3）Vector（4）Stack2、Set接口（1）HashSet（2）LinkedHashSet（3）TreeSet（4）List 和 Set 适用场景（5）使用示例3、Queue三、Map接口（1）HashMap 和 Hashtable（2）LinkedHashMap（3）TreeMa...

			
		

	



		

			
		



	

		

			

				
					
Java集合框架List，Map，Set， Queue介绍

				
			

			

				

					javaxiaojian的专栏
				

				

					06-29
					
					2803
					
				

			

		

		

			
				
Java Collections Framework是Java提供的对集合进行定义，操作，和管理的包含一组接口，类的体系结构。
 
Collection接口
    Collection是最基本的集合接口，一个Collection代表一组Object的集合，这些Object被称作Collection的元素。
    所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的

			
		

	





	

		

			

				
					
java集合类set、map、list、queue的基本架构梳理

				
			

			

				

					monkey-jie的博客
				

				

					11-07
					
					322
					
				

			

		

		

			
				
本文主要介绍java集合类的基本概念和层次关系
整理至：https://www.cnblogs.com/LittleHann/p/3690187.html
1. Java集合类基本概念
在编程中，常常需要集中存放多个数据。从传统意义上讲，数组是我们的一个很好的选择，前提是我们事先已经明确知道我们将要保存的对象的数量。一旦在数组初始化时指定了这个数组长度，这个数组长度就是不可变的，如果我们需要保存一...

			
		

	





	

		

			

				
					
Java集合List，Set，Map，Queue，Deque

				
			

			

				

					weihao_的博客
				

				

					07-07
					
					521
					
				

			

		

		

			
				
集合是Java基础中非常重要的一部分，Java提供了非常丰富的集合API，了解各个集合的特点，怎么样在各种各样的场景中使用正确的集合，非常重要，也是一个Java程序员最基本的素养。

整体了解

Java最基本，最常用的的集合主要有，Set，List，Map，Queue，Deque。
	Collection是集合List，Set，Queue的最顶层接口。Collection继承自Iterable接...

			
		

	





	

		

			

				
					
集合框架(最终版)-list接口、set接口、Queue接口、Map接口

					
最新发布

				
			

			

				

					07-23
				

			

		

		

			
				
集合框架(最终版)-list接口、set接口、Queue接口、Map接口

			
		

	





	

		

			

				
					
java 集合(list-queue-set)学习

				
			

			

				

					01-25
				

			

		

		

			
				
首先，List接口是Java集合框架中用于存储有序元素的接口，它允许元素重复，并且可以通过索引来访问元素。ArrayList和LinkedList是List接口的两种常见实现。ArrayList基于动态数组，适合于频繁的随机访问，因为它的...

			
		

	





	

		

			

				
					
JAVA集合框架专题

				
			

			

				

					08-19
				

			

		

		

			
				
* 集合类主要由两个根接口Collection和Map派生出来的，Collection派生出了三个子接口：List、Set、Queue（Java5新增的队列）。  二、JAVA集合常见接口及实现类  1. Collection接口  Collection接口是JAVA集合框架的...

			
		

	





	

		

			

				
					
集合框架List、Queue、Set

				
			

			

				

					chzech的博客
				

				

					05-16
					
					176
					
				

			

		

		

			
				
List
1.ArrayList - 数组 - 查找效率高
(1)构造方法
–ArrayList()
构造一个初始容量为 10 的空列表。
–ArrayList(int initialCapacity)
构造一个具有指定初始容量的空列表。
(2)常用方法
–boolean add(E e)
将指定的元素添加到此列表的尾部。
–void add(int index, E element)
将指定...

			
		

	





	

		

			

				
					
java 数组与集合学习

				
			

			

				

					凉快
				

				

					06-09
					
					267
					
				

			

		

		

			
				
数组与集合的区别：

1. 内容：

 数组存储同一种类型的元素，

 集合可以存储不同类型的元素（我们这么做的时候很少）

2. 长度：

 数组 长度固定

 集合长度不固定

3. 元素的数据类型：

 数组可以存储基本类型和引用类型

 集合只能存储引用类型





定义数组的两种方式：


// 我们推荐而且常用第一种
type[] arrayName;
type ...

			
		

	





	

		

			

				
					
java集合框架-使用List储存企鹅信息练习

				
			

			

				

					Zwjwen的博客
				

				

					05-28
					
					5107
					
				

			

		

		

			
				
这个练习主要运用到ArrayList集合，通过add方法来把元素插入到ArrayList集合中，并用remove方法来删除集合中的部分元素。
一，首先要写一个企鹅类
企鹅类
public class Penguin extends Pet {
	private String sex;// 性别
	/**
	 * 有参构造方法。
	 * @param name 昵称
	 * @param sex 性别
	 */
	public Penguin(String name, String sex) {
		supe

			
		

	





	

		

			

				
					
List、Set、Map 和 Queue 之间的区别

					
热门推荐

				
			

			

				

					弗兰-随风小欢的博客
				

				

					12-20
					
					1万+
					
				

			

		

		

			
				
分享楼主看到的一道Java面试题：


List、Set、Map 和 Queue 之间的区别：
List 是一个有序集合，允许元素重复。它的某些实现可以提供基于下标值的常量访问时间，但是这不是 List 接口保证的。Set 是一个无序集合。



由于给出的答案过于简单，楼主对其进行了进一步的探索，在网上寻找到一些资料，对其具体的区别进行进一步的挖掘，得到了这些知识：

			
		

	





	

		

			

				
					
Java集合体系总结—Map、Set、List、Queue

				
			

			

				

					嘤其鸣矣，求其友声
				

				

					06-11
					
					4305
					
				

			

		

		

			
				
首先上来一张自己画的图，主要根据《疯狂Java讲义》一书中的两个图整合而来。主要讲解重要的集合及其特点。 
0x01 Collection 接口 
Collection接口比较宽泛，该集合就是单一对象的集合（对比Map容器，是key-value这样的一对元素构成的键值对的集合）。一般作为工具使用，比如在“向上转型”中，定义一个Collection对象接受任何实现类， 该接口提供了很多有用的API，比

			
		

	





	

		

			

				
					
Java集合类List、Set、Queue、Map实现类

				
			

			

				

					xiaoguangtouqiang的博客
				

				

					03-11
					
					5657
					
				

			

		

		

			
				
1.Collection    Collection最基本的集合接口，一个Collection代表一组Object的集合public interface Collection&lt;E&gt; extends Iterable&lt;E&gt; {任何实现Collection接口的类，都必须实现iterator方法来提供遍历集合中的元素Iterator&lt;T&gt; iterator();例如...

			
		

	





	

		

			

				
					
Java中集合类常见set、list(Queue)、map特性总结

				
			

			

				

					endwas
				

				

					02-12
					
					416
					
				

			

		

		

			
				
Java中的集合类总共有三种：set、list（列表包含Queue）、map

Collection: Collection是集合List、Set、Queue的基本接口
Iterator：迭代器，可以通过迭代器来遍历集合数据，同时使用这种方法不会造成数据越界异常，所以在遍历删除的时候务必使用。
Map：是映射表的基础接口。


集合框架
List集合




List集合
实现方式
排列顺序
增删改查
线程安全
特点




ArrayList
底层使用数组
排列有序，可重复
速度快、增删慢
线程不安全
容

			
		

	





	

		

			

				
					
集合框架

				
			

			

				

					Dylan_wf的博客
				

				

					11-01
					
					269
					
				

			

		

		

			
				
集合框架继承关系图： 
 
Java集合框架提供了一套性能优良，使用方便的接口和类，位于java.util包内。集合框架包含三大内容，对外的接口，接口的实现类，和对集合运算的算法。对外的接口：表示集合的抽象数据类型（Collection,List,Set,Map,Iterator）。 
**接口的实现类：**ArrayList,LinkedList,HashSet,TreeSet,HashMap,T

			
		

	





	

		

			

				
					
Java集合框架详解：Set, List, Map, Queue

				
			

			

				

					
				

			

		

		

			
				
本摘要将深入探讨Java集合的主要组成部分：Set、List、Map和Queue四大体系，并分析它们的特点、接口和常用实现类。  Set接口是Java集合框架的一个重要组成部分，它不允许重复元素的存在。Set接口的实现类如HashSet，...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值