国产成人精品日本亚洲专区61 ,日韩亚洲人成在线综合,亚洲日韩中文字幕一区

java数据�l�构-Comparable&Comparator

Wed, 15 Jun 2011 07:07:00 GMT

在深入了解TreeMap之前�Q�有两个接口要先弄清楚，分别是Comparable和Comparator

Comparable & Comparator

Comparable
Comparable 此接口强行对实现它的每个�cȝ��对象�q�行整体排序。这�U�排序被�U�Cؓ�cȝ��自然排序�Q�类�?compareTo �Ҏ��被称为它的自然比较方法。对象本�w�就已经支持自比较所需要实现的接口�Q�如 String、Integer 自己��可以完成比较大��操作）�?br />
它只有一个方�?int compareTo(T o),用来比较当前对象和传入的参数�Q�查看jdk api�Q�共有这一批类实现了此接口�Q�见下图

打开实现了该接口的Integer包装�c�L��看源�?/div>

public final class Integer extends Number implements Comparable<Integer> {

    public int compareTo(Integer anotherInteger) {
    int thisVal = this.value;
    int anotherVal = anotherInteger.value;
    return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
    }

可以看到该方法通过当前的Integer对象的值是否大于传入的参数来得到返回��|��Integer的compareTo实现是按数字大小的自然排序，再找另一个例子String

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
{
public int compareTo(String anotherString) {
    int len1 = count;
    int len2 = anotherString.count;
    int n = Math.min(len1, len2);
    char v1[] = value;
    char v2[] = anotherString.value;
    int i = offset;
    int j = anotherString.offset;

    if (i == j) {
        int k = i;
        int lim = n + i;
        while (k < lim) {
        char c1 = v1[k];
        char c2 = v2[k];
        if (c1 != c2) {
            return c1 - c2;
        }
        k++;
        }
    } else {
        while (n-- != 0) {
        char c1 = v1[i++];
        char c2 = v2[j++];
        if (c1 != c2) {
            return c1 - c2;
        }
        }
    }
    return len1 - len2;
    }

可以看出String的compareTo实现是按字符串中字符的Unicode��D��行排序的�Q�也真是因�ؓ各种�c�d��现的不同�Q�所以只有在�怺�可比的类才能�q�行排序�Q�否则会抛出java.lang.ClassCastException的异常。应该说Comparable是集合内部实现的排序�Q�想要进行集合外的排序就需要Comparator接口�?br />
Comparator
如果一个类不能实现Comparable接口�Q�那么我们自己可以提供Comparator的排序，如果你不喜欢�~�省的Comparator行�ؓ�Q�照样可以编写自��q��Comparator�?br />
Comparator只有2个方法，分别为int compare(T o1, T o2) 和boolean equals(Object obj)

Comparator的compare�Ҏ��的返回值和Comparable的compareTo�q�回值基本相��|��如果排序�W�一个元素出现在�W�二个元素之前，则返回一个负��|��如果�W�一个元素出现在�W�二个元素后面，�q�回一个正��|��再否则，�q�回零。与Comparable不同的是Comparator是由用户自行军_��处理�?br /> 通过一个小例子可以比较明确的看�?/div>

      class ComparatorTest implements Comparator{
          public int compare(Object u1, Object u2) {
            String uname1 = ((User)u1).getName();
            String uname2 = ((User)u2).getName();
            return uname1.compareTo(uname2);
        }
      }
      class User {
          private String name;
          public String getName(){
              return this.name;
          }
      }

Comparator比较函数��Ҏ��些对�?collection �q�行整体排序。可以将 Comparator 传递给 sort �Ҏ��Q�如 Collections.sort�Q�，从而允许在排序��序上实现精��控制。还可以使用 Comparator 来控制某些数据结构（�?TreeSet �?TreeMap�Q�的��序�?/div>

陈于�?/a> 2011-06-15 15:07 发表评论

java数据�l�构-HashMap

Tue, 15 Feb 2011 11:18:00 GMT

一直以来似乎都有一个错觉，认�ؓmap跟其他的集合�c�M��L��承自Collection�Q�其实不�Ӟ��Map和Collection在结构层�ơ上是没有�Q何关�pȝ��Q�通过查看源码可以发现map所有操作都是基于key-value对，而不是单独的元素�?br />
下面以HashMap��Z��子，深入对Map的实现机制进行了解，在这个过�E�中�Q�请打开jdk源码�?br />
Hash��法

HashMap使用Hash��法�Q�所以在解剖HashMap之间�Q�需要先��单的了解Hash��法�Q�Hash��法一般也成�ؓ散列��法�Q�通过散列��法��Q意的��D�{化成固定的长度输出，该输出就是散列��|��q�是一�U�压�~�映��，也就是，散列值的�I�间�q�远��于输入的值空间�?br /> ��单的��_��hash��法的意义在于提供了一�U�快速存取数据的�Ҏ��,它用一�U�算法徏立键��g��真实��g��间的对应关系,(每一个真实值只能有一个键�?但是一个键值可以对应多个真实�?,�q�样可以快速在数组�{�里面存取数据�?br />
下面我们建立一个HashMap,然后往里面攑օ�12对key-value�Q�这个HashMap的默认数�l�长度�ؓ16�Q�我们的key分别存放在该数组的格子中�Q�每个格子下面存攄��元素又是以链表的方式存放元素�?br />

    public static void main(String[] args) {
        Map map = new HashMap();
        map.put("What", "chenyz");
        map.put("You", "chenyz");
        map.put("Don't", "chenyz");
        map.put("Know", "chenyz");
        map.put("About", "chenyz");
        map.put("Geo", "chenyz");
        map.put("APIs", "chenyz");
        map.put("Can't", "chenyz");
        map.put("Hurt", "chenyz");
        map.put("you", "chenyz");
        map.put("google", "chenyz");
        map.put("map", "chenyz");
        map.put("hello", "chenyz");
    }

当我们新��d��一个元素时�Q�首先我们通过Hash��法计算��个元素的Hash值的hashcode�Q�通过�q�个hashcode的��|��我们��可以计��出�q�个新元素应该存攑֜��q�个hash表的哪个格子里面�Q�如果这个格子中已经存在元素�Q�那么就把新的元素加入到已经存在格子元素的链表中�?br />
�q�行上面的程序，我们对HashMap源码�q�行一点修改，打印出每个key对象的hash�?br />
What-->hash��|��8
You-->hash��|��3
Don't-->hash��|��7
Know-->hash��|��13
About-->hash��|��11
Geo-->hash��|��12
APIs-->hash��|��1
Can't-->hash��|��7
Hurt-->hash��|��1
you-->hash��|��10
google-->hash��|��3
map-->hash��|��8
hello-->hash��|��0

计算出来的Hash值分别代表该key应该存放在Hash表中对应数字的格子中�Q�如果该格子已经有元素存在，那么该key��׃��链表的方式依�ơ放入格子中

从上表可以看出，Hash表是�U�性表和链表的�l�合所得，�Ҏ��数据�l�构的定义，可以得出�_�劣的结论，Hash��法的存取速度要比数组差一些，但是比�v单纯的链表，在查扑֒�存取斚w��却要好多�?br />
如果要查找一个元素时�Q�同��L��方式�Q�通过Hash函数计算��个元素的Hash值hashcode�Q�然后通过�q�个hashcode��|��直接扑ֈ�跟这个hash值相对应的线性格子，�q�如该格子后�Q�对�q�个格子存放的链表元素逐个�q�行比较�Q�直到找到对应的hash倹{�?br />
在简单了解完Hash��法后，我们打开HashMap源码

初始化HashMap

下面我们看看Map map = new HashMap();�q�段代码�I�竟做了什么，发生了什么数据结构的变化�?br />
HashMap中几个重要的属�?br />
transient Entry[] table;
用来保存key-value的对象Entry数组�Q�也��是Hash�?br />
transient int size;
�q�回HashMap的键值对个数

final float loadFactor;
负蝲因子�Q�用来决定Entry数组是否扩容的因子，HashMap默认�?.75f

int threshold;
重构因子�Q?capacity * load factor)负蝲因子与Entry[]数组容积的乘�?br />

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{
    int threshold;

    final float loadFactor;

    transient Entry[] table;

    static final float DEFAULT_LOAD_FACTOR = 0.75f;

    static final int DEFAULT_INITIAL_CAPACITY = 16;

    public HashMap(int initialCapacity, float loadFactor) {
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal initial capacity: " +
                                               initialCapacity);
        if (initialCapacity > MAXIMUM_CAPACITY)
            initialCapacity = MAXIMUM_CAPACITY;
        if (loadFactor <= 0 || Float.isNaN(loadFactor))
            throw new IllegalArgumentException("Illegal load factor: " +
                                               loadFactor);

        // Find a power of 2 >= initialCapacity
        int capacity = 1;
        while (capacity < initialCapacity)
            capacity <<= 1;

        this.loadFactor = loadFactor;
        threshold = (int)(capacity * loadFactor);
        table = new Entry[capacity];
        init();
    }

以public HashMap(int initialCapacity, float loadFactor)构造函��Cؓ例，另外两个构造函数实际上也是以同�U�方式来构徏HashMap.

首先是要��定hashMap的初始化的长度，�q�里使用的策略是循环查出一个大于initialCapacity�?的次方的敎ͼ�例如initialCapacity的值是10�Q�那么大�?0的数�?�?�ơ方�Q�也��是16�Q�capacity的��D��赋予�?6�Q�那么实际上table数组的长度是16�Q�之所以采用这��L��{�略来构建Hash表的长度�Q�是因�ؓ2的次方运��对于计��机来说是有相当的效率�?br />
loadFactor�Q�被�U�Cؓ负蝲因子�Q�HashMap的默认负载因子是0.75f

threshold�Q�接下来是重构因子，��p��载因子和定w��的乘机组成，它表�C�当HashMap元素被存放了多少个之后，需要对HashMap�q�行重构�?br />
通过�q�一�p�d��的计��和定义后，初始化Entry[] table;

put(key,value)

接下来看一对key-value是如何被存放到HashMap中：put(key,value)

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());

        int i = indexFor(hash, table.length);
        System.out.println(key+"-->hash��|��"+i);//�q�就是刚才程序打印出来的key对应hash�?/span>
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

    static int hash(int h) {
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

    static int indexFor(int h, int length) {
        return h & (length-1);
    }

�q�里是整个hash的关键，��h��开源码查看一步一步查看�?br />
hash(key.hashCode()) 计算出key的hash�?//对于hash()的算法，�q�里有一��分析很透彻的文�?lt;HashMap hash�Ҏ��分析>
indexFor(hash, table.length) 通过一个与��法计算出来�Q�该key应在存放在Hash表的哪个格子中�?br /> for (Entry e = table[i]; e != null; e = e.next) 然后再遍历table[i]��g��的链表，判断是否已经存在一��L��key�Q�如果存在一��L��key��|��那么��q��新的value覆盖旧的value�Q��ƈ把旧的value��D��回�?br /> addEntry(hash, key, value, i) 如果�l�过遍历链表没有发现同样的key�Q�那么进行addEntry函数的操作，增加当前key到hash表中的第i个格子中的链表中

    void addEntry(int hash, K key, V value, int bucketIndex) {
        Entry<K,V> e = table[bucketIndex];
        table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
        if (size++ >= threshold)
            resize(2 * table.length);
    }

Entry e = table[bucketIndex]; 创徏一个Entry对象来存��N��|��ps:Entry对象是一个链表对象）
table[bucketIndex] = new Entry(hash, key, value, e); ��Entry对象��d��到链表中
if (size++ >= threshold) resize(2 * table.length); 最后将size�q�行自增�Q�判断size值是否大于重构因子，如果大于那么��是用resize�q�行扩容重构�?br />

�q�里��Z��么是否需要扩定w��构，其实是涉及到负蝲因子的性能问题

loadFactor负蝲因子
上面说过loadFactor是一个hashMap的决定性属性，HashSet和HashMap的默认负载因子都�?.75�Q�它表示�Q�如果哈希表的容量超�q?/4�Ӟ��自动成倍的增加哈希表的定w��Q�这个值是权衡了时间和�I�间的成本，如果负蝲因子较高�Q�虽然会减少对内存空间的需求，但也会增加查找数据的旉��开销�Q�无论是put()和get()都涉及到�Ҏ��据进行查扄��动作�Q�所以负载因子是不适宜讄��q�高

get(key)

接下来看看get(key)做了什�?br />

    public V get(Object key) {
        if (key == null)
            return getForNullKey();
        int hash = hash(key.hashCode());
        for (Entry<K,V> e = table[indexFor(hash, table.length)];
             e != null;
             e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k)))
                return e.value;
        }
        return null;
    }

�q�些动作��g��是跟put(key�Q�value)相识�Q�通过hash��法获取key的hash码，再通过indexFor定位��key存在于table的哪一个下表，获取该下标然后对下标中的链表�q�行遍历比对�Q�如果有�W�合��q��接返回该key的value倹{�?br />
keySet()

�q�里�q�涉及另一个问题，上面说了HashMap是跟set没有��M��亲属关系�Q�但map也一样实��C��keySet接口�Q�下面谱析一下keySet在hashMap中是如何实现的，�q�里�l�出部分代码�Q�请�l�合源码查看

public K next() {
            return nextEntry().getKey();
        }

    final Entry<K,V> nextEntry() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            Entry<K,V> e = next;
            if (e == null)
                throw new NoSuchElementException();

            if ((next = e.next) == null) {
                Entry[] t = table;
                while (index < t.length && (next = t[index++]) == null)
                    ;
            }
        current = e;
            return e;
        }

代码很简单，��是�Ҏ��个格子里面的链表�q�行遍历�Q�也正是�q�个原因�Q�当我们依次��key值put�q�hashMap中，但在使用map.entrySet().iterator()�q�行遍历时候却不是put时候的��序�?br />
扩容
在前面说到put函数的时候，已经提过了扩容的问题

if (size++ >= threshold)
resize(2 * table.length);

�q�里一个是否扩容的判断�Q�当数据辑ֈ�了threshold所谓的重构因子�Q�而不是HashMap的最大容量，��p��行扩宏V�?br />

    void resize(int newCapacity) {
        Entry[] oldTable = table;
        int oldCapacity = oldTable.length;
        if (oldCapacity == MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return;
        }

        Entry[] newTable = new Entry[newCapacity];
        transfer(newTable);
        table = newTable;
        threshold = (int)(newCapacity * loadFactor);
    }

    void transfer(Entry[] newTable) {
        Entry[] src = table;
        int newCapacity = newTable.length;
        for (int j = 0; j < src.length; j++) {
            Entry<K,V> e = src[j];
            if (e != null) {
                src[j] = null;
                do {
                    Entry<K,V> next = e.next;
                    int i = indexFor(e.hash, newCapacity);
                    e.next = newTable[i];
                    newTable[i] = e;
                    e = next;
                } while (e != null);
            }
        }
    }

transfer�Ҏ��实际上是��所有的元素重新�q�行一些hash�Q�这是因为容量变化了�Q�每个元素相对应的hash��g��会不一栗��?br />
使用HashMap

1.不要再高�q�发中��用HashMap�Q�HashMap是线�E�不安全�Q�如果被多个�U�程�׃�n之后�Q�将可能发生不可预知的问题�?br /> 2.如果数据大小事固定的�Q�最好在初始化的时候就�l�HashMap一个合理的定w��|��如果使用new HashMap()默认构造函敎ͼ�重构因子的值是16*0.75=12�Q�当HashMap的容量超�q�了12后，��׃��q�行一�p�d��的扩容运��，重徏一个原来成倍的数组�Q��ƈ且对原来存在的元素进行重新的hash�q�算�Q�如果你的数据是有成千上万的�Q�那么你的成千上万的数据也要跟这你的扩容不断的hash�Q�这��生高额的内存和cpu的大量开销�?br />
当然啦，HashMap的函数还有很多，不过都是��Z��table的链表进行操作，当然也就是hash��法�Q�Map & hashMap在��^时我们的应用非常多，最重要的是我们要对每句代码中每块数据结构变化心中有数�?br />

上面主要是参考了jdk源码�Q�数据结构和一些相兌��料本着好记性不如烂博客的精��记录下来，希望朋友们如果发觉哪里不对请指出来，虚心��h��

----------------------------------------

by 陈于�?
QQ:34174409
Mail: dongbule@163.com

陈于�?/a> 2011-02-15 19:18 发表评论

java数据�l�构-List

Sun, 16 Jan 2011 09:36:00 GMT

List在数据结构中表现为是�U�性表的方式，其元素以�U�性方式存储，集合中允许存��N��复的对象�Q�List接口主要的实现类�?br /> ArrayList
ArrayList其实��是一�l�长度可变的数组�Q�当实例化了一个ArrayList�Q�该数据也被实例化了�Q�当向集合中��d��对象�Ӟ��数组的大��也随着改变�Q�这样它所带来的有优点是快速的随机讉K��Q�即使访问每个元素所带来的性能问题也是很小的，但缺点就是想其中��d��或删除对象速度慢，当你创徏的数�l�是不确定其定w��Q�所以当我们改变�q�个数组时就必须在内存中做很多的处理�Q�如你想要数�l�中��L��两个元素中间��d��对象�Q�那么在内存中数�l�要�U�d��所有后面的对象�?br />
LinkedList
LinkedList是通过节点的连接实现链表的数据�l�构�Q�向linkedList中插入或删除元素的速度是特别快�Q�而随��问的速度相对较慢�Q�这个是�׃��链表本��n的性质造成的，在链表中�Q�每个节炚w��包含了前一个节点的引用�Q�后一个节点的引用和节点存储��|��当一个新节点插入式，只需要修改其中相关的前后关系节点引用卛_��Q�删除节点也是一栗��操作对象只需要改变节点的链接�Q�新节点可以存放在内存的��M��位置�Q�但也就是因为如此LinkedList虽然存在get()�Ҏ��Q�但是这个方法通过遍历节点来定位所以速度很慢。LinkedList�q�单独具addFrist(),addLast(),getFrist(),getLast(),removeFirst(),removeLast()�Ҏ��Q�这些方法��得LinkedList可以作�ؓ堆栈�Q�队列，和双队列来��用�?br />
说白了，ArrayList和LinkedList��是数据�l�构中的��序存储表和铑ּ�存储表�?br />
ArrayList构造原�?/strong>
上面已经清楚ArrayList和LinkedList��是数据�l�构的顺序表和链�?不清楚的��ȝ��数据�l�构的书)�Q�下面简单分析一下它们的实现方式�?br /> 下表是摘自sum提供的ArrayList的api文��

ArrayList()
          构造一个初始容量�ؓ 10 的空列表�?br /> ArrayList(Collection c)
          构造一个包含指�?collection 的元素的列表�Q�这些元素是按照�?collection 的�P代器�q�回它们的顺序排列的�?br /> ArrayList(int initialCapacity)
          构造一个具有指定初始容量的�I�列表�?br />
�W�一个构造函数是没有默认构徏了一个初始容�?0的空列表�Q�第二个构造函数是制定collection元素的列表，�W�三个构造函数是��q��h��定构造的列表初始化容量多��，如果使用�W�一个构造函数则表示默认调用该参��CؓinitialCapacity=10来构造一个列表对象�?br />
ArrayList源码�E�微�q�行分析

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    private static final long serialVersionUID = 8683452581122892189L;

    private transient Object[] elementData;

    private int size;

    public ArrayList(int initialCapacity) {
    super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    this.elementData = new Object[initialCapacity];
    }

    public ArrayList() {
    this(10);
    }

    public ArrayList(Collection extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
    }

    public int size() {
    return size;
    }

}

可以发现ArrayList中包含两个主要的属�?br />
    private transient Object[] elementData;

