ArrayList，LinkedList，HashSet，HashMap（熟悉和理解容器，手动写一些简单的容器）

最新推荐文章于 2021-06-02 21:47:49 发布
最新推荐文章于 2021-06-02 21:47:49 发布
阅读量211 收藏
点赞数
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43328816/article/details/104317259
版权

ArrayList

import java.util.ArrayList;

public class myArrayList<E> {
	private Object[] elementDate;
	private int size;
	private static final  int DEFAULT_CAPACITY=10;//默认数组的容量
	
	//构造器
	public myArrayList() {
		elementDate=new Object[DEFAULT_CAPACITY];
	}
	public myArrayList(int capacity) {
		elementDate=new Object[capacity];
	}
	
	//增加元素，需要进行扩容
	public void add(E element) {
		//当放入的元素个数size与数组的长度相等时，需要进行扩容
		if(size==elementDate.length) {
			Object newArray=new Object[elementDate.length+(elementDate.length>>1)];//15
			//增加原数组的个数
			System.arraycopy(elementDate,0,newArray, 0, elementDate.length);
			elementDate = (Object[]) newArray;
		}
		
		
		elementDate[size++]=element;
	}
	
	
	//重写toString方法
	public String toString() {
		StringBuilder s=new StringBuilder();
		s.append("[");
		for(int i=0;i<size;i++) {
			s.append(elementDate[i]+",");
		}
		s.setCharAt(s.length()-1, ']');
		return s.toString();
	}
	
	//增加set和get方法，
	public E get(int index) {
		checkRange(index);
		return (E)elementDate[index];
	}

	public void set(E element,int index) {
		//检查索引的范围[0,sise)
		checkRange(index);
		elementDate[index]=element;
	}
	
	
	
	//除了在set get方法中需要对索引进行判断外，在很多的方法中都需要对其进行判断
	//因此我们将其封装成一个方法
	public void checkRange(int index) {
		if(index<0||index>size-1) {
			//不合法
			throw new RuntimeException("索引不合法"+index);//手动抛出一个异常
		}
	}
	
	//增加remove方法
	public void remove(E element) {
		//element和他们所有的元素进行比较，获得第一个比较为true的，返回。
		for(int i=0;i<size;i++) {
			if(element.equals(get(i))) {//容器中所有的比较操作，都用的是equal方法
				//将该元素从此处移除
				remove(i);
			}
		}
		
	}
	
	
	public void remove(int index) {
		//本质就是数组的拷贝
		int move=elementDate.length -index-1;
		if(move>0) {
			System.arraycopy(elementDate, index+1, elementDate, index,move);
	
		}
		//若删除的最后一个元素
			elementDate[size-1]=null;
			size--;
		
		
		
	}
	
	//返回size的方法
	public int size() {
		return size;
	}
	
	//判断为空的方法
	public boolean isEmpty() {
		if(size==0)
			return true;
		return false;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		myArrayList m=new myArrayList(20);
		for(int i=0;i<30;i++) {
			m.add(" "+i);
		}
		System.out.println(m);
		System.out.println(m.get(10));
		m.set("q",10);
		System.out.println(m.get(10));
		
		m.remove(3);
		System.out.println(m);
		System.out.println(m.size);
		System.out.println(m.isEmpty());
	}
	

}

LinkedList

/**
 * 底层实现的是用链表的增删效率高，查找效率低
 * 
 * @author lsy
 *
 */
public class myLinkedList<E> {
	//通过第一个和最后一个结点对该链表进行操作，增加或者删除元素
	private Node first;//第一个结点
	private Node last;//第一个结点
	private int size;
	
	//[]  [1]
	//增加结点，即是在结尾增加
 	public void add(E element) {//shift+alt+R可以同时修改所有相同的变量名
		Node node=new Node(element);//先创建一个新的结点
		
		if(first==null) {//当链表里面为空的时候
			
			first=node;
			last=node;
		}
		else {
			node.pre=last;
			node.next=null;
			last.next=node;
			last=node;
		
		}
		size++;
	}
	
 	
 	//重写toString方法
 	public String toString() {
		//["q","a","c"]
 		//挨个遍历链表中的元素。
		Node temp=first;
		StringBuilder s=new StringBuilder();
		s.append("[");
		while(temp!=null) {
			s.append(temp.element+",");
			temp=temp.next;
		}
		s.setCharAt(s.length()-1, ']');
		return s.toString();
	}
 	
