Java中的常用容器底层分析及实现

最新推荐文章于 2023-05-10 23:34:02 发布
最新推荐文章于 2023-05-10 23:34:02 发布
阅读量573 收藏
点赞数
分类专栏： 集合
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41955767/article/details/81047639
版权

 

Collection的子类有List,Set
 

List的子类ArrayList(底层实现是数组),LinkedList(底层是链表),Vector(底层是数组)

1.ArrayList的底层方法实现：
package collection;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
public class MyArrayList {
public MyArrayList() {
private Object[] elementData;
int size;
public MyArrayList(int initialCapacity) {
elementData = new Object[] {};
}
throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
if (initialCapacity >= 0) {elementData = new Object[initialCapacity];
return size;
} else {}}public int size() {}
public void add(int index,Object obj) {
public void add(Object obj) {
ensureCapacityInternal(size+1);
elementData[size++] = obj;}
public Object get(int index) {
ensureCapacityInternal(size+1);//注意这个移动数据的方法
System.arraycopy(elementData, index, elementData, index+1, size-index);
elementData[index] = obj;size++;}
Object[] newobj = new Object[size*2+1];
return elementData[index];
}//扩容原理
public void ensureCapacityInternal(int capacity) {
if(capacity>elementData.length) {
if(index >= size) {
System.arraycopy(elementData, 0, newobj, 0, size);
elementData =newobj;}}
//此处设置合情合理，因为数的小标》=0；
public void rangecheck(int index) {throw new RuntimeException();
public void set(int index,Object obj) {
}
}
public void rangeCheckForAdd(int index) {
if(index < 0 || index >= size) {
//ArrayList的实现中不能往后设定元素吗？
throw new RuntimeException();}}rangecheck(index);
return false;
elementData[index] = obj;
}
return size == 0;
public boolean isEmpty() {}
public boolean contains(Object obj) {
int index = indexOf(obj);if(index == -1) {}return true;
if(elementData[i] == null) {
}//有点意思
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}public int indexOf(Object obj) {
for(int i = 0;i < size;i++) {
if(null == obj) {return i;}}}else{
System.arraycopy(elementData, index+1, elementData, index, size-index-1);
for(int i = 0;i < size;i++) {
if(elementData[i] .equals(obj)) {
return i;}}}
public void remove(int index) {
return -1;} rangecheck(index);
}
elementData[size-1] = null; size--;
System.out.println(list.size);
public void remove(Object obj) {
int index = indexOf(obj);
remove(index);
if(index != -1) {}}
MyArrayList list = new MyArrayList();
public static void main(String[] args) {list.add("1");
}
list.add(2);list.add(3);
System.out.println(list.get(1));
//System.out.println(list.get(-1));
list.remove(0);
list.remove(0);
System.out.println(list.size);
System.out.println(list.get(0));
}


 

package collection;

//LinkedList的底层实现是链表，增删改快，查询慢，
public class MyLinkedList {
	private int size;
	private Node first;
	private Node last;

	public int size() {
		return size;
	}

	public void add(Object obj) {
		if (first == null) {
			first = new Node();
			first.previous = null;
			first.content = obj;
			last =first ;
			first.next = last;
		} else {
			Node node = new Node();
			last.next = node;
			node.content = obj;
			node.previous = last;
			last = node;
		}
		size++;

	}

