BlogJava-上善若水-随笔分类-Core Java

分布式Map中实现引用计数

DLevin — Mon, 20 Apr 2015 12:30:00 GMT

前言

在《ReferenceCountSet无锁实现》中，详细介绍了如何在一个进程中实现一个无锁版本的ReferenceCountSet（或者说是在自己的代码里没有锁），但是最近遇到一个问题，如果是在分布式的环境中呢？如何实现这个引用计数？这个问题如果从头开始写，会是一个比较复杂的问题，在实际中，我们可以使用ZooKeeper设置时的version机制来实现，即CAS（Compare-And-Set）。这是一个本人在实际项目中遇到的一个问题，但是会更简单一些，因为在我们的项目中，我们使用GemFire，即已经有一个现成的分布式Map了（在Gemfire中叫做Region），所以问题简化成如果如何使用一个分布式Map实现引用计数？

实现

如果对ConcurrentMap接口比较熟悉的话，这个其实是一个比较简单的问题。在ConcurrentMap中最主要的就是引入几个CAS相关的操作：

public interface ConcurrentMap extends Map {
    V putIfAbsent(K key, V value);
    boolean remove(Object key, Object value);
    boolean replace(K key, V oldValue, V newValue);
    V replace(K key, V value);
}

在《ReferenceCountSet无锁实现》中我们只需要使用putIfAbsent就可以了，剩下的实现可以交给AtomicInteger提供的CAS来实现，因为它是在同一个进程中，但是如果在分布式的环境中就不能使用这个AtomicInteger，这个时候应该怎么办呢？其实这个时候我们就可以求助于replace方法了。replace方法的注释中这样描述：

  /**
     * Replaces the entry for a key only if currently mapped to a given value.
     * This is equivalent to
     *


     *   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
     *       map.put(key, newValue);
     *       return true;
     *   } else return false;

     * except that the action is performed atomically.
     *
     * @param key key with which the specified value is associated
     * @param oldValue value expected to be associated with the specified key
     * @param newValue value to be associated with the specified key
     * @return true if the value was replaced
     * @throws UnsupportedOperationException if the put operation
     *         is not supported by this map
     * @throws ClassCastException if the class of a specified key or value
     *         prevents it from being stored in this map
     * @throws NullPointerException if a specified key or value is null,
     *         and this map does not permit null keys or values
     * @throws IllegalArgumentException if some property of a specified key
     *         or value prevents it from being stored in this map
     */
    boolean replace(K key, V oldValue, V newValue);

在ConcurrentMap的value中我们只需要给Integer，然后用replace去不断的尝试，即自己实现一个CAS：

private int incrementRefCount(Object key) {
    do {
        Integer curCount = distributedMap.get(key);
        if (curCount == null) {
            curCount = distributedMap.putIfAbsent(key, new Integer(1));
            if (curCount == null) {
                return 1;
            }
        }

        Integer newCount = new Integer(curCount.intValue() + 1);
        if (distributedMap.replace(key, curCount, newCount)) {
            return newCount;
        }
    } while (true);
}

主要逻辑就是这样了，其实比较简单，只是之前没有遇到过这个问题，所以感觉可以记录下来。或许什么时候补充一下ZooKeeper版本的实现。

DLevin 2015-04-20 20:30 发表评论

ReferenceCountSet无锁实现

DLevin — Fri, 05 Dec 2014 16:29:00 GMT

摘要: 记得很久以前有一次面试被问到如何编写无锁程序，我当时觉得那个面试官脑子进水了，我们确实可以在某些情况下减少锁的使用，但是怎么可能避免呢？当然我现在还是持这种观点，在Java中，你可以有很多方法减少锁的使用(至少在你自己的代码中看起来)： 1. 比如常见的可以使用volatile关键字来保证某个字段在一个线程中的更新对其他线程的可见性； 2.&nb... 阅读全文

DLevin 2014-12-06 00:29 发表评论

使用Exchanger实现两个线程之间的数据交互

DLevin — Sun, 23 Mar 2014 05:40:00 GMT

在看Jetty源码中的EndPointTest类，对EndPoint的测试，我的思路是：
1. 建立一个连接（创建ServerSocket实例，一般还会给定一个端口，其实可以bind(null)以让操作系统分配一个可用端口），新启动一个线程，在新线程中监听给定端口（调用accept方法）。
2. 发送客户端请求（创建一个Socket实例，并向该Socket写入请求数据）。
3. 在接收端读取数据，验证写入的请求和接收到的数据相同。

在以上流程实现中，accept方法返回的接收端Socket需要传给主线程，同时要保证使用该Socket是在accept方法返回之后，以我习惯，我会使用一个Lock或CountDownLatch：

private static class SocketHolder {
    Socket socket;
}

@Test
public void levinOldWayTest() throws Exception {
    final ServerSocket server = new ServerSocket(10240);

    final CountDownLatch latch = new CountDownLatch(1);
    final SocketHolder socketHolder = new SocketHolder();
    new Thread() {
        public void run() {
            try {
                socketHolder.socket = server.accept();
                latch.countDown();
            } catch(Exception ex) {
                ex.printStackTrace();
            }
        }
    }.start();

    Socket socket = new Socket(server.getInetAddress(), server.getLocalPort());
    socket.getOutputStream().write("My Test String".getBytes());

    latch.await(5, TimeUnit.SECONDS);
    byte[] receives = new byte[4096];
    int length = socketHolder.socket.getInputStream().read(receives);

    assertEquals("My Test String", new String(receives, 0, length));

    socket.close();
    socketHolder.socket.close();
    server.close();
}

不知道有多少人也像我一样把这段代码写成这样？这里有两个问题：
1. ServerSocket的监听的端口不一定是可用的，类似测试代码我之前没有写过，我估计自己正真在写的时候应该会想到让操作系统动态分配。
2. 为了在两个线程中传递数据，这里首先创建了一个SocketHolder类，然后使用CountDownLatch，写起来好麻烦。为了简化这段代码，可以使用Exchanger，即当一个生产者线程准备好数据后可以通过Exchanger将数据传递给消费者，而消费者在生产者传递过来数据后就可以消费了，这里的数据就是Socket。

改进后的代码如下：

@Test
public void levinImprovedWayTest() throws Exception {
    final ServerSocket server = new ServerSocket();
    server.bind(null);

    final Exchanger exchanger = new Exchanger();
    new Thread() {
        public void run() {
            try {
                exchanger.exchange(server.accept());
            } catch(Exception ex) {
                ex.printStackTrace();
            }
        }
    }.start();

    Socket socket = new Socket(server.getInetAddress(), server.getLocalPort());
    socket.getOutputStream().write("My Test String".getBytes());

    Socket receiverSocket = exchanger.exchange(null, 5, TimeUnit.SECONDS);
    byte[] receives = new byte[4096];
    int length = receiverSocket.getInputStream().read(receives);

    assertEquals("My Test String", new String(receives, 0, length));

    socket.close();
    receiverSocket.close();
    server.close();
}

DLevin 2014-03-23 13:40 发表评论

Java Core系列之TreeMap实现详解

DLevin — Sat, 26 Oct 2013 10:41:00 GMT

因为看EHCache中溢出文件的管理代码，它用到了AA－Tree作为文件中的磁盘管理，因而决定先复习以下红黑树(RBT, Red Black Tree)，顺便看看TreeMap的代码。关于红黑树，网上已经有各种相关的文章了，因而属于多一篇不多，少一篇不少的状态，因而我纯粹当作是我自己理解的纪录，加深印象，如果能对部分思路和我类似的人有一些帮助，那就最好了。基于这样的目的，我并不打算深入，如果想看更深入的或者更好的，可以读读我最后的参考链接。

红黑树引入的目的
首先要从对有序序列的查找问题开始，对一个静态的有序序列数组，只需要二分查找即可得到O(log(n))的查找效率；然而实现并不会显得那么“静态”，需要实现动态的插入、删除同时保持序列的有序性，并且尽量提高插入、删除、查找的效率。

为实现动态插入、删除，最简单的实现是二叉排序树(BST, Binary Sort Tree)，它具有以下性质：
1. 它可以是一个空树。
2. 若它的左子树不为空，则它的左子树所有节点的值均小于根节点的值。
3. 若它的右子树不为空，则它的右子树所有节点的值均大于根节点的值。
4. 它的左子树和右子树都是一个二叉排序树。
根据以上性质，
对查找，比较查找数和当前节点，如果查找数和当前节点相等，则找到返回；如果查找数小于当前节点，查找其左子树，如果查找数大于当前节点，查找其右子树，直到找到或直到叶子节点为null，返回null。
对插入，先查找这棵树，如果找到已存在的节点，更新节点值，否则把新值插入到最后一个为null的节点中。
对删除，首先找到要删除的节点，a）如果找到的节点P没有子节点，直接删除即可；b）如果找到的节点P只有左子树或右子树，删除该节点，并将其父节点原来的指针指向它唯一的左子树、或右子树即可；c）如果找到的节点P既有左子树又有右子树，可以有两种做法：I）删除节点P，把节点P的父节点原来指向P的指针指向节点P的左字节点，而将节点P的右节点插入到节点P右节点的最右叶子节点上（如果节点P是其父节点的右节点，则将节点P的父节点原来指向P节点的指针指向P节点的右子树，而将节点P的左子树插入到节点P最左叶子节点上），II）将节点P替换成节点P的直接前驱（或直接后继），然后删除节点P的直接前驱（或直接后继）（注：直接前驱查找：节点P左子树的最右节点，直接后继查找：节点P右子树的最左节点）。
二叉排序树实现比较简单，但是它查找效率却不理想，最好的效率是O(log(n))，最会效率为O(n)。