    private int size;

其中elementData[]是列表的实现的核心数�l�，我们使用该数�l�来存放集合中的数据�Q�而我们的构造函数所传递的initialCapacity参数是构��数组的长度�?br /> 在看看size的实现�Ş式，它的作用是返回size的属性值的大小�Q�我们再看看另外一个构造函数public ArrayList(Collection c)�Q�该构造函数的作用是把另外一个容器对象中的元素放入当点的List对象中。首先是通过调用另外一个容器对象c的size()来设�|�当前List对象的size属性的长度大小。接下来��׃��乎对elementData[]数组�q�行初始化，最后通过Arrays.copyOf(U[] original, int newLength, Class newType)�Ҏ��把当前容器中的对象都存放�q�新的数�l�elementData�Q�主要就完成了一个列表的创徏�?br />
ArrayList定w��扩充
�q�有一个问题就是我们所建立的ArrayList是��用数�l�来实现的，但数�l�的长度一旦被初始化就不能改变�Q�而我们在�l�此列表对象��d��元素时却没有受到长度的限�Ӟ��所以，ArrayList的elementData属性一定是存在一个动态扩充容量的机制�Q�下面把相关的部分源码脓出来再做研究

public boolean add(E e) {
    ensureCapacity(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
    }

    protected transient int modCount = 0;

    /**
     * Increases the capacity of this ArrayList instance, if
     * necessary, to ensure that it can hold at least the number of elements
     * specified by the minimum capacity argument.
     *
     * @param   minCapacity   the desired minimum capacity
     */
    public void ensureCapacity(int minCapacity) {
    modCount++;
    int oldCapacity = elementData.length;
    if (minCapacity > oldCapacity) {
        Object oldData[] = elementData;
        int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity < minCapacity)
        newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
    }
    }

看看public boolean add(E e)�Ҏ��Q�可以发现在��d��一个元素到容器中的时候，我们会先通过ensureCapacity(size + 1)判断该数�l�是否需要扩充�?br /> public void ensureCapacity(int minCapacity)�q�个�Ҏ��是用来判断当前的数组是否需要扩充，�q�且该扩充多��。modCount++; 表示当前的对象对elementData数组�q�行了多��次扩充�Q�清�I�和�U�除�{�操作，相当于是一个对当前List对象的一个操作记录数�?br /> int oldCapacity = elementData.length; 初始化oldCapacity�Q�表�C�Zؓ当前elementData数组的长度�?br /> if (minCapacity > oldCapacity) 判断minCapacity和oldCapacity谁大�Q�来军_��是否需要扩充�?br /> int newCapacity = (oldCapacity * 3)/2 + 1; 扩充的策列是判断(oldCapacity * 3)/2 + 1和minCapacity两者之间谁更大�Q�取更大的数作�ؓ扩充后数�l�的initialCapacity��|��然后使用数组拯��的方式，把以前的数据转移到新的数�l�对象中
如果minCapacity ��于 oldCapacity ��׃��需要再扩充�?br />
ArrayList删除元素

public E remove(int index) {
    RangeCheck(index);

    modCount++;
    E oldValue = (E) elementData[index];

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                 numMoved);
    elementData[--size] = null; // Let gc do its work

    return oldValue;
    }

