深入理解Java集合

最新推荐文章于 2022-01-10 15:03:55 发布
最新推荐文章于 2022-01-10 15:03:55 发布
阅读量919 收藏 10
点赞数 2
分类专栏： java-集合 文章标签： java集合 java集合的底层实现 java集合特点 java集合的种类 java集合遍历
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_30162219/article/details/86762418
版权

目录

 

一.集合概述 

二.List

2.1 手动实现简单的ArrayList

2.2 手动实现LinkeList

三.Map

3.1 手动实现HashMap

3.2 TreeMap

四.Set

4.1 手动实现HashSet

4.2 TreeSet

​

五.集合的遍历

5.1 遍历List

5.2 遍历Set

5.3 遍历Map

六.Collections

七.集合总结

一.集合概述 

二.List

2.1 手动实现简单的ArrayList

public class MyArrayList<E> {
	//底层是一个数组
	private Object[]  elementData;
	//定义一个变量标记数组所含内容的数量
	private int  size;
	//定义数组长度
	private static final int DEFALT_CAPACITY = 10 ;
	
	//无参构造初始化一个长度为10的Object数组
	public MyArrayList(){
		elementData = new Object[DEFALT_CAPACITY]; 
	}
	//有参构造传递一个int变量构造数组
	public MyArrayList(int  capacity) {
		
		if(capacity<0){
			throw  new  RuntimeException("容器的容量不能为负数");
		} else if(capacity==0){
			elementData  = new Object[DEFALT_CAPACITY];
		}else{
			elementData  = new Object[capacity];
		}
		
		
	}
	
	public int size(){
		return size;
	}
	
	public  boolean isEmpty(){
		return  size==0?true:false;
	}
	
	
	public  void  add(E  element){
		
		//什么时候扩容？？
		if(size == elementData.length){
			//扩容操作
			Object[]  newArray  =  new Object[elementData.length+(elementData.length>>1)];  //10-->10+10/2
			//使用系统函数进行拷贝，将旧数组中从0开始的内容拷贝到新数组中下标0开始的位置
			System.arraycopy(elementData, 0, newArray, 0, elementData.length); 
			elementData = newArray;
		}
		
		elementData[size++] = element;
	}
	
	public  E  get(int index) {
		
		checkRange(index);
		
		return  (E)elementData[index];
	}
	
	public void set(E element, int  index) {
		
		checkRange(index);
		
		elementData[index] = element;
		
	}
	
	public  void  checkRange(int index ){
		//索引合法判断 [0,size)    10    0-9
				if(index<0||index>size-1){
					//不合法
					throw  new RuntimeException("索引不合法:"+index);
				}
	}
	
	public void  remove(E  element){
		//element，将它和所有元素挨个比较，获得第一个比较为true的，返回。
		for(int i=0;i<size;i++){
			if(element.equals(get(i))){   //容器中所有的比较操作，都是用的equals而不是==
				
				//将该元素从此处移除
				remove(i);
			}
		}
	}
	
	public  void  remove(int index){
		
		//a,b,c,d,e,f,g,h
		//a,b,c,e,f,g,h,h
		int numMoved = elementData.length-index-1;
		if(numMoved>0){
			System.arraycopy(elementData, index+1, elementData, index, numMoved);
		}
		
		elementData[--size] = null;
		
	}
	
	
	@Override
	public String toString() {
		
		StringBuilder  sb = new StringBuilder();
		
		//[a,b,c]
		sb.append("[");
		for(int i=0;i<size;i++){
			sb.append(elementData[i]+",");
		}
		sb.setCharAt(sb.length()-1, ']'); 
		
		return  sb.toString();
	}
	
}

2.2 手动实现LinkeList

创建节点类

public class Node {
	
	Node  previous;		//上一个节点
	Node next;				//下一个节点

	Object element;		//元素数据
	
	public Node(Node previous, Node next, Object element) {
		super();
		this.previous = previous;
		this.next = next;
		this.element = element;
	}

	public Node(Object element) {
		super();
		this.element = element;
	}
	
}

实现类

public class MyLinkedList<E> {
	
	private  Node  first;
	private  Node  last;
	
	private  int size;
	
	public  void  add(int index, E  element) {
		
		checkRange(index);
		
		Node  newNode = new Node(element);
		Node  temp  =  getNode(index);
		
		if(temp!=null){
			Node up = temp.previous;
			
			up.next = newNode;
			newNode.previous = up;
			
			newNode.next = temp;
			temp.previous = newNode;
		}
		
	}
	