为了提高查找效率，后来有人提出了平衡二叉树（AVL树），它具有二叉排序树的所有特点，并添加了以下性质：
1. 左子树和右子树的深度之差绝对值不超过1。
2. 左子树和右子树都是平衡二叉树。
为了实现平衡二叉树，需要在没个节点上添加平衡因子字段，在插入后，如果发现平衡因子不符合性质1，则需要经过旋转以调整。平衡二叉树可以保证其查找的最好、最坏查找时间复杂度都为O(log(n))。

红黑树是平衡二叉树的变种，它是一种自平衡的二叉排序树，也需要通过一些旋转调整以保持它的性质，它的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。不同于平衡二叉树的高度平衡，红黑树只能保证从根到叶子节点的最长路径不超过最短路径的2倍，因而它的最坏查找时间复杂度为O(2log(n + 1))，然而有研究表明它的统计性能要好于平衡二叉树，因而它具有更广泛的应用。

红黑树的性质
一棵树需要满足以下性质才能保证它是一颗红黑树：
1. 它是一颗二叉查找树（BST）。
2. 它的所有节点是红色或黑色。
3. 它的根节点是黑色。
4. 它的叶子节点是黑色（空节点视为叶子节点）。
5. 它的红节点的子节点必须是黑色的；而黑节点的字节点可以是黑色或红色。
6. 它任一节点到其后代的叶子节点路径上有相同的黑色节点数。
一般的文章都是把性质列出来，然后根据这些性质来写代码实现（我也一样:)），但是如何得出这些性质呢？多问几个为什么总是好事，这个问题需要去读上面提到的论文，我没读过也不打算读，这貌似不是我能涉及的，那就提出问题不回答了。。。

TreeMap中红黑树的节点
对一颗树的节点，最基础是该节点的值、左节点指针、右节点指针。对TreeMap，因为它存储的是键值对，因而它包含了key、value，为了纪录节点的颜色，它还需要有color字段：

  private static final boolean RED   = false;
    private static final boolean BLACK = true;

    static final class Entry implements Map.Entry {
        K key;
        V value;
        Entry left = null;
        Entry right = null;
        Entry parent;
        boolean color = BLACK;
....
    }

