在平时的编程中经常用到ArrayList和LinkedList,它的区别在于效率方面的问题,ArrayList中是以数组为基础的存储方式,而LinkedList是以链表为基础的存储方式。当我们要获取一个数据时ArrayList效率比LinedList高,当要增加和删除数据时除了对末端的数据进行操作效率相等外,其它的都是LinkedList的效率要高。
自己实现ArrayList代码:
package com.example.arze.tree;
import java.util.Iterator;
/**
* Created by arze on 2015/11/27.
*/
public class MyListView<E> {
private static final int DEFAULT_SIZE = 10;
private E [] arr;
private int size;
public MyListView () {
size = 0;
arr = (E[]) new Object[DEFAULT_SIZE];
}
public int size () {
return size;
}
public boolean isEmpty () {
return 0 == size;
}
private void judgementSize (int newSize ) {
if (newSize < size) {
return;
} else {
E[] oldArr = arr;
arr = (E[]) new Object[newSize];
for (int i = 0 ;i < size (); i++) {
arr[i] = oldArr[i];
}
}
}
public void add (int index,E data) {
if (arr.length == size) {
judgementSize(size * 2 +1);
}
for (int i = size ; i > index;i++) {
arr[i] = arr[i-1];
}
arr[index] = data;
size++;
}
public void remove (int index) {
if (index < 0 || index >= size)
new IndexOutOfBoundsException("error");
for (int i = index ; i < size -1 ; i ++) {
arr[i] = arr [i+1];
}
size--;
}
public void clean () {
size = 0;
arr = (E[]) new Object[DEFAULT_SIZE];
}
public void add (E data) {
if (arr.length == size) {
judgementSize(size * 2 +1);
}
arr[size] = data;
size++;
}
public E get(int index) {
if (index >= size)
new IndexOutOfBoundsException("error");
return arr[index];
}
public MyIterator iterator () {
return new MyIterator();
}
private class MyIterator implements Iterator<E> {
private int current = 0;
@Override
public boolean hasNext() {
return current < size();
}
@Override
public E next() {
if (!hasNext()) {
new Exception("error");
}
return arr[current++];
}
@Override
public void remove() {
MyListView.this.remove(current-- );
}
}
}
自己实现LinkedList代码:
package com.example.arze.tree;
import java.util.Iterator;
/**
* Created by arze on 2015/11/28.
*/
public class MyLinkedList<E> {
//采用双链表
private int size = 0;
private class Node<E> {
private E data;
private Node next;
private Node prev;
}
private Node head;
private Node tail;
public MyLinkedList() {
clean();
}
public int size() {
return size;
}
private boolean isEmpty() {
return 0 == size();
}
public void clean() {
size = 0;
head = new Node();
tail = new Node();
head.next = tail;
tail.prev = head;
}
public void add(E data) {
/* if (size == 0) {
Node node = new Node();
node.data = data;
node.prev = head;
node.next = tail;
head.next = node;
tail.prev = node;
} else { */
/* Node node = getNode(size - 1);
Node newNode = new Node();
node.next = newNode;
newNode.data = data;
newNode.prev = node;
newNode.next = tail;
tail.prev = newNode; */
Node node = new Node();
node.data = data;
node.prev = tail.prev;
node.next = tail;
tail.prev.next = node;
tail.prev = node;
size++;
}
public void add(int index, E data) {
if (index >= size) {
add(data);
} else {
Node node = getNode(index);
Node newNode = new Node();
newNode.data = data;
newNode.next = node;
newNode.prev = node.prev;
node.prev.next = newNode;
node.prev = newNode;
size++;
}
}
public void remove(int index) {
Node node = getNode(index);
node.prev.next = node.next;
node.next.prev = node.prev;
size--;
}
private Node<E> getNode(int index) {
if (index < 0 || index >= size())
new IndexOutOfBoundsException("error");
Node<E> node ;
if (index < size() / 2) {
node = head;
for (int i = 0; i <= index; i++)
node = node.next;
} else {
node = tail;
for (int i = size(); i > index; i--) {
node = node.prev;
}
}
return node;
}
public E get(int index) {
return getNode(index).data;
}
public Iterator iterator() {
return new MyIterator();
}
private class MyIterator implements Iterator<E> {
private int currentIndex = 0;
@Override
public boolean hasNext() {
return currentIndex < size();
}
@Override
public E next() {
if (hasNext())
new Exception("error");
return getNode(currentIndex++).data;
}
@Override
public void remove() {
}
}
}
对于栈,能实现链表的模型都能实现栈,限制链表加入和移除只在末端操作。队列也是一样加入的时候只在前段加入,获取的时候只在末端获取。