	public   void  remove(int index){
		checkRange(index);
		Node  temp  =  getNode(index);
		
		if(temp!=null){
			Node  up = temp.previous;
			Node down = temp.next;
			
			if(up!=null){
				up.next = down;
			}
			
			if(down!=null){
				down.previous = up;
			}
			
			if(index==0){
				first = down;
			}
			
			if(index == size-1){
				last = up;
			}
			
			size--;
		}
		
	}
	
	//[]    
	//["a","b","c","d","e","f"]           2
	public  E  get(int index) {  
	
		checkRange(index);
		
		Node temp = getNode(index);
		
		return temp!=null?(E)temp.element:null;
	}
	
	private  void  checkRange(int index){
		if(index<0||index>size-1){
			throw  new RuntimeException("索引不合法:"+index);
		}
	}
	
	
	
	private   Node  getNode(int index){
		
		checkRange(index);
		
		Node  temp = null;
		
		if(index<=(size>>1)){   
			temp = first;
			for(int i=0;i<index;i++){
				temp = temp.next;
			}
		}else{
			temp = last;
			for(int i=size-1; i>index;i--){
				temp = temp.previous;
			}
		}
		
		return temp;
	}
	
	public  void  add(E  element) {
		Node  node  = new Node(element);
		
		if(first==null){
//			node.previous = null;
//			node.next = null;
			first = node;
			last = node;
		}else{
			
			node.previous = last;
			node.next = null;
			
			last.next = node;
			last = node;
			
		}
		
		size++;
		
	}
	
	@Override
	public String toString() {
		//[a,b,c]     first=a,    last=c
		//a,b,c
		StringBuilder   sb = new StringBuilder("[");
		Node  temp = first;
		while(temp!=null){
			sb.append(temp.element+",");
			temp = temp.next;
		}
		sb.setCharAt(sb.length()-1, ']'); 
		
		return sb.toString();
	}	
	
}

三.Map

3.1 手动实现HashMap

//节点类
public class Node3<K,V> {
	
	int  hash;
	K  key;
	V  value;
	Node3  next; 
	
}
//实现类
public class MyHashMap04<K,V> {
	
	Node3[]  table;    //位桶数组。bucket  array
	int size;				//存放的键值对的个数
	
	public MyHashMap04() {
		table = new Node3[16];    //长度一般定义成2的整数幂
	}
	
	
	public  V  get(K  key){
		
		int  hash = myHash(key.hashCode(), table.length);
		V value = null; 
		
		if(table[hash]!=null){
			Node3  temp = table[hash];
			
			while(temp!=null){
				
				if(temp.key.equals(key)){   //如果相等，则说明找到了键值对，返回相应的value
					value = (V)temp.value;
					break;
				}else{
					temp = temp.next;
				}
			}
			
		}
		
		return value;
	}
	
	
	public  void   put(K key,  V   value){
		
		//如果要完善，还需要考虑数组扩容的问题！！！
		
		//定义了新的节点对象
		Node3    newNode = new Node3();
		newNode.hash = myHash(key.hashCode(),table.length);
		newNode.key =  key;
		newNode.value = value;
		newNode.next = null;
		
		Node3 temp = table[newNode.hash];
		
		Node3  iterLast = null;  //正在遍历的最后一个元素
		boolean  keyRepeat = false;  
		if(temp==null){
			//此处数组元素为空，则直接将新节点放进去
			table[newNode.hash] = newNode;
			size++;
		}else{
			//此处数组元素不为空。则遍历对应链表。。
			while(temp!=null){
				
				//判断key如果重复，则覆盖
				if(temp.key.equals(key)){
					keyRepeat = true;
					temp.value =  value;  //只是覆盖value即可。其他的值(hash,key,next)保持不变。
					
					break;
					
				}else{
					//key不重复，则遍历下一个。
					iterLast = temp;
					temp = temp.next;
					
				}
			}
			
			if(!keyRepeat){   //没有发生key重复的情况，则添加到链表最后。
				iterLast.next = newNode;
				size++;
			}
			
		}
		
		
		
	}

	
	@Override
	public String toString() {
		//{10:aa,20:bb}
		StringBuilder  sb = new StringBuilder("{");
		
		//遍历bucket数组
		for(int i=0;i<table.length;i++){
			Node3  temp = table[i]; 
			
			//遍历链表
			while(temp!=null){
				sb.append(temp.key+":"+temp.value+",");
				temp  = temp.next;
			}
		}
		sb.setCharAt(sb.length()-1, '}'); 
		return sb.toString();
		
	}
}