 	//["q","a","c"]//2
 	//获得索引位置的元素
 	public E get(int index) {
 		//从第一个开始
 		//判断索引的范围
 		checkRange(index);
 		Node temp=getNode(index);
 		
 		return temp!=null?(E)temp.element:null;//返回结点元素。
 		
 		
 	}

 	
 	//根据索引值获得结点，
 	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.pre;
 			}
 		}
 		return temp;
 	}
 	
 	
 	
 	//remove 方法
 	public void remove(int index) {
 		checkRange(index);
 		Node temp=getNode(index);
 		if(temp!=null) {
 			Node up=temp.pre;
 			Node down=temp.next;
 			if(up!=null)
 				up.next=down;
 			if(down!=null)
 				down.pre=up;
 			if(index==0)//删除的是第一个元素
 				first=down;
 			if(index==size-1)//删除的是最后一个元素
 				last=up;
 			size--;
 		}
 	}
 	
 	
 	
 	
 	//判断索引是否合法
 	//不需要外部知道的方法可以用private修饰
 	
 	private void checkRange(int index) {
 		if(index<0||index>size-1) {
 			throw new RuntimeException("索引的范围不合法："+index);
 		}
 	}
 	
 	//在索引位置前插入一个结点，
 	public void add(int index,E element) {
 		checkRange(index);
 		Node newNode=new Node(element);
 		Node temp=getNode(index);
 		if(index==0) {
 			newNode.next=temp;
 			newNode.pre=null;
 			temp.pre=newNode;
 			first=newNode;
 		}
 		
 		if(temp!=null) {
 			Node up=temp.pre;
 			
 			up.next=newNode;
 			newNode.pre=up;
 			
 			newNode.next=temp;
 			temp.pre=newNode;
 		}
 		size++;
 		
 		
 	}
 	
 	
 	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		myLinkedList<Integer> l=new myLinkedList<>();
		l.add(1);
		l.add(2);
		l.add(4);
		l.add(3);
		
//		System.out.println(l);
//		System.out.println(l.get(3));
//		System.out.println(l.get(0));
//		l.remove(0);
//		System.out.println(l);
//		l.remove(3);
		System.out.println(l);
		l.add(0,5);
		System.out.println(l);
		}

}

节点类

public class Node {
	Node pre;//上一个结点
	Node next;//下一个结点
	Object element;//元素数组
	public Node(Node pre, Node next, Object element) {
		super();
		this.pre = pre;
		this.next = next;
		this.element = element;
	}
	
	
	public Node(Object element) {
		super();
		this.element = element;
	}

HashMap

public class myHashMap<K,V> {
	Node2[] table;//位桶数组，用于存放Node2
	int size;

	public myHashMap() {
		super();
		table=new Node2[16];//数组的大小一般为2的整数幂
	}
	
	
	
	public void put(K key,V value) {
		//可以增加数组扩容的方法
		
		
		//定义心得结点对象
		Node2 newNode=new Node2();
		newNode.hash=myHash(key.hashCode(), table.length);//获得新节点的hash值
		newNode.key=key;
		newNode.value =value;
		newNode.next =null;
		
		//根据hash值存放
		
		Node2 temp=table[newNode.hash];//放入hash相应的table中
		boolean keyReplace=false;
		Node2 iterLast=null;//正在遍历的最后一个元素
		if(temp==null) {//如果此处的数组元素为空，则直接将新节点放进去
			table[newNode.hash]=newNode;
			size++;
		}else {//否则遍历数组，如果键重复，则替换，没有重复的就直接放在链表的后面。
			while(temp!=null) {
				//判断key存在，替换
				if(temp.key.equals(key)) {
					keyReplace=true;
					temp.value =value;//只是覆盖value就可以，其他的值不变
					break;
				}else {
					//key不存在，将temp.next=newNode;
					iterLast=temp;
					temp=temp.next;
				}
				
			}
			
			if(!keyReplace) {//如果没有发生键重复
				iterLast.next=newNode;
				size++;
			}
		}

	}
	public int myHash(int v,int length) {
		return v&(length-1);//获得hash值，与操作就是对length取模。
	}
	//重写toString方法
	@Override
	public String toString() {
		//[1:a,2:b]
		StringBuilder sb=new StringBuilder("[");
		for(int i=0;i<table.length;i++) {
			Node2 temp=table[i];//获得第一个元素
			while(temp!=null) {
				sb.append(temp.key+":"+temp.value +",");
				temp=temp.next;
			}
		}
		sb.setCharAt(sb.length()-1, ']');
		return sb.toString();
	}
	