    private void RangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(
        "Index: "+index+", Size: "+size);
    }

在看看ArrayList�U�除元素是怎么实现的，首先判断需要删除的index是否在elementData数组的下标内�Q�如不存在则抛出IndexOutOfBoundsException�?br /> modCount++; 与扩充元素一个，删除元素也记下来操作数�?br /> E oldValue = (E) elementData[index]; 获取需要删除元素的对象�?br /> int numMoved = size - index - 1; 获取需要被删除元素的下标，删除该元素后�Q�数�l�需要在此元素下标后的所有对象进行内存的�U�d��?br /> System.arraycopy(elementData, index+1, elementData, index,numMoved);对numMoved后面的所有对象通过copy的方式进行内存的�U�d��重新构徏数组�?br />
说完ArrayList的实玎ͼ�再说说linkedList

构徏双链�?LinkedList)
LinkedList是类��g��C语言的双链表�Q�双链表比单链表多了一个域�Q�这个双链表��有了三个域�Q�一个域来用存储数据元素�Q�一个用来指向后�l�节点，另一个是指向�l�点的直接前��p��炏V�?br />

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    private transient Entry<E> header = new Entry<E>(null, null, null);
    private transient int size = 0;

    public LinkedList() {
        header.next = header.previous = header;
    }

    private static class Entry<E> {
    E element;
    Entry<E> next;
    Entry<E> previous;

    Entry(E element, Entry<E> next, Entry<E> previous) {
        this.element = element;
        this.next = next;
        this.previous = previous;
    }
    }

}