3.2 TreeMap

/**
 * 测试TreeMap的使用
 * @author Administrator
 *
 */
public class TestTreeMap {
	public static void main(String[] args) {
		Map<Integer,String>  treemap1 = new TreeMap<>();
		treemap1.put(20, "aa");
		treemap1.put(3, "bb");
		treemap1.put(6, "cc");
		
		//按照key递增的方式排序
		for(Integer  key:treemap1.keySet()){
			System.out.println(key+"---"+treemap1.get(key)); 
		}
		
		
		Map<Emp,String>  treemap2 = new TreeMap<>();
		treemap2.put(new Emp(100,"张三",50000), "张三是一个好小伙");
		treemap2.put(new Emp(200,"李四",5000), "李四工作不积极");
		treemap2.put(new Emp(150,"王五",6000), "王五工作还不错");
		treemap2.put(new Emp(50,"赵六",6000), "赵六是个开心果");
		
		//按照key递增的方式排序
		for(Emp  key:treemap2.keySet()){
			System.out.println(key+"---"+treemap2.get(key)); 
		}		
		
	}
}

class Emp  implements Comparable<Emp>  {
	int id;
	String name;
	double salary;
	
	public Emp(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return  "id:"+id+",name:"+name+",salary:"+salary;
	}
	
	@Override
	public int compareTo(Emp o) {		//负数：小于，0：等于，正数：大于
		
		if(this.salary>o.salary){
			return 1;
		}else if(this.salary<o.salary){
			return -1;
		}else{
			if(this.id>o.id){
				return 1;
			}else if(this.id<o.id){
				return -1;
			}else{
				return 0;
			}
		}
		
	}
	
}

四.Set

4.1 手动实现HashSet

public class MyHashSet {
	
	HashMap map;
	
	private static final Object  PRESENT = new Object();
	
	public MyHashSet() {
		map = new HashMap();
	}
	
	public  int  size(){
		return  map.size();
	}
	
	public void add(Object o){
		map.put(o, PRESENT);
	}
	
	@Override
	public String toString() {
		
		StringBuilder   sb = new StringBuilder();
		sb.append("[");
		
		for(Object key:map.keySet()){
			sb.append(key+",");
		}
		sb.setCharAt(sb.length()-1, ']');  
		return  sb.toString();
		
	}
	
}

4.2 TreeSet

public class TestTreeSet {
	public static void main(String[] args) {
		Set<Integer>  set = new TreeSet<>();
		
		set.add(300);
		set.add(200);
		set.add(600);
		
		//按照元素递增的方式排好序
		for(Integer m:set){
			System.out.println(m);
		}
		
		Set<Emp2>  set2 = new TreeSet<>();
		set2.add(new Emp2(100,"张三",3000));
		set2.add(new Emp2(50,"李四",2000));
		set2.add(new Emp2(150,"王五",8000));
		set2.add(new Emp2(30,"赵六",20000));
		
		for(Emp2 m:set2){
			System.out.println(m);
		}
		
	}
}



class Emp2  implements Comparable<Emp2>  {
	int id;
	String name;
	double salary;
	
	public Emp2(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}

	@Override
	public String toString() {
		return  "id:"+id+",name:"+name+",salary:"+salary;
	}
	
	@Override
	public int compareTo(Emp2 o) {		//负数：小于，0：等于，正数：大于
		
		if(this.salary>o.salary){
			return 1;
		}else if(this.salary<o.salary){
			return -1;
		}else{
			if(this.id>o.id){
				return 1;
			}else if(this.id<o.id){
				return -1;
			}else{
				return 0;
			}
		}
		
	}
	
}

五.集合的遍历

5.1 遍历List

5.2 遍历Set