TreeMap中红黑树节点插入
红黑数的插入分以下步骤：
1. 如果当前为空树，插入节点直接作为根节点，并将该节点颜色比较
2. 以二叉排序树的查找算法查找当前树，如果在当前树中找到已存在的节点，更新节点的值，并返回。
3. 否则，创建一个新节点，将其插入到最后一个查找到的叶子节点上，其初始颜色为红色。
4. 如果新插入节点的父节点是黑节点，则没有破坏当前红黑树的性质，直接返回。
5. 如果新插入节点的父节点是红节点，则需要做一些调整。
在TreeMap中，key值的比较可以通过构造TreeMap传入的Comparator实例，如果没有Comparator，则key必须实现Comparable接口作为比较逻辑，key不可以为null。以二叉排序树的算法插入新节点的代码比较简单：

  public V put(K key, V value) {
        Entry t = root;
        if (t == null) {
            compare(key, key); // type (and possibly null) check
            root = new Entry<>(key, value, null);
            size = 1;
            modCount++;
            return null;
        }
        int cmp;
        Entry parent;
        // split comparator and comparable paths
        Comparatorsuper K> cpr = comparator;
        if (cpr != null) {
            do {
                parent = t;
                cmp = cpr.compare(key, t.key);
                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();
            Comparablesuper K> k = (Comparablesuper 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 e = new Entry<>(key, value, parent);
        if (cmp < 0)
            parent.left = e;
        else
            parent.right = e;
        fixAfterInsertion(e);
        size++;
        modCount++;
        return null;
    }
    private void fixAfterInsertion(Entry x) {
        x.color = RED;
        ..
        root.color = BLACK;
    }

TreeMap中红黑树新节点插入后调整
红黑树的调整比较复杂，首先它会从当前节点向上查找，直到当前节点为null，或是root节点，或者当前节点的父节点颜色不是红色，然后根据以下不同情况做处理（设当前节点为C（红色），其父节点为P（红色），其祖先节点为A（黑色），其叔叔节点为U（待定））：
1. P是A的左子树，U节点颜色为红色，此时不管C是节点是P的左子树还是右子树，只需要将P和U设为黑色，A设为红色，则可保证当前局部树符合红黑树定义，把A作为新插入节点重新调整，如果当前树已经是整棵树，则因为根节点为红色，不符合红黑树定义，此时只需要将根节点颜色设置为黑色即可，即fixAfterInsertion()最后一句代码的作用。
2. P是A的左子树，U节点颜色为黑色，C是P的左子树，将P设置为黑色，A设置为红色，并对A做右旋操作。此时C的父节点已变为黑色，循环可以直接退出。
3. P是A的左子树，U节点颜色为黑色，C是P的右子树，此时只需要先对P左旋，然后设置C为黑色，A为红色，并对A右旋，此时P的父节点已变为黑色，循环可以直接退出。
如下图所示：

代码：

  while (x != null && x != root && x.parent.color == RED) {
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
                Entry y = rightOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == rightOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateLeft(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateRight(parentOf(parentOf(x)));
                }
            } else {
....
            }
        }

4. P是A的右子树，U节点颜色为红色，此时不管C是节点是P的左子树还是右子树，只需要将P和U设为黑色，A设为红色，则可保证当前局部树符合红黑树定义，把A作为新插入节点重新调整，如果当前树已经是整棵树，则因为根节点为红色，不符合红黑树定义，此时只需要将根节点颜色设置为黑色即可，即fixAfterInsertion()最后一句代码的作用。
5. P是A的右子树，U节点颜色为黑色，C是P的右子树，将P设置为黑色，A设置为红色，并对A做左旋操作。此时C的父节点以变为黑色，循环可以直接退出。
6. P是A的右子树，U节点颜色为黑色，C是P的左子树，此时只需要先对P左旋，然后设置C为黑色，A为红色，并对A右旋，此时P的父节点已为黑色，循环可以直接退出。
如下图所示：

代码：

  while (x != null && x != root && x.parent.color == RED) {
            if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
....
            } else {
                Entry y = leftOf(parentOf(parentOf(x)));
                if (colorOf(y) == RED) {
                    setColor(parentOf(x), BLACK);
                    setColor(y, BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    x = parentOf(parentOf(x));
                } else {
                    if (x == leftOf(parentOf(x))) {
                        x = parentOf(x);
                        rotateRight(x);
                    }
                    setColor(parentOf(x), BLACK);
                    setColor(parentOf(parentOf(x)), RED);
                    rotateLeft(parentOf(parentOf(x)));
                }
            }
        }

TreeMap中红黑树节点删除
红黑树的删除类似二叉查找树删除逻辑类似，在对同时有左子树和右子树存在时，TreeMap选择先将要删除的节点替换成其直接后继节点，然后删除其直接后继节点（其直接后继节点不可能同时存在左子节点和右子字节点）。对红黑树，由于红色节点不影响路径计算（性质6），因而对红色节点可以直接删除。然而在删除黑色节点时，如果删除的节点不是树的唯一节点，那么在某些路径上的黑色节点数会发生改变，破坏性质6；如果被删除的唯一子节点为红色，而父节点也为红色，那么性质5被破坏，因为存在红色节点的子节点为红色；如果删除的是根节点，而它的唯一子节点是红色，则性质3被破坏。因而需要做一些调整。

  private void deleteEntry(Entry p) {
        modCount++;
        size--;

        // If strictly internal, copy successor's element to p and then make p
        // point to successor.
        if (p.left != null && p.right != null) {
            Entry s = successor(p);
            p.key = s.key;
            p.value = s.value;
            p = s;
        } // p has 2 children

        // Start fixup at replacement node, if it exists.
        Entry replacement = (p.left != null ? p.left : p.right);

        if (replacement != null) {
            // Link replacement to parent
            replacement.parent = p.parent;
            if (p.parent == null)
                root = replacement;
            else if (p == p.parent.left)
                p.parent.left  = replacement;
            else
                p.parent.right = replacement;

            // Null out links so they are OK to use by fixAfterDeletion.
            p.left = p.right = p.parent = null;

            // Fix replacement
            if (p.color == BLACK)
                fixAfterDeletion(replacement);
        } else if (p.parent == null) { // return if we are the only node.
            root = null;
        } else { //  No children. Use self as phantom replacement and unlink.
            if (p.color == BLACK)
                fixAfterDeletion(p);

            if (p.parent != null) {
                if (p == p.parent.left)
                    p.parent.left = null;
                else if (p == p.parent.right)
                    p.parent.right = null;
                p.parent = null;
            }
        }
    }

TreeMap中红黑树删除黑色节点后调整
调整的逻辑分以下步骤来考虑（假设新替换的节点为C，即代码中的x参数，C的父节点为P，C是P的左子节点，C的兄弟节点为S，S的左子树为SL，S的右子树为SR）：
1. 如果C为红色，直接将C标记为黑色即可，因为删除的黑节点数被该节点补上，该树已经恢复成一颗红黑树。
2. 如果C为黑色，且C为根节点，直接返回。
3. 如果C为黑色，且S为红色，那么节点P、SL、SR都为黑色，此时设置P为红色，S为黑色，对P左旋，并重新计算S，即S变为SL，即把问题转换为兄弟节点为黑色的情况。图片来自http://blog.csdn.net/v_JULY_v/article/details/6105630，自己画太麻烦了，虽然图片的命名规则和我的不一样，凑合的看把，囧。

4. 如果C为黑色，S为黑色，且SL、SR都为黑色，将S设置为红色，P赋值给C，重新计算。

5. 如果C为黑色，S为黑色，且SL为红色，SR为黑色，那么设置SL为黑色，S为红色，对S右旋，重新设置S为SL。

6. 如果C为黑色，S为黑色，且SR为红色，SL为任一颜色，则把S节点的颜色设置为P节点的颜色，设置P节点的颜色为黑色，SR节点的颜色为黑色，对P节点右旋，算法结束。

当C为P的右子节点时，其逻辑和以上对称，不再赘述。

  private void fixAfterDeletion(Entry x) {
        while (x != root && colorOf(x) == BLACK) {
            if (x == leftOf(parentOf(x))) {
                Entry sib = rightOf(parentOf(x));

                if (colorOf(sib) == RED) {
                    setColor(sib, BLACK);
                    setColor(parentOf(x), RED);
                    rotateLeft(parentOf(x));
                    sib = rightOf(parentOf(x));
                }

                if (colorOf(leftOf(sib))  == BLACK &&
                    colorOf(rightOf(sib)) == BLACK) {
                    setColor(sib, RED);
                    x = parentOf(x);
                } else {
                    if (colorOf(rightOf(sib)) == BLACK) {
                        setColor(leftOf(sib), BLACK);
                        setColor(sib, RED);
                        rotateRight(sib);
                        sib = rightOf(parentOf(x));
                    }
                    setColor(sib, colorOf(parentOf(x)));
                    setColor(parentOf(x), BLACK);
                    setColor(rightOf(sib), BLACK);
                    rotateLeft(parentOf(x));
                    x = root;
                }
            } else { // symmetric
                Entry sib = leftOf(parentOf(x));

                if (colorOf(sib) == RED) {
                    setColor(sib, BLACK);
                    setColor(parentOf(x), RED);
                    rotateRight(parentOf(x));
                    sib = leftOf(parentOf(x));
                }

                if (colorOf(rightOf(sib)) == BLACK &&
                    colorOf(leftOf(sib)) == BLACK) {
                    setColor(sib, RED);
                    x = parentOf(x);
                } else {
                    if (colorOf(leftOf(sib)) == BLACK) {
                        setColor(rightOf(sib), BLACK);
                        setColor(sib, RED);
                        rotateLeft(sib);
                        sib = leftOf(parentOf(x));
                    }
                    setColor(sib, colorOf(parentOf(x)));
                    setColor(parentOf(x), BLACK);
                    setColor(leftOf(sib), BLACK);
                    rotateRight(parentOf(x));
                    x = root;
                }
            }
        }

        setColor(x, BLACK);
    }

TreeMap中红黑树节点查找
红黑树的节点查找同二叉查找树逻辑，不再赘述。这里有一点不太明白：getEntryUsingComparator()方法注释中说它从getEntry()方法提取出来是为了性能上的考虑，这是为什么？

  /**
     * Version of getEntry using comparator. Split off from getEntry
     * for performance. (This is not worth doing for most methods,
     * that are less dependent on comparator performance, but is
     * worthwhile here.)
     */
    final Entry getEntryUsingComparator(Object key)

TreeMap中其他方法
TreeMap中其他方法实现比较直观，只要理解了红黑树，基本上很容易理解，不再赘述。

参考链接：

http://blog.csdn.net/v_JULY_v/article/details/6105630

http://blog.csdn.net/zhaojinjia/article/details/8120403

http://blog.csdn.net/eric491179912/article/details/6179908

http://dongxicheng.org/structure/red-black-tree/

DLevin 2013-10-26 18:41 发表评论

Java Core系列之ConcurrentHashMap实现(JDK 1.7)

DLevin — Fri, 18 Oct 2013 14:24:00 GMT

摘要: ConcurrentHashMap类似Hashtable，是HashMap更高效的线程安全版本的实现。不同于Hashtable简单的将所有方法标记为synchronized，它将内部数组分成多个Segment，每个Segment类似一个Hashtable，从而减少锁的粒度，并且它内部有一些比较tricky实现，让get操作很多时候甚至不需要锁（本文代码基于JDK 1.7，它在JDK 1.6的基础上... 阅读全文

DLevin 2013-10-18 22:24 发表评论

Java Core系列之HashMap实现

DLevin — Tue, 15 Oct 2013 15:40:00 GMT

最近在看Guava中的Cache的源码，它的实现基于ConcurrentHashMap，前段时间组里招人，据说很多看起来很牛掰的简历，一个HashMap就能刷掉很多，所以顺便把HashMap和ConcurrentHashMap的源码复习一遍。先从HashMap开始（另：Hashtable是HashMap的线程安全版本，它的实现和HashMap实现基本一致，除了它不能包含null值的key和value，并且它在计算hash值和数组索引值的方式要稍微简单一些。对于线程安全的实现，Hashtable简单的将所有操作都标记成synchronized，即对当前实例的锁，这样容易引起一些性能问题，所以目前一般使用性能更好的ConcurrentHashMap）。

Map是对键值对存储的抽象，因而其最主要的方法有：
1. 添加新的键值对(key,value)；
2. 通过键(key)查找关联的值(value)；
3. 通过键(key)移除关联的值(value)；
4. 判断键(key)或值(value)的存在性。
其他的方法有：判断键值对的空属性以及目前的键值对数，获取所有键、所有值或者所有键值对的集合，批量添加，清除所有键值对等。在Map中，一个键值对用Entry接口来表示。因而在Java中，对Map接口的定义如下：

public interface Map {
    boolean isEmpty();
    boolean containsKey(Object key);
    boolean containsValue(Object value);
    V get(Object key);
    V put(K key, V value);
    V remove(Object key);
    void putAll(Mapextends K, ? extends V> m);
    void clear();
    Set keySet();
    Collection values();
    Set> entrySet();

    interface Entry {
        K getKey();
        V getValue();
        V setValue(V value);
        boolean equals(Object o);
        int hashCode();
    }

    boolean equals(Object o);
    int hashCode();
}

HashMap是哈希表对Map非线程安全版本的实现，它允许key为null，也允许value为null。所谓哈希表就是通过一个哈希函数计算出一个key的哈希值，然后使用该哈希值定位对应的value所在的位置；如果出现哈希值冲突（多个key产生相同的哈希值），则采用一定的冲突处理方法定位到正真value位置，然后返回查找到的value值。一般哈希表内部使用一个数组实现，使用哈希函数计算出key对应数组中的位置，然后使用处理冲突法找到真正的value，并返回。因而实现哈希表最主要的问题在于选择哈希函数和冲突处理方法，好的哈希函数能使数据分布更加零散，从而减少冲突的可能性，而好的冲突处理方法能使冲突处理更快，尽量让数据分布更加零散，从而不会影响将来的冲突处理方法。

在严蔚敏、吴伟明版本的《数据结构（C语言版）》中提供的哈希函数有：1. 直接定址法（线性函数法）；2. 数字分析法；3. 平方取中法；4. 折叠法；5. 除留余数法；6. 随机数法。在JDK的HashMap中采用了移位异或法后除留余数（和2的n次方'&'操作）。HashMap内部的数据结构是一个Entry的数组，在使用key查找value时，先使用key实例计算hash值，然后对计算出的hash值做各种移位和异或操作，然后取其数组的最大索引值的余数（'&'操作，一般其容量值都是2的倍数，因而可以认为是除留余数）。在JDK 1.7中对String类型采用了内部hash算法（当数组容量超过一定的阀值，使用“jdk.map.althashing.threshold”设置该阀值，默认为Integer.MAX_VALUE，即关闭该功能），并且使用了一个hashSeed作为初始值，不了解这些算法的具体缘由，就这样浅尝辄止了。

  final int hash(Object k) {
        int h = 0;
        if (useAltHashing) {
            if (k instanceof String) {
                return sun.misc.Hashing.stringHash32((String) k);
            }
            h = hashSeed;
        }
        h ^= k.hashCode();
        h ^= (h >>> 20) ^ (h >>> 12);
        return h ^ (h >>> 7) ^ (h >>> 4);
    }

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

同样在上述的数据结构书中关于冲突处理提供了几个方法：1. 开放定址法；2. 再哈希法；3.链地址法；4. 建立一个公共溢出区法。在JDK的HashMap中采用了链地址法，即每个数组bucket中存放的是一个Entry链，每次新添加一个键值对，就是向链头添加一个Entry实例，新添加的Entry的下一个元素是原有的链头（如果该数组bucket不存在Entry链，则原有链头值为null，不影响逻辑）。每个Entry包含key、value、hash值和指向下一个Entry的next指针。

  static class Entry implements Map.Entry {
        final K key;
        V value;
        Entry next;
        int hash;
    }

添加
从以上描述中，我们可以知道添加新的键值对可以分成两部分：
1. 使用key计算出内部数组的索引值（index）。
2. 如果该索引的数组bucket中已经存在Entry链，并且该链中已经存在新添加的key的值，则将原有的值设置成新添加的值，并返回旧值。
3. 否则，创建新的Entry实例，将该实例插入到原有链的头部。
4. 在新添加Entry实例时，如果当前size超过阀值（capacity * loadFactor），数组容量将会自动扩大两倍，在数组扩容时，所有原存在的Entry会重新计算索引值，并且Entry链的顺序也会发生颠倒（如果还在同一个链中的话）；而该新添加的Entry的索引值也会重新计算。
5. 对key为null时，默认数组的索引值为0，其他逻辑不变。

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

插入原理图：

查找
查找和添加类似，首先根据key计算出数组的索引值（如果key为null，则索引值为0），然后顺序查找该索引值对应的Entry链，如果在Entry链中找到相等的key，则表示找到相应的Entry记录，否则，表示没找到，返回null。对get()操作返回Entry中的Value值，对于containsKey()操作，则判断是否存在记录，两个方法都调用getEntry()方法：

  final Entry getEntry(Object key) {
        int hash = (key == null) ? 0 : hash(key);
        for (Entry e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
  if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
  return e;
}
        return null;
    }

而对于value查找（如containsValue()操作）则需要整个表遍历（数组遍历和数组中的Entry链遍历），因而这种查找的效率比较低，代码实现也比较简单。

移除
移除操作（remove()）也是先通过key值计算数组中的索引号（当key为null时索引号为0），从而找到Entry链，查找Entry链中的Entry，并将该Entry删除。

遍历
HashMap中实现了一个HashIterator，它首先遍历数组，查找到一个非null的Entry实例，记录该Entry所在数组索引，然后在下一个next()操作中，继续查找下一个非null的Entry，并将之前查找到的非null Entry返回。为实现遍历时不能修改HashMap的内容（可以更新已存在的记录的值，但是不可以添加、删除原有记录），HashMap记录一个modCount字段，在每次添加或删除操作起效时，将modCount自增，而在创建HashIterator时记录当前的modCount值（expectedModCount），如果在遍历过程中（next()、remove()）操作时，HashMap中的modCount和已存储的expectedModCount不一样，表示HashMap已经被修改，抛出ConcurrentModificationException。即所谓的fail fast原则。
在HashMap中返回的key、value、Entry集合都是基于该Iterator实现，实现比较简单，不细讲。

注：clear()操作引起的内存问题-由于clear()操作只是将数组中的所有项置为null，数组本身大小并不改变，因而当某个HashMap已存储过较大的数据时，调用clear()有些时候不是一个好的做法。

最后吐槽一下，即使JDK内部的HashMap也有很多的代码重复。。。。。

DLevin 2013-10-15 23:40 发表评论

SAX解析XML文件

DLevin — Sun, 18 Nov 2012 12:10:00 GMT

摘要: 就目前来说，有三种方式可以解析XML文件：DOM、SAX、StAX。DOM将整个XML文件加载到内存中，并构建出节点树；应用程序可以通过遍历节点树的方式来解析XML文件中的各个节点、属性等信息；这种方式便于对XML节点的添加修改等，而且解析也很方便，然后它比较耗费内存，解析速度也不快。SAX则是基于事件的解析，解析器在一次读取XML文件中根据读取的数据产生相应的事件，由应用程序实现相应的事件处理逻... 阅读全文

DLevin 2012-11-18 20:10 发表评论

【转】关于AccessController.doPrivileged

DLevin — Thu, 01 Nov 2012 17:04:00 GMT

转自：http://hi.baidu.com/qmiao128/item/eedc21dfa60d2051d63aae2b
最近在看一些框架代码，偶尔都会遇到AccessController.doPrivileged()方法的使用，虽然之前在《深入解析Java虚拟机》这本书上看到过对这个方法的解释，但是貌似当时没有真正理解，虽然到现在对这个方法的概念还比较模糊，感觉这边文章介绍的挺清晰的，因而转载过来。

AccessController.doPrivileged是一个在AccessController类中的静态方法，允许在一个类实例中的代码通知这个AccessController：它的代码主体是享受"privileged(特权的)"，它单独负责对它的可得的资源的访问请求，而不管这个请求是由什么代码所引发的。

这就是说，一个调用者在调用doPrivileged方法时，可被标识为 "特权"。在做访问控制决策时，如果checkPermission方法遇到一个通过doPrivileged调用而被表示为 "特权"的调用者，并且没有上下文自变量，checkPermission方法则将终止检查。如果那个调用者的域具有特定的许可，则不做进一步检查，checkPermission安静地返回，表示那个访问请求是被允许的；如果那个域没有特定的许可，则象通常一样，一个异常被抛出。

一、"特权"特性的正常使用如下所示：

1、如果你不需要从"特权"块内返回一个值，按下列代码去做：

somemethod() {

      ...normal code here...

      AccessController.doPrivileged(new PrivilegedAction() {
             public Object run() {
                   // privileged code goes here, for example:
                    System.loadLibrary("awt");
                    returnnull; // nothing to return
            }
      });

      ...normal code here...

}

PrivilegedAction是一个接口，它带有一个被称为run的方法，这个方法返回一个Object。上述例子显示了一个用来实现那个接口的匿名内类的创建，并提供了一个run方法的具体实现。

当做一个doPrivileged调用时，一个PrivilegedAction实现的实例被传递给它。doPrivileged方法在使特权生效后，从PrivilegedAction实现中调用run方法，并返回run方法的返回值以作为doPrivileged的返回值，这一点在本例中被忽略。

2、如果你需要返回一个值，你可按如下方法去做：

somemethod() {

        ...normal code here...

        String user = (String) AccessController.doPrivileged(new PrivilegedAction() {
                  public Object run() {
                         return System.getProperty("user.name");
                 }
        });

        ...normal code here...

}

3、如果用你的run方法执行的动作可能扔出一个"检查"的异常（包括在一个方法的throws子句列表中），则你需要使用PrivilegedExceptionAction接口，而不是使用PrivilegedAction接口：

somemethod() throws FileNotFoundException {

        ...normal code here...

        try {
               FileInputStream fis = (FileInputStream)
               AccessController.doPrivileged(new PrivilegedExceptionAction() {
                     public Object run() throws FileNotFoundException {
                            returnnew FileInputStream("someFile");
                     }
               });
        } catch (PrivilegedActionException e) {
                  // e.getException() should be an instance of
                 // FileNotFoundException,
                 // as only "checked" exceptions will be "wrapped" in a
                 // PrivilegedActionException.
                throw (FileNotFoundException) e.getException();
        }

       ...normal code here...

}

有关被授予特权的一些重要事项：
首先，这个概念仅存在于一个单独线程内。一旦特权代码完成了任务，特权将被保证清除或作废。

第二，在这个例子中，在run方法中的代码体被授予了特权。然而，如果它调用无特权的不可信代码，则那个代码将不会获得任何特权；只有在特权代码具有许可并且在直到checkPermission调用的调用链中的所有随后的调用者也具有许可时, 一个许可才能被准予。

二、使用事例：

final String name = MyClass.class.getName();
String className = AccessController.doPrivileged(new PrivilegedAction() {
                public String run() {
                    return System.getProperty(name);
                 }
});关于AccessController.doPrivileged- -

来自不同的位置的代码可以由一个CodeSource对象描述其位置和签名证书。根据代码的CodeSource的不同，代码拥有不同的权限。例如所有Java SDK自带的代码都具有所有的权限，而Applet中的代码则具有非常受限的权限，用户编写的代码可以自己定制权限（通过SecurityManager）。
当执行一段代码时，这段代码的StackTrace包含了从Main开始所有正在被调用而且没有结束的方法。在这个调用过程中，很有可能出现跨多个不同的CodeSource的调用序列。由于CodeSource不同，这些代码通常拥有不同的权限集。只有所有途经的CodeSource都具有对应的权限集合时，当前正在运行的代码才能存取某个Resource。
而doPrivileged方法是对这个规则的一种补充。他类似于Unix中的setuid程序。Unix中的login程序必须访问password文件从而获得用户授权信息，但是用户不能随意的访问password文件。因此，login程序具有setuid位，它不管被哪个用户所调用，都具有root的权限。
调用doPrivileged的方法不管其StackTrace中其他方法的权限，而仅仅根据当前方法的权限来判断用户是否能访问某个resource。也即可以规定用户只能用某种预定的方式来访问其本来不能访问的resource。
使用doPrivileged方法和使用setuid位都有需要注意的地方，例如仅执行必要的操作。否则，可能带来安全上的问题。

DLevin 2012-11-02 01:04 发表评论

Spring中集合定义

DLevin — Tue, 14 Feb 2012 10:16:00 GMT

习惯了把集合定义在一个类的字段中，今天遇到想重用集合的定义，竟然不知道单独的集合Bean应该怎么定义了，记之，以备后用。

对Map来说，有一种比较搓的方法，就是直接用Map的构造函数：

1<bean id="SymbolMap" class="java.util.HashMap">
2    <constructor-arg>
3       <map>
4         <entry>
5            <key><value>[CDATA[us;djia]]>value>key>
6            <value>[CDATA[us&dji]]>value>
7         entry>
8       map>
9    constructor-arg>
10bean>
11

另一种稍微简单的方法：

1<bean id="emails" class="org.springframework.beans.factory.config.MapFactoryBean">
2  <property name="sourceMap">
3      <map>
4        <entry key="pechorin" value="pechorin@hero.org"/>
5        <entry key="raskolnikov" value="raskolnikov@slums.org"/>
6        <entry key="stavrogin" value="stavrogin@gov.org"/>
7        <entry key="porfiry" value="porfiry@gov.org"/>
8      map>
9  property>
10bean>
11

对这种方法，Sping还提供了ListFactoryBean, SetFactoryBean等类，这貌似是Spring的一个可扩展框架，可以待以后进一步研究这个框架的实现方式。
最简单的一种方式就是直接用spring中提供的util包：

1<util:map id="emails">
2    <entry key="pechorin" value="pechorin@hero.org"/>
3    <entry key="raskolnikov" value="raskolnikov@slums.org"/>
4    <entry key="stavrogin" value="stavrogin@gov.org"/>
5    <entry key="porfiry" value="porfiry@gov.org"/>
6util:map>
7

使用改方法时，xml文件头需要使用：

1    xmlns:util="http://www.springframework.org/schema/util"
2    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
3                        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-2.5.xsd">

引用：
http://macrochen.iteye.com/blog/392616
http://springindepth.com/book/in-depth-ioc-collections.html

DLevin 2012-02-14 18:16 发表评论

[多问几个为什么]为什么匿名内部类中引用的局部变量和参数需要final而成员字段不用？

DLevin — Tue, 22 Nov 2011 17:49:00 GMT

摘要: 昨天有一个比较爱思考的同事和我提起一个问题：为什么匿名内部类使用的局部变量和参数需要final修饰，而外部类的成员变量则不用？对这个问题我一直作为默认的语法了，木有仔细想过为什么（在分析完后有点印象在哪本书上看到过，但是就是没有找到，难道是我的幻觉？呵呵）。虽然没有想过，但是还是借着之前研究过字节码的基础上，分析了一些，感觉上是找到了一些答案，分享一下；也希望有大牛给指出一些不足的地方。假如我们有... 阅读全文

DLevin 2011-11-23 01:49 发表评论

历程杂技

DLevin — Wed, 07 Sep 2011 17:15:00 GMT

为什么会抛出IllegalMonitorStateException？

在使用java线程的时候，我们有时候要调用wait，notifyAll，notify来等待或者唤醒线程，如果这几个方法没有包含在synchronized块中，将抛出IllegalMonitorStateException异常，并且当前线程被中断，为什么？

为什么？因为wait，notifyAll，notify被调用的时候，都要使用到对象的监视器（锁），但是，如果这些方法不被包含在synchronized块中，那么当前线程就获取不到对象的锁，那么当我们wait的时候，wait根本不知道该释放哪个锁，所以就会抛出不合法的锁异常。

为什么？sleep不需要被包含在synchronized块中呢？因为sleep不要释放锁，所以也就不抛出异常。

"Could not resolve placeholder"解决方案

　　除去properites文件路径错误、拼写错误外，出现"Could not resolve placeholder"很有可能是使用了多个PropertyPlaceholderConfigurer或者多个的原因。
在Spring 3.0中，可以写：

<context:property-placeholder location="xxx.properties" ignore-unresolvable="true" />

在Spring 2.5中，没有ignore-unresolvable属性，此时可以改用PropertyPlaceholderConfigurer。其实ignore-unresolvable="true" />与下面的配置是等价的

"随便" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
"location" value="xxx.properties" />
"ignoreUnresolvablePlaceholders" value="true" />

用Spring JMS，在主线程退出后，进程没有退出情况：
今天写了一个关于Spring JMS的小程序，发现主线程退出后，但相应的Server进程却没有退出。用jconsole查看内部线程情况，发现还有好多线程并没有结束。如图：
在网上没有找到相关的资料，无意中看到貌似可以通过ClassPathXmlApplicationContext中的close()方法解决这个问题。对Spring和JMS其实都不算很了解，不知道这个方法是不是合适或者还有更好的方法，先记下，等以后有时间再好好研究研究。

Spring获取插入数据库时自增字段的值：
代码如下：

public int insertSubscriberRecord(int websiteId,
                                  String firstName,
                                  String lastName,
                                  String password,
                                  String email)
{
  Subscriber subscriber = new Subscriber(websiteId, firstName, lastName, password, email);
  String insertFileString = "INSERT INTO subscribers "
    + "(website_id, first_name, last_name, password, email_address) VALUES "
    + "(:websiteId, :firstName, :lastName, :password, :emailAddress) ";
  // see http://static.springframework.org/spring/docs/2.5.x/reference/jdbc.html
  SqlParameterSource fileParameters = new BeanPropertySqlParameterSource(subscriber);
  KeyHolder keyHolder = new GeneratedKeyHolder();
  getNamedParameterJdbcTemplate().update(insertFileString, fileParameters, keyHolder);
  return keyHolder.getKey().intValue();
}

参考：http://www.devdaily.com/blog/post/jdbc/spring-jdbc-insert-auto-generated-key

Print the Stack Trace of the Exception to a String

1import java.io.PrintWriter;
2import java.io.StringWriter;
3    public static String getStackTrace(Throwable t)
4    {
5        StringWriter sw = new StringWriter();
6        PrintWriter pw = new PrintWriter(sw, true);
7        t.printStackTrace(pw);
8        pw.flush();
9        sw.flush();
10        return sw.toString();
11    }
12

最近在网上看到一个面试题：

1 Integer a = null;
2 Integer b = a;
3 int c = b;
What will happen？答案当然是NullPointerException。但是为什么？查看以下代码：

0 aconst_null

1 astore_1 [a]

2 aload_1 [a]

3 astore_2 [b]

4 aload_2 [b]

5 invokevirtual java.lang.Integer.intValue() : int [16]

8 istore_3 [c]
从字节码中我们可以看出，其实对于装箱和拆箱操作，都是编译器在其中做了支持，将int类型转换成Integer类型（调用Integer.valueOf()方法），或将Integer类型转换成int类型（调用Integer.intValue()方法）。

类在什么时候加载为题

1 class Singleton {
2     private static final Singleton instance = new Singleton();
3
4     private Singleton() {
5         System.out.println("Singleton()");
6     }
7
8     public static Singleton getInstance() {
9         return instance;
10     }
11 }
然后当我们有以下一句话：

Singleton singleton = null;
or

Singleton singleton;
此时类会加载吗？直观点，打印"Singleton()"这句话会被执行吗？答案是不会被执行，对第二句话还是好理解的，因为singleton实例根本没有被用到，若要用，首先要初始化所以编译器会最后忽略这句话，所以singleton变量不会出现在字节吗中。对第一句，singleton实例会出现在字节码中，并且会赋null的值，但是此时Singleton类还是没有被加载，那么此时singleton这个实例是什么类型呢？这点我有点想不通。或者Java的引用在内存中根本是没有类型的，保证类型安全是在编译器端做的，所以在给singleton实例赋null值得时候，只是表明singleton是一个指向null的引用而已，它并没有指向Singleton实例，所以此时Singleton类不需要加载，只有到真正使用到Singleton类的时候才会去加载Singleton类，并实例化instance成员。
这样就引出另一个问题：
有人说把初始化放在getInstance()方法中，会使instance在用到时才被加载，而不是刚开始程序初始化时就被加载，在C++中，这个确实是这样的，但是在Java中有必要这么做吗？从上述的分析中，我们可以看到，其实Java中根本没有必要，只要像上面一样写就可以了。

DLevin 2011-09-08 01:15 发表评论

Java中的装箱与拆箱

DLevin — Wed, 20 Jul 2011 15:09:00 GMT

在J2SE5.0后推出了自动装箱和拆箱的功能，以提高我们的开发效率，然而自动装箱和拆箱实际上是通过编译器来支持的（并非语言本身，或者说虚拟机），因而这种支持也隐藏了部分内部实质，再加上某些类的优化（比如Integer里面的缓存等，参看关于缓存节），就更加容易在特定的环境下产生问题，并且如果不知道原来还无法调试。以下先是简单的介绍了编译器对装箱和拆箱的实现，并根据实现简单介绍一下可能会遇到的几个问题。

装箱和拆箱实现

以下装箱和拆箱代码：

   Object value = 10;
       int intValue = (Integer)value;
       Integer newIntValue = new Integer(10);

编译成字节码如下：

0 bipush 10

2 invokestatic java.lang.Integer.valueOf(int) : java.lang.Integer [20]

5 astore_1 [value]

6 aload_1 [value]

7 checkcast java.lang.Integer [21]

10 invokevirtual java.lang.Integer.intValue() : int [26]

13 istore_2 [intValue]

14 new java.lang.Integer [21]

17 dup

18 bipush 10

20 invokespecial java.lang.Integer(int) [30]

23 astore_3 [newIntValue]

从以上字节码可以看到10首先调用valueOf方法转换为Integer实例，再赋值该value，而value强制转换成Integer类后，会调用intValue方法，后赋值给intValue。这就是用编译器来实现装箱和拆箱。

奇怪的NullPointerException

查看以下代码：

Integer value = null;
int intValue = value;

可以编译通过，但是运行的时候却会发生NullPointerException。这是由什么引起的呢？依然看一下字节码就可以了：

0 aconst_null

1 astore_1 [value]

2 aload_1 [value]

3 invokevirtual java.lang.Integer.intValue() : int [20]

6 istore_2 [intValue]

从字节码中可以看到，从value赋值该intValue事实上是直接在value实例上调用intValue函数。

对当前代码，我们可以一眼就看出当前value是null的问题，但是如果这个null是在很远以外的地方赋值的呢？或者是间接赋值呢？这个时候遇到这种问题就会比较诡异了。

相等与不相等问题

查看一下代码：

   Integer value1 = 100;
       Integer value2 = 100;
       System.out.println("value1 == value2 is " + (value1 == value2));

       Integer value3 = 200;
       Integer value4 = 200;
       System.out.println("value3 == value4 is " + (value3 == value4));

这段代码会是什么结果？

value1 == value2 is true

value3 == value4 is false

两段代码就是值不一样，其他的都一样，竟然会有区别？这个奥妙就因为装箱过程中调用的是valueOf方法，而valueOf方法对值在-128到127之间的数值缓存了（参见关于缓存一节），因而value1和value2的引用是相同的，而value3和value4的引用是不一样的，而==比较的是引用，因而才会出现以上的结果。

这确的做法应该是：

   Integer value1 = 100;
       Integer value2 = 100;
       System.out.println("value1 == value2 is " + (value1.equals(value2)));

       Integer value3 = 200;
       Integer value4 = 200;

System.out.println("value3 == value4 is " + (value3.equals(value4)));

这样的结果就是预料的结果了：

value1 == value2 is true

value3 == value4 is true

所以我们要慎用“==”操作符。

String中的相等与不等

在String中也有类似的情况，查看一下代码：

   String str1 = "abc";
       String str2 = "abc";
       System.out.println("str1 == str2 is " + (str1 == str2));

       String str3 = new String("abc");
       String str4 = new String("abc");
       System.out.println("str3 == str4 is " + (str3 == str4));

执行结果：

str1 == str2 is true

str3 == str4 is false

这是因为str1和str2使用的是同一个字符串，即在字符常量中的字符串，而str3和str4在使用字符常量中的字符为参数又创建出了两个新的字符串对象，因而在引用比较情况下是不等的。我们可以从字节码中得到这些信息（删除打印的代码）：

0 ldc [20]

2 astore_1 [str1]

3 ldc [20]

5 astore_2 [str2]

6 new java.lang.String [22]

9 dup

10 ldc [20]

12 invokespecial java.lang.String(java.lang.String) [24]

15 astore_3 [str3]

16 new java.lang.String [22]

19 dup

20 ldc [20]

22 invokespecial java.lang.String(java.lang.String) [24]

25 astore 4 [str4]

正确的做法还是调用equals方法，而不是使用“==”操作符。

关于缓存

据目前信息，有缓存的类有：Byte、Short、Integer、Long以及Boolean类。而这种缓存也只是在调用valueOf（静态）方法的时候才会存在（装箱正是调用了valueOf方法）。对整型，缓存的值都是-128到127（包括-128和127）之间，其他值都不缓存，而对Boolean类型只有true和false值。代码如下：

public final class Integer extends Number {
    public static Integer valueOf(int i) {
        if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.cache[i + 128];
        else
        return new Integer(i);
}
public final class Boolean {
    public static Boolean valueOf(boolean b) {
        return (b ? TRUE : FALSE);
    }

2011-01-05

DLevin 2011-07-20 23:09 发表评论

Tomcat中Jsp使用没有命名空间类的问题

DLevin — Wed, 20 Jul 2011 15:08:00 GMT

问题重现：

今天一刚开始学Java的同学在接触Jsp的时候遇到了一个比较诡异的问题，他在JSP中始终无法使用自己写的类。简单的演示问题代码：

//没有定义包名

public class MyDefaultClass {

}

//index.jsp文件

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"

pageEncoding="ISO-8859-1"%>

DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

<title>Insert title heretitle>

head>

<body>

MyDefaultClass cls = new MyDefaultClass();

Load successful

body>

html>

出现的错误提示：

type Exception report

message

description The server encountered an internal error () that prevented it from fulfilling this request.

exception

org.apache.jasper.JasperException: Unable to compile class for JSP:

An error occurred at line: 12 in the jsp file: /index.jsp

MyDefaultClass cannot be resolved to a type

10:

11: <%

12: MyDefaultClass cls = new MyDefaultClass();

13: %>

14:

15: Load successful

An error occurred at line: 12 in the jsp file: /index.jsp

MyDefaultClass cannot be resolved to a type

10:

11: <%

12: MyDefaultClass cls = new MyDefaultClass();

13: %>

14:

15: Load successful

Stacktrace:

org.apache.jasper.compiler.DefaultErrorHandler.javacError(DefaultErrorHandler.java:92)

org.apache.jasper.compiler.ErrorDispatcher.javacError(ErrorDispatcher.java:330)

org.apache.jasper.compiler.JDTCompiler.generateClass(JDTCompiler.java:439)

org.apache.jasper.compiler.Compiler.compile(Compiler.java:349)

org.apache.jasper.compiler.Compiler.compile(Compiler.java:327)

org.apache.jasper.compiler.Compiler.compile(Compiler.java:314)

org.apache.jasper.JspCompilationContext.compile(JspCompilationContext.java:592)

org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:317)

org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:313)

org.apache.jasper.servlet.JspServlet.service(JspServlet.java:260)

javax.servlet.http.HttpServlet.service(HttpServlet.java:717)

解决方案：

为什么要特别提示他是刚开始接触Java呢？因为我是想强调一下他没有定义包名的习惯，所以才会出现这个问题，而在Java中不定义包名是一个非常不好的编程习惯。这个问题本身是可以通过定义自己的包名，然后在JSP文件中导入自己的包解决。

问题原因：

由于JSP文件在请求时动态的生成Servlet类，然后动态的编译新生成的Servlet类，并加载新编译出的Servlet的class文件，运行相应的service方法，返回结果给客户端。根据栈信息可以知道问题出在了动态编译Servlet类的时候，而且是说MyDefaultClass无法被解析。

所以我猜测，可能是Tomcat在解析JSP文件的时候，没有发现有用户导入的类型（没有使用命名空间，因而无法导入包，也不需要加包名的前缀，导致Tomcat在解析JSP文件的时候无法自动感知到当前是引用了用户自定义的类的；也导致在编译的时候却能通过），所以在动态编译的时候没有设置ClassPath的值，然后导致了这个问题。然而对于这个“Bug”，Tomcat本身应该不会想不到，何况从逻辑上，默认的把/classes和/lib的目录加入到ClassPath中去编译动态生成的Servlet类也是合理的，那么Tomcat为什么要这样做呢？我的猜测可能会有两点吧：1. Tomcat也认为不定义包名是非常不好的习惯，因而故意留下这个缺陷，以惊醒编程人员。2. 也有可能是出于性能的考虑，如果不加ClassPath应该是可以提升编译动态生成的Servlet类的速度的，因而只要不需要ClassPath的情况下，默认就不加。

2010-09-22

DLevin 2011-07-20 23:08 发表评论

Eclipse中异常断点问题

DLevin — Wed, 20 Jul 2011 15:07:00 GMT

之前在.NET平台下，VS提供的异常断点的工具给我在工作中帮了不好忙，特别是在出问题调试时，给我节省了不少时间。最近开始用Eclipse学习Java，对异常断点的功能很是怀念，也没有在网上找到过相关资料说Eclipse也提供了类似的功能，很是郁闷。今天这个功能终于被我找到了。

在Eclipse中的“Run”中的“Add Java Exception Breakpoint…”项，选择要断住的抛出异常类型即可。

在这里选择的Exception类型可以在Breakpoint窗口中查看或取消：

2010-10-03

DLevin 2011-07-20 23:07 发表评论

Eclipse中ClassPath问题

DLevin — Wed, 20 Jul 2011 15:00:00 GMT

今天发现把jar文件或.class文件放在系统配置的CLASSPATH目录下，然而在eclipse的工程中却是无法加载的(通过ClassLoader去加载相应的类)。最后我发现eclipse应该是重新设置了CLASSPATH的值了，也正因为这样它才能运行其bin目录下的文件。如打开工程目录下的.classpath文件：

然而如果加入一下内容：

重启eclipse，就可以正确的加载CLASSPATH中的内容了。

2011-09-16

DLevin 2011-07-20 23:00 发表评论

通过final变量实现条件编译

DLevin — Tue, 19 Jul 2011 16:23:00 GMT

首先来比较两段代码所产生的中间代码：

public class AppConfig {

    public static final boolean debug = true;
}
public class DebugCode {
    public static void main(String[] args) {
       if(AppConfig.debug) {
           System.out.println("Some debug information");
       }
    }
}

DebugCode的中间代码（部分）：

public class org.levin.insidejvm.miscs.DebugCode {

public static void main(java.lang.String[] args);

0 getstatic java.lang.System.out : java.io.PrintStream [16]

3 ldc [22]

5 invokevirtual java.io.PrintStream.println(java.lang.String) : void [24]

8 return

}

public class AppConfig {
    public static final boolean debug = false;
}
public class ReleaseCode {
    public static void main(String[] args) {
       if(AppConfig.debug) {
           System.out.println("Some debug information");
       }
    }
}

ReleaseCode中间代码（部分）：

public class org.levin.insidejvm.miscs.ReleaseCode {

public static void main(java.lang.String[] args);

0 return

}

在上面的代码中，很明显DebugCode和ReleaseCode中的代码是一样的，只是AppConfig.debug的值不一样而已，却产生了不同的中间代码，即编译器在AppConfig.debug为false的时候直接忽略了if中的语句。利用这个特性，我们就可以根据配置来实现条件编译，从而实现不同的条件产生不同的中间代码而不只是不同的运行结果。

然而在这里为什么会出现这样的行为呢？

这是因为编译器对final修饰的基本类型和String类型的变量，在编译时解析为一个本地拷贝，这样拷贝导致编译器在编译的时候明确的知道ReleaseCode的那一段if语句是不会被执行的，因而可以对其做优化。而这种替换的结果也使得用final修饰的int变量可以出现在switch-case语句中。

这种方式的缺陷

这种方式的缺陷在于要现实该机制的条件编译，在改变AppConfig.debug中的值时，需要同时对AppConfig类和ReleaseCode类进行编译（即不能只编译AppConfig类）。

参考：《深入Java虚拟机（第二版）》第八章
2010-09-22

DLevin 2011-07-20 00:23 发表评论

equals方法实现小记

DLevin — Wed, 29 Jun 2011 11:05:00 GMT

最近做项目，在一次写equals方法时突然悟出了一些心得，小记之，以备后用。在《Effective Java（第二版）》的Item7中提出我们要尽量避免重新equals方法，他同时也列举了几种我们不需要实现equals方法的情况：
1）类的每个实例从本质上来说是唯一的，如Thread类的实例。
2）我们并不会用到该类的equals方法，如Random类，虽然可以比较两个Random的实例，以判断两个实例是否可以产生相同的随机数，设计者认为这样的需求用到的场合很少，因而就没有重写equals方法。
3）父类已经实现了equals方法，并且父类实现方式和子类实现方式是一样的，如大部分的Set实现的equals方法使用AbstractSet类提供的equals方法，List实现则使用AbstractList，Map实现使用AbstractMap的。
4）一个private类或package-private类，我们自己可以确保我们不会使用到它们的equals方法。
同时书也提出一般只有值类型的类才需要实现equals方法，像Date、Integer、Order（作为bean来使用）等。
另外，我们在实现equals方法是也要遵循以下几个原则：
1）自反性（reflexive）：x.equals(x)＝＝true
2）对称性（symmetric）：x.equals(y)==y.equals(x)
3）传递性（transitive）：若x.equals(y)==true, y.equals(z)==true,则x.equals(z)==true。
4）一致性（consistent）：多次调用x.equals(y)的结果应该是一样的。
5）对任何非null实例x，x.equals(null)＝＝false。

根据这些特性，我们可以写出如下代码：

1 public class Customer implements Serializable {
2     private static final long serialVersionUID = 1L;
3
4     private String id;
5     private String name;
6     private String role;
7
8     @Override
9     public boolean equals(Object obj) {
10         if(obj == null) {
11             return false;
12         }
13
14         if(this == obj) {
15             return true;
16         }
17
18         if(!(obj instanceof Customer)) {
19             return false;
20         }
21
22         Customer other = (Customer)obj;
23         return (ObjectUtils.equals(id, other.id) &&
24                 ObjectUtils.equals(name, other.name) &&
25                 ObjectUtils.equals(role, other.role));
26     }
27
28     public String getId() {
29         return id;
30     }
31     public void setId(String id) {
32         this.id = id;
33     }
34     public String getName() {
35         return name;
36     }
37     public void setName(String name) {
38         this.name = name;
39     }
40     public String getRole() {
41         return role;
42     }
43     public void setRole(String role) {
44         this.role = role;
45     }
46 }

其中ObjectUtils类的代码如下：

1 public class ObjectUtils {
2
3     /**
4      * Compare whether the left and right is equals
5      * It has already considered the null case
6      *
7      * @param left
8      * @param right
9      * @return
10      */
11     public static boolean equals(Object left, Object right) {
12         if(left == null && right == null) {
13             return true;
14         }
15         if(left == null && right != null) {
16             return false;
17         }
18         return left.equals(right);
19     }
20 }

在《Effective Java》这本书中，貌似equals实现方法前面没有null、this的判断，因为instanceof可以解决null的问题，而super.equals()方法可以解决this问题，但是我还是喜欢把它们都分出来，这样写的更加明了一些。另外，事实上，这里的实现并没有遵循对称性的原则，因为如果A是B的子类，而这个equals方法在A类中，那么AInstance.equals(BInstance)==false，若B也实现了类似的equals方法，则BInstance.equals(AInstance)==true(当A没有新的比较字段时，或许这个时候A根本就不需要实现equals方法，如本文开头列出的第三条），这是因为AInstance instanceof BInstance ＝＝ true，反之则为false。不过由于这种情况并不常见，所以就不去care了。:)

事实上，这里我之所以要记录这些代码，主要是因为有ObjectUtils类的存在。记得以前在学C#的时候，它的Object类提供了一个静态的Equals方法，我一直对这个方法的存在感到很疑问，直到这次自己写这个equals方法才弄明白，因为虽然在equals方法实现中，最后还要判断类字段是否equals，然后这些字段都有可能是null的，如果没有提供这个静态的equals方法，我们就需要自己来判断每个字段是否为null，然后才可以调用它的equals方法，这样就比较麻烦了，而Object.Equals方法正是对这种行为的封装，我们只要使用一个方法就可以安全的实现类成员的equals。这也是我加ObjectUtils类的意义所在。希望以后能有机会向这个ObjectUtils类填充更多的实用方法。:)

PS:如一楼所说在commons中的EqualsBuilder已经实现了相同的功能，而且代码更加完善，有兴趣的可以看看那里的代码，我这里只是对这次新的的记录，代码只是对当前我考虑的场景中使用，并没有考虑其他方面。另外，在《Effective Java》中也是建议equals和hashCode两个方法应该是同时实现的，一楼也有说可以用HashCodeBuider来实现，这个大家也不妨可以去看看里面的源码，最近时间不多，以后回来再看。。。。。。

DLevin 2011-06-29 19:05 发表评论

Java中的Bridge方法

DLevin — Thu, 23 Jun 2011 15:54:00 GMT

今天在Java中字节码的格式的时候，发现method_info中的access_flags中竟然定了ACC_BRIDGE的值。网上搜了一下，大概理解它的意思了，先记之。

首先是在什么情况下会生成bridge方法（2）：

bridge method may be created by the compiler when extending a parameterized type whose methods have parameterized arguments.

这是在网上找到的有人贴出来的一段话，但是感觉这段话说的并不是很明白。首先bridge方式是由编译器产生的，因而在源代码中也没有bridge的关键字。然后只有在以具体类型继承自一个泛型类，同时被继承的泛型类包含了泛型方法。比如看以下的例子：

abstract class A<T> {
    public abstract T method1(T arg);
    public abstract T method2();
}

class B extends A<String> {
    public String method1(String arg) {
       return arg;
    }
    public String method2() {
       return "abc";
    }
}

class C<T> extends A<T> {
    public T method1(T arg) {
       return arg;
    }

    public T method2() {
       return null;
    }
}

他们生成的.class文件如下：

A.class

abstract class org.levin.insidejvm.miscs.bridgemethod.A {

public abstract java.lang.Object method1(java.lang.Object arg0);

public abstract java.lang.Object method2();

}

B.class

class org.levin.insidejvm.miscs.bridgemethod.B extends org.levin.insidejvm.miscs.bridgemethod.A {

public java.lang.String method1(java.lang.String arg);

0 aload_1 [arg]

1 areturn

public java.lang.String method2();

0 ldc [20]

2 areturn

public bridge synthetic java.lang.Object method2();

0 aload_0 [this]

1 invokevirtual org.levin.insidejvm.miscs.bridgemethod.B.method2() : java.lang.String [23]

4 areturn

public bridge synthetic java.lang.Object method1(java.lang.Object arg0);

0 aload_0 [this]

1 aload_1 [arg0]

2 checkcast java.lang.String [26]

5 invokevirtual org.levin.insidejvm.miscs.bridgemethod.B.method1(java.lang.String) : java.lang.String [28]

8 areturn

}

C.class

class org.levin.insidejvm.miscs.bridgemethod.C extends org.levin.insidejvm.miscs.bridgemethod.A {

public java.lang.Object method1(java.lang.Object arg);

0 aload_1 [arg]

1 areturn

public java.lang.Object method2();

0 aconst_null

1 areturn

}

可以看到B中生成了两个bridge方法，而C中则没有。事实上，由于Java中泛型有擦除的机制，因而在编译A类的时候，它里面定义的方法都是以Object类型来表示了，因而如果没有bridge方法，B类根本没有覆盖A类中的abstract方法。正因为有bridge方法的存在，才使得B类可以编译通过。而C类由于在编译时所有的泛型也都是通过Object类来表达的，因而它实现的也是A类中的abstract方法，因而不用再生成bridge方法了。

事实上B类中的bridge方法在调用也有一些区别：

   public static void main(String[] args) {
       B b = new B();
       b.method1("abc");
       A<String> a = new B();
       a.method1("abc");
    }

这段方法的字节码如下：

0 new org.levin.insidejvm.miscs.bridgemethod.B [16]

3 dup

4 invokespecial org.levin.insidejvm.miscs.bridgemethod.B() [18]

7 astore_1 [b]

8 aload_1 [b]

9 ldc [19]

11 invokevirtual org.levin.insidejvm.miscs.bridgemethod.B.method1(java.lang.String) : java.lang.String [21]

14 pop

15 new org.levin.insidejvm.miscs.bridgemethod.B [16]

18 dup

19 invokespecial org.levin.insidejvm.miscs.bridgemethod.B() [18]

22 astore_2 [a]

23 aload_2 [a]

24 ldc [19]

26 invokevirtual org.levin.insidejvm.miscs.bridgemethod.A.method1(java.lang.Object) : java.lang.Object [25]

29 pop

30 return

以上的代码可以看出b变量调用的method1(String)的方法，而a变量调用的却是method1(Object)方法。这种区别也正式因为bridge方法提供的支持才实现的。

事实上，bridge方法还会在另外一种情况下产生（2）：

在Java 1.4中，子类若要重写父类某个方法，那么子类的方法和父类的方法签名必须完全一致，包括方法名、参数类型以及返回值；而到Java 1.5中，该机制变成，如果子类中某个方法的方法名和参数类型和父类某方法一致，并且子类该方法的返回值是父类相应方法返回值的类型或其子类型，那么该子类方法也可以重写父类中相应的方法。参看以下例子：

class E {

}

class F extends E {

}

class X {
    public E getE() {
       return new E();
    }
}

class Y extends X {
    @Override
    public F getE() {
       return new F();
    }
}

以上代码是可以编译通过的。让我们再来查看一下Y的字节码：

class org.levin.insidejvm.miscs.bridgemethod.Y extends org.levin.insidejvm.miscs.bridgemethod.X {

public org.levin.insidejvm.miscs.bridgemethod.F getE();

0 new org.levin.insidejvm.miscs.bridgemethod.F [16]

3 dup

4 invokespecial org.levin.insidejvm.miscs.bridgemethod.F() [18]

7 areturn

public bridge synthetic org.levin.insidejvm.miscs.bridgemethod.E getE();

0 aload_0 [this]

1 invokevirtual org.levin.insidejvm.miscs.bridgemethod.Y.getE() : org.levin.insidejvm.miscs.bridgemethod.F [20]

4 areturn

}

从字节码上，我们可以看出语法本身事实上并没有发生变化，变化的只是编译器做的支持，它为重载方法重新生成了一个返回E而不是F的bridge方法。

从调用的字节码上可以更加明显的看出语法没有发生变化这一点：

   public static void main(String[] args) {
       X x = new Y();
       x.getE();
    }

字节码如下：

public static void main(java.lang.String[] args);

0 new org.levin.insidejvm.miscs.bridgemethod.Y [16]

3 dup

4 invokespecial org.levin.insidejvm.miscs.bridgemethod.Y() [18]

7 astore_1 [x]

8 aload_1 [x]

9 invokevirtual org.levin.insidejvm.miscs.bridgemethod.X.getE() : org.levin.insidejvm.miscs.bridgemethod.E [19]

12 pop

13 return

该字节码中x.getE()方法事实上调用的就是生成的bridge方法（E getE()）方法，而不是用户定义的F getE()方法。

这种重载机制在某些，不同子类某个函数的返回值是不一样的，但是他们都需要重写父类中方法，以可以在某个点上通过父类实例统一调用。只是这种机制就需要返回值必须是继承于同一个类。事实上，这种方式在没有引入这种重写机制的时候也是可以实现的，只是现在Java在编译器层面上提供了支持。

于2010年10月3日
注：这些文章都是前些时候写的，之前博客很乱，也都是随便贴一些自己写的或转载的，还有一些则是没有贴出来过的。现在打算好好整理一下，完整的记录自己的一些学习历程，而每次看到过去的时间，则让我想起以前的日子，因而我对时间一直是很重视的，所以每篇都著名写的日期，直到最先的文章出现。:)

DLevin 2011-06-23 23:54 发表评论

Java接口中的字段

DLevin — Thu, 23 Jun 2011 15:51:00 GMT

Java接口中的字段默认都是静态常量，不管在编码的时候有没有显示的指定static或者final。

如以下接口：

public interface AccessFlag {
    public int a = 10;
    public static int b = 20;
    public final int c = 30;
    public static final int d = 40;
}

它编译生成的二进制代码如下：

public abstract interface org.levin.classfilereader.AccessFlag {

public static final int a = 10;

public static final int b = 20;

public static final int c = 30;

public static final int d = 40;

}

于2010年9月4日
注：这些文章都是前些时候写的，之前博客很乱，也都是随便贴一些自己写的或转载的，还有一些则是没有贴出来过的。现在打算好好整理一下，完整的记录自己的一些学习历程，而每次看到过去的时间，则让我想起以前的日子，因而我对时间一直是很重视的，所以每篇都著名写的日期，直到最先的文章出现。:)

