最近在复习数据结构,于是把java集合类重新复习一遍~~
ArrayList基本方法的底层实现:
public class MyArrayList {
//实质是一个数组
private Object[] ElementData;
//集合大小[注:集合大小用size表示,数组大小才有length]
private int size;
//构造函数 没有自定义长度的话 会先自动给一个容量
public MyArrayList() {
this(10);
}
//数组的初始化 自定义大小
public MyArrayList(int capacity) {
if(capacity<0) {
try {
throw new Exception();
} catch (Exception e) {
e.printStackTrace();
}
}
ElementData=new Object[capacity];//数组初始化 指定数组大小
}
//元素的增加
public void add(Object obj) {
//如果集合满了 就对集合进行扩容
if(size==ElementData.length) {
Object[] newArray=new Object[size*2+1];
System.arraycopy(ElementData, 0, newArray,0,ElementData.length);
ElementData=newArray; //现在才发现不同长度的数组也可以这样赋值
}
ElementData[size]=obj;
size++; //别忘了向集合中添加一个元素之后,集合的size就会+1
}
public void remove(int i) {
ElementData[i]=null;
size--; //删除元素同理
}
public Object get(int index) {
return ElementData[index];
}
public boolean isEmpty() {
/*
if(size==0) {
return true;
}
else {
return false;
}
*/
return size==0;
}
}
MyLinkedList基本方法底层实现:
Node类
//每一个节点可看成链式线性表中每一个完整的小部分
public class Node {
//一个完整节点的三个属性 一个节点包含3个节点的信息(上一个节点 存储的对象表示当前节点本身 后一个节点)
Node previous;//上一个节点
Node next;//后一个节点、
Object obj;
public Node() {
}
public Node(Node previous, Node next, Object obj) {
super();
this.previous = previous;
this.next = next;
this.obj = obj;
}
public Node(Object obj) {
this.obj = obj;
}
public Node getPrevious() {
return previous;
}
public void setPrevious(Node previous) {
this.previous = previous;
}
public Node getNext() {
return next;
}
public void setNext(Node next) {
this.next = next;
}
public Object getObj() {
return obj;
}
public void setObj(Object obj) {
this.obj = obj;
}
}
基本方法实现
public class MyLinkedList {
//链式链表的三个属性
Node FirstNode; //首节点
Node LastNode;//尾结点
int size;//节点个数 其实就是MyLinkedList集合的容量
//获取集合的容量
public int size() {
return size;
}
//在链表的末尾添加元素
public void add(Object obj) {
Node node=new Node(obj);
//如果链表为空
if(size==0) {
FirstNode=node;
LastNode=node;
}else { //链表不为空
LastNode.setNext(node);
node.setPrevious(LastNode);
LastNode=node;
}
size++;
}
//根据index取出某一节点中存放的对象
public Object get(int index) {
//index异常处理
if(index<0||index>size-1) {
try {
throw new Exception();
}catch (Exception e) {
e.printStackTrace();
}
}
Node temp=FirstNode;
for(int i=0;i<index;i++) {
temp=temp.getNext();
}
return temp.getObj();
}
//移除某一个节点
public void remove(int index) {
//index异常处理
if(index<0||index>size-1) {
try {
throw new Exception();
}catch (Exception e) {
e.printStackTrace();
}
}
if(index==size-1) { //如果是移除最后一个节点
Node upNode=LastNode.previous;
LastNode=upNode;
LastNode.setNext(null);
}
if(index==0) { //如果移除的是第一个节点
Node secondNode=FirstNode.next;
secondNode.setPrevious(null);
FirstNode=secondNode;
}
Node temp=FirstNode;
for(int i=0;i<index;i++) {
temp=temp.next;
}
Node up=temp.previous;
Node down=temp.next;
up.setNext(down);
down.setPrevious(up);
size--;
}
HashMap基本方法底层实现:
HashMap的实质是一个存放对象()含有两个属性key value)的数组:
ElementData类:
public class ElementData {
public Object key;
public Object value;
public ElementData(Object key, Object value) {
super();
this.key = key;
this.value = value;
}
}
基本方法实现
//Map底层实现的实质是一个存放对象(含有两个属性 key 、value)的数组
public class MyMap {
ElementData[] element=new ElementData[999];
int size;
public int size() {
return size;
}
//往Map中添加键值对
public void put(Object key,Object value) { //Map中不会有重复的key 相同的key会被后来者覆盖
ElementData e=new ElementData(key,value);
for(int i=0;i<size;i++) {
if(key.equals(element[i].key)) {
element[i].value=value;
return;
}
}
element[size]=e;
size++;
}
//根据键 获取Map中对应的value值
public Object getValue(Object key) {
for(ElementData e:element) {
if(key.equals(e.key)) {
return e.value;
}
}
return null;
}
//根据键 移除Map中的某个键值对
public void remove(Object key) {
for(ElementData e:element) {
for(int i=0;i<size;i++) {
if(key.equals(element[i].key)) {
for(int j=i;j<size-1;j++) {
element[i]=element[i+1];
}
size--;
}
}
}
}
//判断Map中是否含有某个键
public boolean contains(Object key) {
for(ElementData e:element) {
if(key.equals(e.key)) {
return true;
}
}
return false;
}
}
//为了简化Map查询 底层用一个存放LinkedList的数组来实现
public class MyMap002 {
LinkedList[] array=new LinkedList[9999];
int size;
public int size() {
return size;
}
public void put(Object key,Object value) {
ElementData e=new ElementData(key,value);
int hash=key.hashCode();
hash= hash>0?hash:-hash;//A=(一个判断条件?(成立的结果):(条件不成立的结果))
int a=hash%array.length;
if(array[a]==null) {
LinkedList<ElementData> list=new LinkedList<>();
array[a]=list; //一个需要注意的bug: 当array[a]为空时 需要在该位置创建一个链表 创建完链表之后一定要记得将其存放到数组中 否则后期将访问不到
list.add(e);
}else {
LinkedList<ElementData> list=array[a];
for(int i=0;i<list.size();i++) {
if(list.get(i).key.equals(key)) {
list.get(i).value=value;
return;
}
array[a].add(e);
}
}
size++;
}
public void remove(Object key) {
int hash=key.hashCode();
hash= hash>0?hash:-hash;
int a=hash%array.length;
if(array[a]!=null) {
LinkedList<ElementData> list=new LinkedList<>();
list=array[a];
for(int i=0;i<list.size();i++) {
ElementData e=list.get(i);
if(e.key==key) {
list.remove(i);
}
}
size--;
}else {
return;
}
}
public Object get(Object key) {
int hash=key.hashCode();
hash= hash>0?hash:-hash;
int a=hash%array.length;
if(array[a]!=null) {
LinkedList<ElementData> list=array[a];
for(int i=0;i<list.size();i++) {
ElementData e=(ElementData)list.get(i);
if(e.key.equals(key)) {
return e.value;
}
}
}
return null;
}
}