	public void addFirst(Object obj) {
		Node node = new Node();	
		if(first==null) {
			first = node;
			first.previous = null;
			first.content = obj;
			last= first;
			first.next = last;
						
		}else{
			first.previous = node;	
			node.content = obj;
			node.next = first;
			node.previous = null;
			first = node;		
		}
		size++;

	}
	public void addLast(Object obj){
		
		if(last ==null) {
			addFirst(obj);
		}else {
			Node node = new Node();
			last.next = node;
			node.previous = last;
			node.content = obj;
			last = node;
			size++;
		}
		
		
		
	}
	public Node getNode(int index) {
		Node temp = new Node();
		temp = first;
		for(int i = 0;i < index;i++) {
			temp = temp.next;
		}
		return temp;
	}
	public Object get(int index) {
		
		return getNode(index).content;
	}
	 public void set(int index,Object obj) {
		 Node node = getNode(index);
		 node.content = obj;
	 }
	 public int indexOf(Object obj) {
		 Node temp = first;
		 if(obj == null) {
			 for(int i = 0;i < size;i++) {
				 if( temp.content == obj) {
					 return i;
				 }else {
					 temp = temp.next;
				 }
			 }
			 return -1;
		 }else {
			 for(int i = 0;i < size;i++) {
				 if( temp.content.equals(obj) ) {
					 return i;
				 }else {
					 temp = temp.next;
				 }
			 }
			 return -1;
		 }
		
		
	 }
	 public boolean contains(Object obj) {
		// return indexOf(obj) ==-1? true:false;
		 return indexOf(obj)!=-1;
	 }
	 public void remove(Object obj) {
		 Node temp = first;
		 if(obj==null) {
			 for(int i = 0;i < size;i++) {
				 if( temp.content == obj) {
					 temp.previous.next = temp.next;
					 temp.next.previous = temp.previous;
					 size--;
					 break;
				 }else {
					 temp = temp.next;
				 }
			 }
		 }else {
			 for(int i = 0;i < size;i++) {
				 if( temp.content.equals(obj) ) {
					 if(temp==first) {
						
						first =  first.next;
						first.previous = null;
						 size--;
						 break;
					 }else {
						 temp.previous.next = temp.next;
						 temp.next.previous = temp.previous;
						 size--;
						 break;
					 }
					
				 }else {
					 temp = temp.next;
				 }
			 }
			
		 }
	 }
	 public void clear() {
		 if(size !=0) 
		 {
			 Node temp = first;
			 for(int i = 0;i < size;i++) {
				
				Node node =temp.next;
				temp.content = null;
				temp = null;
				node.previous = null;
				temp = node;
				 
			 }
		 }
		 size = 0;
		 
	 }

	public static void main(String[] args) {
		MyLinkedList list = new MyLinkedList();
		list.add(1);
		System.out.println(list.get(0));
		list.add(2);
		System.out.println(list.get(1));
		list.add(3);
		System.out.println(list.get(2));
		list.addFirst(4);
		System.out.println(list.get(0));
		list.addLast(5);
		System.out.println(list.get(4));
		System.out.println(list.indexOf(1));
		list.remove(4);
		System.out.println(list.size);
		list.clear();
		System.out.println(list.size);
		System.out.println(list.get(0));
		
		
		
	}
}

 

package collection;

public class Node {
	Node previous;
	Object content;
	Node next;
	
}

 

package collection;
//hashmap的底层实现是数组+链表
public class MyHashMap {
	private int size;
	MyLinkedList arr[] = new MyLinkedList[999];//在这里不考虑扩容的事了
	