DLevin 2011-06-23 23:51 发表评论

Static变量和实例变量的初始化顺序问题

DLevin — Mon, 20 Jun 2011 14:53:00 GMT

摘要: 问题重现让我们先来看一下以下的程序： Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1 public class StaticInitSequence { 2 ... 阅读全文

DLevin 2011-06-20 22:53 发表评论

Void类的用法

DLevin — Mon, 20 Jun 2011 14:48:00 GMT

今天在看ClassLoader源码的时候，突然发现里面有一个叫Void的类使用，代码看起来挺新颖的，摘下来，以备后用。

public abstract class ClassLoader {
   private static Void checkCreateClassLoader() {
   ...
   return null;

}

private ClassLoader(Void unused, ClassLoader parent) {

this.parent = parent;

}

protected ClassLoader(ClassLoader parent) {

this(checkCreateClassLoader(), parent);

}
protected ClassLoader() {

this(checkCreateClassLoader(), getSystemClassLoader());

}

checkCreateClassLoader()方法用返回Void类型，该函数返回null，然后它就可以在其他函数的参数中调用了，只要该参数也是Void类型的。

这种方式绕开了Java中不能在函数参数中使用void类型的局限。

可以作为部分参考吧。呵呵。

于2010年9月15日

注：这些文章都是前些时候写的，之前博客很乱，也都是随便贴一些自己写的或转载的，还有一些则是没有贴出来过的。现在打算好好整理一下，完整的记录自己的一些学习历程，而每次看到过去的时间，则让我想起以前的日子，因而我对时间一直是很重视的，所以每篇都著名写的日期，直到最先的文章出现。:)

DLevin 2011-06-20 22:48 发表评论

List或数组到String的转换

DLevin — Mon, 20 Jun 2011 05:27:00 GMT

在编程过程中偶尔会遇到需要将List或数组以某个字符间隔的形式将其拼接成一个字符串，比如在发送邮件时，to列表是以分号分割的字符串，然而在程序中我们可能会一List或String[]的形式存在，此时就需要做List或数组到String的转换。
在C#中，String类提供了一个叫Join的方法，因而我们使用一句代码就可以完成这样的工作：

string result = string.Join("; ", toList.ToArray());

但是在Java中貌似没有提供类似的方法（至少我还没有找到），既然没有提供，我们就可以自己来写一个：

public class StringUtils {
    /**
     * StringUitls类中的方法都是静态的，
     * 阻止其创建实例，以引起一些误解。
     * 另一种做法是将其变为abstract类，
     * 但是这样也会引起一些误解，
     * 因为abstract类的意思就是可以继承的，
     * 然而该类却不应该由其他类来继承。
     * 因而abstract类个人感觉不是一种好的做法。
     */
    private StringUtils() { }

    /**
     * 将array中的内容以delimiter为间隔拼接字符串
     *
     * @param array
     * @param delimiter
     * @return
     */
    public static String join(Object[] array, String delimiter) {
        if(array == null) {
            throw new IllegalArgumentException();
        }

        if(array.length == 0) {
            return "";
        }

        StringBuilder builder = new StringBuilder();
        for(Object item : array) {
            builder.append(item.toString() + delimiter);
        }
        builder.delete(builder.length() - delimiter.length(), builder.length());
        return builder.toString();
    }

    /**
     * 将list中的内容以delimiter为间隔拼接字符串
     *
     * @param list
     * @param delimiter
     * @return
     */
    @SuppressWarnings("unchecked")
    public static String join(List list, String delimiter) {
        if(list == null) {
            throw new IllegalArgumentException();
        }

        return join(list.toArray(), delimiter);
    }
}

测试代码如下：

1     @Test
2     public void testListToString() {
3         List<String> list = new ArrayList<String>();
4         list.add("Item1");
5         list.add("Item2");
6         list.add("Item3");
7
8         String expected = "[Item1, Item2, Item3]";
9
10         assertEquals(expected, list.toString());
11     }
12
13     @Test
14     public void testListToString2() {
15         List<String> list = new ArrayList<String>();
16         list.add("Item1");
17         list.add("Item2");
18         list.add("Item3");
19
20         String expected = "Item1;Item2;Item3";
21
22         assertEquals(expected, StringUtils.join(list, ";"));
23     }

DLevin 2011-06-20 13:27 发表评论