在Entry�c�M��Q�定义了三个属性，分别为E element 表示数据与，Entry next为后�l�指针域�Q�Entry previous为前驱指针域�?br /> 在LinkedList中定义了一个重要的属性header�Q�头�l�点�Q�不会纳入链表的��d��?该节点的previous是指向最后节点，next是指向第一节点�?br /> 构造函数LinkedList() 构造一个空列表。将header的前驱指针域和后�l�指针域都指向了自己,看到�q�里可以发现�Q�next和previous��是一个引用，其实也相�{�于C里面的指针，不过C不会处理�I�指针，直接放操作系�l�处理了�Q�java��q��接抛出NullPointerException�Q�根本不让它破坏�pȝ��的机会�?br />
LinkedList元素变动
上面说到了LinkedList的新增和删除的效率比ArrayList的高�Q�实际上�?链表操作�q�些�Ҏ��Ӟ��只需要改�?个节点各自的前驱指针和后�l�指针域�Q�而ArrayList是需要移动很多的元素�?br />

public boolean add(E e) {
    addBefore(e, header);
        return true;
    }

    private Entry<E> addBefore(E e, Entry<E> entry) {
    Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
    newEntry.previous.next = newEntry;
    newEntry.next.previous = newEntry;
    size++;
    modCount++;
    return newEntry;
    }

    private E remove(Entry<E> e) {
    if (e == header)
        throw new NoSuchElementException();

        E result = e.element;
    e.previous.next = e.next;
    e.next.previous = e.previous;
        e.next = e.previous = null;
        e.element = null;
    size--;
    modCount++;
        return result;
    }

相比ArrayList的add()�Ҏ��Q�LinkedList实现��h��非常��单，主要是两行代码：
newEntry.previous.next = newEntry;��上一节点的后�l�节�Ҏ��向新增的节点
newEntry.next.previous = newEntry;头节点的前驱节点指向新增节点�Q�size和modCount自增记录�?br />
同样remove的实��C��非常��?br /> e.previous.next = e.next;该节点的后一节点的后去节�Ҏ��向该节点的后��p��点，
e.next.previous = e.previous;该节点的后一节点的前��p��Ҏ��向该节点的前��p��炏V�?br /> e.next = e.previous = null;把该节点的前��p��点和后驱节点全部指向null�?br /> e.element = null;把该节点的数据域讄��为null�?br />
随机讉K��
相比��序表，链表的随��问效率要低得�?理论说法�Q�不是绝�?�Q�ArrayList可以�Ҏ��索引可��行随��问，而LinkedList则不要遍历访问�?br />

public E get(int index) {
        return entry(index).element;
    }

    private Entry<E> entry(int index) {
        if (index < 0 || index >= size)
            throw new IndexOutOfBoundsException("Index: "+index+
                                                ", Size: "+size);
        Entry<E> e = header;
        if (index < (size >> 1)) {
            for (int i = 0; i <= index; i++)
                e = e.next;
        } else {
            for (int i = size; i > index; i--)
                e = e.previous;
        }
        return e;
    }

上列的代码是对一个链表的遍历�Q�其中包含了一个算法，如果�l�的索引号小于总节�Ҏ��的一半，则在链表的前半部分第一个节点完�q�行遍历�Q�如果给的烦引号大于总节�Ҏ��的一半，则从最后一个节点往前进行遍历直到烦引号�?br />
最�?strong>�ȝ��一下ArrayList和LinkedList的各自特�?br /> 1.ArrayList是基于线性表的顺序存储表�Q�LinkedList是基本线性表的链表存储表�?br /> 2.对于新增和删除元素，LinkedList比较占有优势�Q�只需要变前后2个节点，而ArrayList要移动数据�?br /> 3.对于随机讉K��来说�Q�ArrayList比较占有优势�Q�可以根据烦引号快速访问，而LinkedList则需要遍历集合的元素来定位�?br /> 4.而对于�P代操�?iterate)和查找操�?indexOf)�Q�两者是差不多�?br /> 不过上面都是��Z��理论�Q�具体问题还是要�Ҏ��事实�q�行分析�Q�如ArrayList删除的元素刚好是队列的最后一个元素，那么是无需要移动数据的�Q�大体我们可以认为需要随��问较多的那么比较适合用ArrayList�Q�如果是插入和删�?如消息队�?较多的那么就需要考虑LinkedList�?br />
上面主要是参考了jdk源码�Q�数据结构和一些相兌��料本着好记性不如烂博客的精��记录下来，希望朋友们如果发觉哪里不对请指出来，虚心��h��

----------------------------------------

by 陈于�?
QQ:34174409
Mail: dongbule@163.com

陈于�?/a> 2011-01-16 17:36 发表评论

java数据�l�构-set

Thu, 06 Jan 2011 10:07:00 GMT

看一�D�set的简单应用代�?br />

        Set<String> set = new HashSet<String>();
        String a = "1",b = "2",c = "1",d = "3",e = "2";
        set.add(a);
        set.add(b);
        set.add(c);
        set.add(d);
        set.add(e);

        Iterator it = set.iterator();
        while(it.hasNext()){
            String s = (String)it.next();
            System.out.print(s+",");
        }
        System.out.println("一共有对象�Q?/span>"+set.size()+"�?/span>"); //打印�l�果是：3,2,1,一共有对象�Q?�?/div>
我们都知道Set是一�U�最��单的集合�Q�对象的排序无特定的规则�Q�集合里面存攄��是对象的引用�Q�所以没有重复的对象�Q�在上面的代码中�Q�程序创��Z��a、b、c、d、e五个变量�Q�其中a和c�Q�b和e所引用的字�W�串是一致的�Q�然后向set��d��了这5个变量。打印出来的size()只有3个，实际上向集合加入的只�?个对象，在执行Set的add()�Ҏ��时已�l�进行了判断�q�个对象是否存在于集合，如果对象已经存在则不�l�箋执行�?br />