	public void put(Object key,Object value) {
		
		int num = key.hashCode()%arr.length;//恰到好处的运用hashcode；
		if(arr[num]==null) {
			MyLinkedList linkedlist = new MyLinkedList();
			arr[num] = linkedlist;
			Entry entry = new Entry(key, value);
			linkedlist.add(entry);
			
			size++;
		}else {
			for(int i = 0;i < arr[num].size();i++) {
				Entry entry = (Entry)arr[num].get(i);
				if(entry.key.equals(key)) {
					entry.value = value;
					return;
				}
			}
			Entry entry = new Entry(key, value);
			arr[num].add(entry);
			size++;
			
		}
	}
	public Object get(Object key) {
		int num = key.hashCode()%arr.length;
		if(arr[num]!=null) {
			
			for(int i = 0;i < arr[num].size();i++) {
				Entry en = (Entry) arr[num].get(i);
				if(en.key.equals(key)) {
					return en.value;
				}
			}
		}
		return null;
		
	}
	public int size() {
		return size;
	}
	public static void main(String[] args) {
		MyHashMap map = new MyHashMap();
	/*	map.put("a", "a1");
		map.put("b", "b1");
		map.put("a", "a2");
		System.out.println(map.get("a"));
		System.out.println(map.get("b"));
		System.out.println(map.size());*/
		Student stu1 = new Student("张三", 18);
		Student stu2 = new Student("李四", 19);
		Student stu3 = new Student("张三", 20);
		map.put(stu1, "男");
		map.put(stu2, "女");
		map.put(stu1, "女");
		System.out.println(map.size);
		System.out.println(map.get(stu1));
		
	}
	private class Entry{
		Object key;
		Object value;
		public Entry(Object key, Object value) {
			super();
			this.key = key;
			this.value = value;
		}
		
	}
}
class Student{
	private String name;
	private int age;
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		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 (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	
}

 

package collection;

import java.util.HashMap;
//由此可见HashSet集合的不可重复完全依赖于HashMap键的不可重复实现的
public class MyHashSet {
	private HashMap hashmap;
	 private static final Object PRESENT = new Object();
	public MyHashSet() {
		hashmap = new HashMap<>();
	}
	public int size() {
		return hashmap.size();
	}
	public boolean isEmpty() {
		return hashmap.isEmpty();
	}
	public boolean contains(Object obj) {
		return hashmap.containsKey(obj);
	}
	public void clear() {
		hashmap.clear();
	}
	public void add(Object obj) {
		hashmap.put(obj, PRESENT);
	}
	
}

 

package knowledgepoint;

import java.util.TreeSet;

//TreeSet注意：在添加数据时排序，数据更改不会影响原来的顺序，因此里面的数据可能有重复的。
//因此使用TreeSet时要保证数据不能修改（有必要时加final）
public class TreeSetDemol {
	public static void main(String[] args) {
		TreeSet<Worker> treeset = new TreeSet<>();
		treeset.add(new Worker("工人", 10000));
		Worker w = new Worker("教师",5000);
		treeset.add(w);
		treeset.add(new Worker("程序员", 20000));
		treeset.add(new Worker("修理工", 8000));
		System.out.println(treeset);
		w.setType("修理工");
		w.setSalary(8000);
		System.out.println(treeset);//由此验证了可重复性，因此本例中最好将属性设为final
		
	}
}
class Worker implements Comparable<Worker>{
	private String type;
	private double salary;
	public Worker(String type,double salary) {
		this.type = type;
		this.salary = salary;
	}
	@Override
	public int compareTo(Worker o) {
		
		return this.type.compareTo(o.type);
	}
	@Override
	public String toString() {
		return "Worker [type=" + type + ", salary=" + salary + "]";
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	public double getSalary() {
		return salary;
	}
	public void setSalary(double salary) {
		this.salary = salary;
	}
	
	
}

TreeMap要求键能够排序就行了 ，其余和TreeSet基本一致。

 

    

闻人哲杰
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于java的容器底层原理实现
萌萌的PP博客
11-13 8374
一.java容器的体系大览 1. java为啥子需要容器呢? 通常，程序总是在运行时才能确定要创建的对象，甚至是对象的类型。为了解决这个问题，需要在任意时刻任意位置创建任意数量的对象。大多数语言都提供某种方法来解决这个问题，Java使用容器来解决这个问题。容器也称集合类，基本的类型是List、Set、Queue、Map，但由于Java类库中使用了Collection关键字来代表某一接口，所以一般...
Java并发容器，底层原理深入分析
不喝枸杞的程序员
05-25 227
ConcurrentHashMap ConcurrentHashMap底层具体实现 JDK 1.7底层实现 将数据分为一段一段的存储，然后给每一段数据配一把锁， 当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。 ConcurrentHashMap是由Segment数组结构和HashEntry数组结构组成。 其中Segment 实现了 ReentrantLoc...
Java数据存储容器核心之集合底层探究下
qibulemingzi的博客
08-15 412
HashSet底层数据结构是哈希表，HashSet的本质是一个"没有重复元素"的集合，它是通过HashMap实现的。HashSet中含有一个HashMap类型的成员变量map，在HashSet中操作函数，实际上都是通过map实现的。
Java集合（底层设计与实现）
kukudeYSB的博客
05-10 486
无序（添加顺序与取出顺序不一样），没有索引不允许有重复元素，所以最多包含一个null。
java基础容器底层原理_Java基础：容器
weixin_31869569的博客
02-27 298
一、Collection：存放独立元素Collection中的接口都是可选操作，其实现类 并不一定实现了其所有接口，这是为了防止“接口爆炸”。最常见的Unsupported Operation都源自于背后由固定尺寸的数据结构支持的容器，比如使用ArrayList.asList将数组转换成List的时候，就会得到这样的容器。(1)Collection之ListList较之Collection增加了...
java中一些容器底层的数据结构解析
南朝烟雨的博客
05-08 8921
先来看一个java里一些主要容器的继承图：   然后分别解析一下上面几种容器底层的数据结构以及一些实现： 1.ArrayList(非线程安全的) 底层的数据结构其实就是数组，但是它比数组优秀的地方在于他是动态的，即不必像数组那样固定大小，那么他是如何实现这种数据结构是数组，但是给我们看起来确实不固定大小的呢？ ArrayList 是通过将底层 Object 数组复制的
java容器源码-Java-Container-Source-Code:Java常用容器底层源码及注释
05-19
本项目“Java-Container-Source-Code”专注于Java常用容器的底层源码分析，提供了对这些容器实现的深入理解。源码分析对于开发者来说至关重要，因为它可以帮助我们了解内部的工作机制，优化代码性能，以及解决潜在的...
Java集合容器面试题
09-30
Java 集合容器是 Java 语言中的一种数据结构，用于存储和操作数据。集合容器框架是 Java 中的一个重要组件，提供了一种统一的标准来存储和操作数据。下面是关于 Java 集合容器的知识点： 集合容器概述 集合容器是...
heap_implementation:在Java中实现堆数据结构
05-05
在Java中，我们通常使用ArrayList或LinkedList来表示动态大小的集合，但因为堆操作主要涉及元素的交换和比较，ArrayList由于其底层是数组，对于这些操作更为高效。 以下是一些关键知识点： 1. **初始化堆**: 创建...
Java源码篇之容器类——ArrayList
12-20
在Java编程语言中，ArrayList是集合框架中一个重要的容器类，属于List接口的实现，它提供了动态数组的功能。本文将深入解析ArrayList的源码，帮助开发者理解其内部工作原理。 1、前言 在日常开发中，ArrayList是...
Java面试题及答案-共72道.docx
07-18
Java 集合框架中有很多常用的集合类，例如 Map、Set、List 等。Map 接口和 Collection 接口是所有集合框架的父接口。Collection 接口的子接口包括 Set 接口和 List 接口。Map 接口的实现类主要有 HashMap、TreeMap、...
java容器的底层原理
weixin_51631350的博客
05-26 181
Java04 容器（之底层原理b）
m0_46834909的博客
06-07 87
Java容器底层原理
javaSwing--容器
m0_37599962的博客
11-18 817
容器 java中的容器分为顶层容器、中间容器和特殊容器三大类。其中，顶层容器是GUI的基础，其他所有的组件都是直接或间接显示在顶层容器中的。在Swing中有3种顶层容器，分别是JFrame（框架窗口，即通常的窗口）、JDialog(对话框)、JApplet(用于设计嵌入在网页中的Java小程序)。中间容器是可以包含其他相应组件的容器，但是中间容器不能单独存在，必须依附于顶层容器。Java常见的中
系统研究Java--容器（五）--部分容器的底层实现
G_beginner的专栏
02-23 3387
List和存储顺序 从List接口展开的实现类有ArrayList，LinkedList，Vector和Stack，其中Vector和Stack被称为遗留类，是用于支持遗留代码，向前兼容，你不应该再去使用这样的东西，但Vector在处理并发的时候加了同步，而ArrayList没
Java中常见数据结构：Java容器 Collection与map -底层如何实现
莫贤彬的博客
07-09 5368
1:集合 2 Collection(单列集合) 3 List(有序,可重复) 4 ArrayList 5 底层数据结构是数组,查询快,增删慢 6 线程不安全,效率高 7 Vector 8 底层数据结构是数组
Arcmap天地图历史影像插件全国版-免费！免费！
最新发布
07-22
2024版“天地图”首次开放多时相影像专题，公众可查看32个省级天地图节点近半个世纪的历史影像；本arcmap插件集成了全国天地图历史影像接口，累计上千期。 免费使用。不收费！！不收费！！不收费！！
2020年Java集合容器深度解析及面试精华
本文档聚焦于2020年的Java集合容器面试题，涵盖了集合的概述、集合与数组的区别、集合框架的优势、常用集合类的介绍及它们之间的关系、线程安全的集合、快速失败机制、数据安全性、以及List、Set、Map等接口的特性和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值