java：数据结构
一,命名规范定义
1，java.util.collection接口来定义数据结构中方法的命名规范。
2，java.util.List此接口是collection的子接口，要求实现此接口的类，必须满足数据是有序且可以重复的特性。
3，java.util.Set此接口是collection的子接口，要求实现此接口的类，必须满足数据是无序且不可重复的特性。
二，数据结构的实现类
List
1，java.util.ArrayList以可变数组长度的方式实现java.util.List接口。
例：
package myutil; /*总结: ArrayList适合查找元素，而不适合 删除、插入元素*/ public class ArrayList { Object[] elementData; int size; public ArrayList(){ this(10); } public ArrayList(int initialCapacity){ if (initialCapacity < 0) throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity); this.elementData = new Object[initialCapacity]; } public boolean add(Object obj){ this.ensureCapacity(this.size+1); this.elementData[size++] = obj; return true; } /* 由于在数组中删除元素需要调整数组的下标，例如在100个元素中删除第一个元素需要调下标99次， 因此在ArrayList中删除元素的效率很低(特别是删除在数组中靠前的元素)*/ public Object remove(int index){ Object oldEle=this.elementData[index]; for(int i=index;i<size;i++){ this.elementData[i]=this.elementData[i+1]; } size--; return oldEle; } /* 由于可变长度实际上是新数组和原数组之间一个copy，因此效率很低，在创建ArrayList的时候应该尽量使用 第二种构造函数。*/ private void ensureCapacity(int capacity){ if(capacity>this.elementData.length){ Object[] newElementData = new Object[this.elementData.length*3/2];//扩展到1.5倍。 this.copy(newElementData); } } private void copy(Object[] newElementData){ for(int i=0;i<size;i++){ newElementData[i]=this.elementData[i]; } this.elementData=newElementData; } public Object get(int index){ return this.elementData[index]; } public int size(){ return this.size; } }
2，java.uti.LinkedList以链表的方式实现java.util.List接口。
例：
package myutil; import java.util.Collection; import java.util.Iterator; /*总结:由于LikedList由链表实现(对象的引用),因此在删除链表头或尾部元素的时候效率非常高，这刚好与ArrayList相反 LinkedList的遍历应该按照java.util.Iterator(迭代器规)规范实现遍历，这种方式是从链表表的头部往next或previous顺序返回数据， 效率与ArrayList相同，因此如果要遍历LinkedList应该使用迭代器而不是get方法。 * * */ public class LinkedList implements Iterable { Node header = new Node(null); int size; public LinkedList(){ this.header.previous = header.next = header; } public Iterator iterator(){ class IteratorImp implements Iterator{ Node ele=header; @Override public boolean hasNext() { return ele.next!=header; } @Override public Object next() { Node n=ele.next; ele=n; return n.ele ; } @Override public void remove() { } } return new IteratorImp(); } public boolean add(Object ele){ Node newNode = new Node(ele); newNode.previous = header.previous; newNode.next = header; header.previous.next = newNode; header.previous = newNode; size++; return true; } private Node node =header; public boolean add2(Object ele){ Node newNode = new Node(ele); header.previous = newNode; node.next = newNode; newNode.previous = node; newNode.next = header; node = newNode; size++; return true; } public void removeFirst(){ Node removeEle=header.next; removeEle.next.previous = header; header.next = removeEle.next; removeEle = removeEle.previous = removeEle.next = null; size--; } public void removeLast(){ } //查找元素时效率低，需要对链表进行遍历。ArrayList效率高因为数组可以快速定位到指定下标的元素。 public Object get(int index){ if(index < size>>1){ Node node=header; for(int i=0;i<=index;i++){ node=node.next; } return node.ele; }else{ Node node=header; for(int i=size;i>index;i--) { node = node.previous; } return node.ele; } } public int size(){ return this.size; } class Node{ Node next; Node previous; Object ele; Node(Object ele){ this.ele =ele; } } }
Set
1，java.util.HashSet HashSet由HashMap实现，把所有元素都储存在HashMap的key中。（此实现依照HashMap方法实现）
Map
（map是key-value的数据储存关系，与集合接口没有任何关联）
1，常用实现类java.util.HashMap
例：
package myutil; import java.util.Iterator; @SuppressWarnings("all") public class HashMap{ static final int DEFAULT_INITIAL_CAPACITY = 16; static final float DEFAULT_LOAD_FACTOR = 0.75f; Node[] elementsData; public int threshold; int size; public HashMap(int initialCapacity, float loadFactor) { this.threshold= (int)(initialCapacity*loadFactor); } public HashMap(){ this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR); this.elementsData = new Node[8]; init(); } public Object get(Object key){ int index= indexFor(key.hashCode()); Node ele=this.elementsData[index]; for(; ele!=null;ele=ele.next){ if(ele.key==key) return ele.value; } return null; } public Object put(Object key, Object value){ if(size+1>threshold){ //reHash 扩展Hash表的长度。 } return addNode(key,value); } public void init(){ } public Node addNode(Object key, Object value){ Node ele=new Node(key,value); int index= indexFor(key.hashCode()); ele.next = this.elementsData[index]; this.elementsData[index]=ele; size++; return ele; } public int indexFor(int h) { int index=h & (this.elementsData.length-1); if(index<0) index=index*-1; return index; } public static class Node{ Object key; Object value; Node next; public Node(Object key,Object value){ this.key = key; this.value = value; } public Node(){ } } }
2，java.util.LinkedHashMap如果需要使用HashMap的功能又需要对储存的数据进行排序则使用LinkedHashMap。
例：
package myutil; import java.util.Iterator; public class LinkedHashMap extends HashMap implements Iterable { Node header; @Override public void init(){ header=new Node(null,null); header.previous = header.next = header; } @Override public Iterator iterator() { class IteratorImp implements Iterator{ Node ele=header; @Override public boolean hasNext() { return ele.next!=header; } @Override public Object next() { Node n=ele.next; ele=n; return n.value ; } @Override public void remove() { } } return new IteratorImp(); } class Node extends HashMap.Node{ Node previous; Node next; public Node(Object key,Object value){ super(key,value); } public boolean addBefore(){ this.previous = header.previous; this.next = header; header.previous.next = this; header.previous = this; return true; } } /* 重写addNode方法。由于HashMap在调用put方法时会调用addNode方法。因此重写此方法后 LinkedHashMap在调用put方法时会执行重写的addNode，从而将存储元素存储到Hash表的同时， 在添加到双向链表的结构中去。*/ @Override public Node addNode(Object key, Object value){ super.addNode(key,value); Node e = new Node( key, value); e.addBefore(); return e; } }