Set的接口有两个实现�c�，HashSet和TreeSet�Q�HashSet是按照哈希算法来�q�行存取集合中的对象�Q�存取速度比较快，TreeSet�c�L��C�Z��SortedSet接口�Q�具有排序功�?br />
HashSet
HashSet是按照哈希算法来存取集合中的对象�Q�具有很好的存取和查找性能�Q�当向集合中加入一个对象时�Q�HashSet会调用对象的hashCode()�Ҏ��来获取哈希码�Q�然后根据这个哈希吗来计��对象在集合中的存放位置�?br /> 在Object�c�M��定义了hashCode()和equal()�Q�equal()是按照内存地址比较对象是否相同�Q�如果object1.equal(object1)w为true�Ӟ��则表明了object1和object2变量实际上引用了同一个对象，那么object1和object2的哈希码也是肯定相同�?br /> �E�微的看看HashSet的源�?br />

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{

    private transient HashMap<E,Object> map;
    private static final Object PRESENT = new Object();
        public HashSet() {
        map = new HashMap<E,Object>();
    }

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }
}

public class HashMap<K,V>
    extends AbstractMap<K,V>
    implements Map<K,V>, Cloneable, Serializable
{

    public V put(K key, V value) {
        if (key == null)
            return putForNullKey(value);
        int hash = hash(key.hashCode());
        int i = indexFor(hash, table.length);
        for (Entry<K,V> e = table[i]; e != null; e = e.next) {
            Object k;
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;
                e.value = value;
                e.recordAccess(this);
                return oldValue;
            }
        }

        modCount++;
        addEntry(hash, key, value, i);
        return null;
    }

}