5.3 遍历Map

	public static void testIteratorMap(){
		Map<Integer,String> map1 = new HashMap<>();
		map1.put(100, "aa");
		map1.put(200, "bb");
		map1.put(300, "cc");
		

		//第一种遍历Map的方式
		Set<Entry<Integer,String>>  ss =  map1.entrySet();
		for(Iterator<Entry<Integer,String>> iter=ss.iterator();iter.hasNext();){
			Entry<Integer,String> temp = iter.next();
			
			System.out.println(temp.getKey()+"--"+temp.getValue());
			
		}
		System.out.println("++++++++++++++++++++++++");
		//第二种遍历Map的方式
		Set<Integer>  keySet = map1.keySet();
		for(Iterator<Integer> iter=keySet.iterator();iter.hasNext(); ){
			Integer key = iter.next();
			System.out.println(key+"----"+map1.get(key));
		}
		
		
	}

六.Collections

/**
 * Collections辅助类的使用
 * Collection是接口，Collections是工具类
 *
 */
public class TestCollections {
	public static void main(String[] args) {
		List<String>  list  = new ArrayList<>();
		for(int i=0;i<10;i++){
			list.add("gao:"+i);
		}
		System.out.println(list);
		
		Collections.shuffle(list);	//随机排列list中的元素
		System.out.println(list);
		
		Collections.reverse(list); //逆序排列
		System.out.println(list);
		
		Collections.sort(list);		//按照递增的方式排序。自定义的类使用：Comparable接口。
		System.out.println(list);
		
		System.out.println(Collections.binarySearch(list, "gao:1")); 	//二分法查找，或者：折半查找
		
		
	}
}

七.集合总结