	//增加get方法
	public V get(K key) {
		int hash=myHash(key.hashCode(),table.length);
		V value=null;
		if(table[hash]!=null) {
			Node2 temp=table[hash];
			while(temp!=null) {
				if(temp.key.equals(key)) {
					//如果相等，则说明找到了键值对，返回相应的value
					value=(V) temp.value;
					break;
				}else {
					temp=temp.next ;
					
				}
				
			}
		}
		return value;
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		myHashMap<Integer,String> m=new myHashMap<>();
		m.put(1, "a");
		m.put(2,"b");
		m.put(3,"c");
		m.put(3,"d");
		System.out.println(m);
		System.out.println(m.get(1));
		
		
	}

}


/**
 * 用于HashMap的节点类
 * 
 * 
 * @author lenovo
 *
 */
public class Node2<K,V> {
	int hash;
	K key;
	V value;
	Node2 next;
	
}

HashSet

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

public class myTreeSet {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Set<Integer> set=new TreeSet<>();
		set.add(30);
		set.add(40);
		set.add(20);
		for(Integer m:set) {
			System.out.println(m);
		}
		
		Set<Employee2> set2=new TreeSet<>();
		set2.add(new Employee2(200,"ki",20000));
		set2.add(new Employee2(300,"yi",30000));
		set2.add(new Employee2(400,"ei",40000));
		
		for(Employee2 m:set2) {
			System.out.println(m);
		}
		
	}

}