我们会发现我们调用Set的add()�Ҏ��其实是返回一个transient HashMap.put(e, PRESENT)�Q�再跟进HashMap的put(K key, V value)�Ҏ��q�行查看,可以看到int hash = hash(key.hashCode());使用了set.add(key)的key做了一个哈希处理得��C��个哈希码�Q�然后再��Entry做了一个遍历，使用equal()�Ҏ��对讲原有的对象和新添加的对象�q�行了一个比较，如果出现了true的情况，��q��接返回一个oldValue�Q�如果在遍历�Ҏ��的过�E�中没有出现ture的情况，则��l�一下的步骤modCount++�Q�将对象��L��自加�Q��ƈ且��l�执行addEntry()的操作，下面涉及HashMap的操作就不��l��?br />
实际上HashSet的底层实现是��Z��HashMap�Q�所以在此处涉及到Hash��法不展开�Q�详�l�可以见另一��?a id="viewpost1_TitleUrl" href="../archive/2011/02/15/344387.html">java数据�l�构-HashMap�?br />
TreeSet
TreeSet�c�L��实现了SortedSet接口�Q�所以能够对集合中的对象�q�行排序

        Set iset = new TreeSet();
        iset.add(new Integer(1));
        iset.add(new Integer(10));
        iset.add(new Integer(5));
        iset.add(new Integer(8));
        iset.add("2");
        Iterator it2 = iset.iterator();
        while(it2.hasNext()){
            Integer s = (Integer)it2.next();
            System.out.print(s+",");
        }
        System.out.println("一共有对象�Q?/span>"+iset.size()+"�?/span>");//打印出来的结果：1,2,5,8,10,一共有对象�Q?�?/span>