IT-prince老隋
关注
  • 2
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
深入Java集合学习系列
10-21
Java集合学习系列
Java集合思维导图.xmind.zip
09-13
这份"Java集合思维导图.xmind.zip"压缩包文件，显然旨在帮助学习者深入理解Java集合框架的核心原理以及不同版本间的差异。以下是关于Java集合类，特别是HashMap、CurrentHashMap、ArrayList和LinkedList的详细知识点...
java基础——LinkedBlockingQueue源码学习
奇艺诶
12-20 428
目录 类图记录 方法说明 核心源码解析 总结 类图记录 方法说明 核心方法功能描述 方法定义 功能 private void signalNotEmpty() 队列不为空，唤醒一个take线程 private void signalNotFull() 队列不满，唤醒一个put线程 private void enqueue(...
《深入理解Java集合框架》系列文章
weixin_30394981的博客
05-31 115
Introduction 关于C++标准模板库(Standard Template Library, STL)的书籍和资料有很多，关于Java集合框架(Java Collections Framework, JCF)的资料却很少，甚至很难找到一本专门介绍它的书籍，这给Java学习者们带来不小的麻烦。我深深的不解其中的原因。虽然JCF设计参考了STL，但其定位不是Java版的STL，而是要实现一个精...
深入了解Java集合
欢迎来到我的博客
01-10 520
个人笔记记录，如有错漏，恳请指教 参考来源 blog.csdn.net/hancoder/ar… jdk1.8 API中文版 snailclimb.gitee.io/javaguide/#… www.runoob.com/ 集合 数据容器，即数据组织的方式（数据结构） 集合类存放的是对象的引用 设计要求 该框架必须是高性能的。基本集合（动态数组，链表，树，哈希表）的实现也必须是高效的。 该框架允许不同类型的集合，以类似的方式工作，具有高度的互操作性。 对一个集合的扩展和适应必须...
Java深入 - 深入理解Java集合
自娱自乐的代码人
12-06 4210
List类型 Java List一共三个实现类：分别是ArrayList、Vector和LinkedList。 类型 说明 ArrayList ArrayList是最常用的List实现类，内部是通过数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从A
Java 集合深入理解：Map
qq_41418638的博客
06-17 234
Map概述 public interface Map<K,V> {｝ Java 中的 Map 接口 是和 Collection 接口 同一等级的集合根接口，它 表示一个键值对 (key-value) 的映射。 一个 Map 中，任意一个 key 都有唯一确定的 value 与其对应，这个 key-value 的映射就是 map。 Map 中元素的顺序取决于迭代器迭代时的顺序，有的实现...
深入理解Java集合框架.zip
最新发布
07-18
这个"深入理解Java集合框架.zip"文件很可能是包含了一系列关于Java集合框架的详细资料，比如源码分析、设计模式以及最佳实践。下面将详细探讨Java集合框架的关键知识点。 1. **集合接口**：Java集合框架的核心接口...
深入理解Java中的容器
02-24
在Java当中，如果有一个类专门用来存放其它类的对象，这个类就叫做容器，或者就叫做集合，集合就是将若干性质相同或相近的类对象组合在一起而形成的一个整体之所以需要容器：1、数组的长度难以扩充2、数组中数据的...
Java 集合深入理解：Collection
12-22
什么是集合？ 　· 集合，或者叫容器，是一个包含多个元素的对象； 　· 集合可以对数据进行存储，检索，操作； 　· 它们可以把许多个体组织成一个整体： 　比如一副扑克牌（许多牌组成的集合）; 　比如一个...
深入理解Java7.pdf
01-31
《深入理解Java 7》是一本专为Java开发者深度解析Java 7特性和技术的书籍。这本书涵盖了Java语言的关键更新，旨在帮助读者更好地理解和利用Java 7的新功能，提升编程效率和代码质量。通过阅读本书，你可以深入了解...
【深入学习java集合框架】总篇章
Wanna的博客
07-06 1271
Java容器里只能放对象，对于基本类型（int, long, float, double等），需要将其包装成对象类型后（Integer, Long, Float, Double等）才能放到容器里。很多时候拆包装和解包装能够自动完成。 Java集合工具包位于Java.util包下，包含了很多常用的数据结构，如数组、链表、栈、队列、集合、哈希表等。Java集合框架大致可以分为：List列表、Set集
深入理解java集合类
半路出Java
01-17 193
                               深入理解java集合类 目的：1，能够全面了解有关集合类的构造细节       2，通过对集合类的深入理解，在实际开发中能够更精准的使用这些集合类 引子 Java集合类是java程序员的编程利器。熟练，深入的理解集合类的实现细节， 能够在实际应用中做到游刃有余，更合理，更好的使用这些集合类。本文从数据结构出发，逐一分析Li...
深入理解Java集合体系
LangWeiXian_的博客
04-05 244
深入理解Java集合体系 集合体系其实一共分为两大块儿：Collection和Map,他们都与Iterator相关联 1, Collection(单值) Collection是一个接口，实现了Iterable接口，意味着所有实现Collection的类都将实现Iterator方法，他们都能生成自己的迭代器。并使用foreach遍历。 Collection中的主要抽象方法 说明 boolean add(E e) 添加 boolean remove(Object o) 删除 boo
java 集合深入_Java-集合深入理解
weixin_39614262的博客
02-19 140
集合集合类存放于Java.util包中集合类型主要有三种:set(集)、list(列表包含Queue)、map(映射)。Collection：Collenction是集合的基本接口，List、Set、Queue的最基本的接口。Iterator：迭代器，可以通过迭代器遍历集合中的数据Map：是映射表的基本接口List有序集合java的List是非常常用的数据类型，List是有序的Collection...
JAVA集合深入理解，多图解析。
技术大神之路
04-14 1057
概览1.Collection 接口 类似数学上的集的概念，你能想到哪些方法？ 集的大小、添加、删除、批量添加、批量删除、清空。hashCode和equals 是每个类都有的，就是这么简单。2.AbstractCollection ==> Collection的骨干实现那么他都实现了Collection的哪些方法？假设我们去掉他的abstract 关键字，结果如下： 可见，这里只有size 和
Java深入理解集合框架List
JasonBlog
07-17 724
前言 Java集合框架主要包含Collection和Map两大类，其中Collection类包含List、Set、Queue，List接口包含ArrayList、LinkedList、Vector、Stack，Set接口包含HashSet、TreeSet、SortedSet，而Map接口则主要包括HashMap、HashTable、TreeMap，总结起来类似结构如下： Collection...
万字长文深入理解java中的集合-附PDF下载
热门推荐
程序那些事
10-24 2万+
集合是用来存储多个数据的，除了基本类型之外，集合应该是java中最最常用的类型了。java中的集合类型一般都集中在java.util包和java.util.concurrent包中。 其中util包中的集合类是基础的集合类，而concurrent包中的集合类是为并发特别准备的集合类。 集合类的父类有两个，一个是java.util.Collection, 一个是java.util.Map。
深入了解java集合框架中的常用集合
dengxuquan2011的博客
07-03 127
深入了解java集合框架中的常用集合 学过java的人都知道，它是一个很重要的知识点，在面试中经常出现。那么怎样才能深入了解集合呢！我想，首先我们需要知道什么是集合？所谓集合就是具有某种特定性质事物的总体。这里的事物可以指大到宇宙，小到细菌；可以表示实实在在的东西，也可以表示抽象的东西。那么什么是集合框架呢？集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。任何集合框...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值