//实现Comparable接口，需要重写compareTo的方法。
class Employee2 implements Comparable<Employee2>{
	int id;
	String name;
	double salary;
	public Employee2(int id, String name, double salary) {
		super();
		this.id = id;
		this.name = name;
		this.salary = salary;
	}
	
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return " id "+id+" name "+name+" salary "+salary;
	}
	public int compareTo(Employee2 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;
			}
		}
	}
}
love the future
关注
专栏目录
Java 容器（HashMap、HashSet、LinkedList、ArrayList）原理与对比
lifeidroid的专栏
05-29 614
HashMap HashSet LinkList 原理总结： 1、数据存储基于双向链表的数据结构，查询慢，增删快。线程不安全。 2、插入数据很快。先是在双向链表中找到要插入节点的位置index，找到之后，再插入一个新节点。 双向链表查找index位置的节点时，有一个加速动作：若index < 双向链表长度的1/2，则从前向后查找; 否则，从后向前查找。 add(E)添加到末尾，复杂度O(1)； add(index, E)添加第几个元素后，需要先查找到第几个元素，直接指针指...
【数据结构】Java容器——ArrayList、LinkedList、HashMap（红黑树）等结构的分析
火火的博客
12-16 4040
文章目录ArrayList和LinkedList使用场景： ArrayList和LinkedList ArrayList是基于数组实现的，LinkedList是基于双链表实现的，因此LinkedList可以作为双向队列 ，栈。 因为Array是基于索引(index)的数据结构，它使用索引在数组中搜索和读取数据是很快的，可以直接返回数组中index位置的元素，因此在随机访问集合元素上有较好的性能。Array获取数据的时间复杂度是O(1),但是要插入、删除数据却是开销很大的，因为这需要移动数组中插入位置之后的
四种常用的容器（ArrayList,LinkedList,HashSet,HashMap）的基本方法和基本概念
weixin_45868097的博客
03-29 229
https://blog.csdn.net/weixin_45868097/article/details/105189545
一文搞懂Java中的容器（Collection、List、Set、Map、HashSet、HashMap...）
qq_41189226的博客
06-02 325
1 容器 1.1 容器简介 开发和学习中需要时刻和数据打交道，如何组织这些数据是我们编程中重要的内容。我们一般通过“容器”来容纳和管理数据。事实上，我们前面所学的数组就是一种容器，可以在其中放置对象或基本类型数据。 数组的优势：是一种简单的线性序列，可以快速地访问数组元素，效率高。如果从效率和类型检查的角度讲，数组是最好的。 数组的劣势：不灵活。容量需要事先定义好，不能随着需求的变化而扩容。 2 容器的结构 2.1 结构图 2.1.1 单例集合 单例集合：将数据一个一个的进行存储。 2.1.2 双例集合
Java集合之ArrayList,LinkedList,HashMap,HashSet
weixin_34284188的博客
04-14 176
2019独角兽企业重金招聘Python工程师标准>>> ...
浅析Java中的集合包(ArrayList,LinkedList,Vector, Stack,HashSet,TreeSet,HashMap,TreeMap)
安卓开发
12-08 1023
集合包是Java中最常用的包，它最常用的有Collection和Map两个接口的实现类，Collection用于存放多个单对象，Map用于存放Key-Value形式的键值对。         Collection中常用的又分为两种类型的接口：List和Set，两者最明显的差别为List支持放入重复的对象，而Set不支持。List接口常用的实现类有：ArrayList，LinkedList，V
51. ArrayList LinkedList Set HashMap介绍.txt
10-08
### ArrayList #### 简介 `ArrayList` 是 Java 中的一种动态数组实现方式，它允许在运行时调整其大小。`ArrayList` 实现了 `List` 接口，并且内部通过一个数组来存储数据。当添加元素导致数组空间不足时，`...
ArrayList、LinkedList、HashSet以及HashMap
粥要熬。
10-21 851
集合类 集合类是一种工具类，像是容器，储存任意数量的具有共同属性的对象。 集合的作用：
Java中常用的容器LinkedList，ArrayList，HashMap
weixin_37875637的博客
10-12 160
前言：java初学者第一次发文，针对最近的学习心得做一些总结，有说错的或者理解粗浅的地方还请大神不吝赐教，感谢！
ArrayList、LinkedList、Vector、HashSet、Treeset、HashMap、TreeMap的区别和适用场景
sinat_27250263的博客
08-08 1195
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
LinkedList、ArrayList、Hashtable、HashMap、HashSet底层原理
李承
10-10 415
LinkedList 是一个双向链表，每一个元素被封装为一个节点，有序，可重复。 ArrayList 用一个数组来保存元素，当数组装满后开始扩容，扩容公式： int newCapacity = oldCapacity + (oldCapacity &gt;&gt; 1);是一种有序可重复的存储方式，默认容量为10。 HashMap 用一个数组来保存元素，允许null的key,无序不重复，...
List、Map、Set的理解（LinkedList和ArrayList、Vector和ArrayList、HashMap和HashTable和HashSet区别与使用）
csdnZCjava的博客
09-21 707
List特点：元素有放入顺序，元素可重复 Map特点：元素按键值对存储，无放入顺序 Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） List接口有三个实现类：LinkedList，ArrayList，Vector LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素
集合之ArrayList,HashMap,LinkedList,HashSet优缺点及源码分析
flybridy的博客
11-30 598
集合源码分析 项目中今天遇到一个加载文件，保存数据入在内存中的操作，初始化过程中只有add操作，使用arraylist耗时300秒，改为hashset后只需要13秒，探究集合源码， 看到一个很不错的源码分析，注释非常全，解释到位的帖子，记录分享下。 https://www.cnblogs.com/dongying/tag/java容器/ ...
ArrayList，LinkedList，HashMap，HashSet，vactor区别整理
wangkai3214的博客
03-03 475
ArrayList，LinkedList，HashMap，HashSet，vactor之间的区别与联系这些在面试中经常会被问到，现在整理一下，方便以后查询。 要说这些东西，就必须先提一下这些东西总体上的划分： ArrayList，LinkedList是实现了List接口，而List接口有继承了Collection接口。 vactor也是实现了List接口。 HashSet是实现了Set接口，Set...
ArrayList,LinkedList,HashMap简单实现
sunny潘先生的博客
08-10 194
ArrayList: /** * 自定义ArrayList * @author pan */ public class CustomArrayList<E> { private Object[] elementData; private int size; private static final int DEFALT_CAPACITY = 10;...
二重Arraylist简易模拟HashMap
whyfive4的博客
05-19 162
package Day_3; import java.util.ArrayList; import java.util.Arrays; public class Try_list_list { private int size; private ArrayList<ArrayList> arrayLists; public Try_list_list() { size =...
深入理解 ArrayList、LinkedList、HashSet 等 Java 容器
HappyFeet的博客
05-10 5514
本文主要从 Java 源码深入学习 java.util 包中容器部分的底层代码实现
Java集合框架深度解析：ArrayList、LinkedList、HashSet与HashMap
- HashSet和HashMap的区别在于，HashSet是Set的实现，存储的是元素，而HashMap是Map的实现，存储键值对。 - ConcurrentHashMap是线程安全的HashMap实现，其内部采用了分段锁机制，提高了并发性能。 了解并熟练...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值