当TreeSet向集合加入一个对象时�Q�会把它插入到有序的对象序列中，TreeSet包括了两�U�排序方式，自然排序和客户化排序�Q�在默认的情况下使用自然排序�?br />
自然排序
在jdk�c�d��中，有部分类实现了Comparable接口�Q�如Integer�Q�Double�{�等�Q�Comparable接口有一个compareTo()�Ҏ��可以�q�行比较�Q�TreeSet调用对象的compareTo()�Ҏ��比较集合中对象的大小�Q�然后进行升序排序。如Integer�Q?br />

��Z��Comparable的属性，使用自然排序�Ӟ��只能向TreeSet集合中加入同�c�d��的对象，�q�且�q�些对象的类必须实现了Comparable的接口，以下我们��试向TreeSet集合加入两个不同�c�d��的对象，会发现抛出ClassCastException

Set iset = new TreeSet();
iset.add(new Integer(1));
iset.add(new Integer(8));
iset.add("2");
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer

我们再打开TreeSet的源码进行查�?br />

public class TreeSet<E> extends AbstractSet<E>
    implements NavigableSet<E>, Cloneable, java.io.Serializable
{
    private transient NavigableMap<E,Object> m;

    private static final Object PRESENT = new Object();

    public boolean add(E e) {
    return m.put(e, PRESENT)==null;
    }

}

NavigableMap为接口，实现�c�MؓTreeMap

public class TreeMap<K,V>
    extends AbstractMap<K,V>
    implements NavigableMap<K,V>, Cloneable, java.io.Serializable
{
    private final Comparator super K> comparator;

    private transient Entry<K,V> root = null;

    public V put(K key, V value) {
        Entry<K,V> t = root;
        if (t == null) {
        // TBD:
        // 5045147: (coll) Adding null to an empty TreeSet should
        // throw NullPointerException
        //
        // compare(key, key); // type check
            root = new Entry<K,V>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry<K,V> parent;
        // split comparator and comparable paths
        Comparator super K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key); //此处如果�c�d��不相同可能抛出ClassCastException
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        else {
            if (key == null)
                throw new NullPointerException();
            Comparable super K> k = (Comparable super K>) key;
            do {
                parent = t;
                cmp = k.compareTo(t.key);
                if (cmp < 0)
                    t = t.left;
                else if (cmp > 0)
                    t = t.right;
                else
                    return t.setValue(value);
            } while (t != null);
        }
        Entry<K,V> e = new Entry<K,V>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }

}

首先判断原始集合是否存在�Q�如果不存在则直接创建，无需比较�?br /> 如果原始集合存在的话�Q�先��d��出Comparator对象�Q�然后遍历原始集合t�Q��用parent��Z��时比较��|��逐个使用compare(key, t.key)�Ҏ��与添加对象key�q�行比较�Q�决定元素排在集合的left或right�?br />
客户端排�?/strong>
客户端排序时因�ؓjava.util.Comparator接口提供了具体的排序方式�Q?lt;Type>指定了被比较对象的类型，Comparator有个compare(Type x,Type y)的方法，用于比较两个对象的大��?br />

public class NameComparator implements Comparator<Name>{

    public int compare(Name n1,Name n2){
        if(n1.getName().compareTo(n2.getName())>0) return -1;
        if(n1.getName().compareTo(n2.getName())<0) return 1;

        return 0;
    }

    public static void main(String[] args) {
        Set<Name> set = new TreeSet<Name>(new NameComparator());

        Name n1 = new Name("ray");
        Name n2 = new Name("tom");
        Name n3 = new Name("jame");
        set.add(n1);
        set.add(n2);
        set.add(n3);

        Iterator it = set.iterator();
        while(it.hasNext()){
            Name s = (Name)it.next();
            System.out.print(s.getName()+",");
        }
        System.out.println("一共有对象�Q?/span>"+set.size()+"�?/span>");
    }
}//打印�l�果是：tom,ray,jame,一共有对象�Q?�?/span>

道理与自然排序其实相同，都是通过实现Comparator接口�Q�就不细说了,可能有些说得不对的地方，�Ƣ迎指正

----------------------------------------

by 陈于�?
QQ:34174409
Mail: dongbule@163.com

陈于�?/a> 2011-01-06 18:07 发表评论