java中常见的性能较差的方法：

Question

请列举你知道的java中性能较差的方法，并说明理由
说明白的加分!!!

Answer 1

Java 中的方法都是经过 N 多测试，经过完整的软件开发流程一步一步发布的，你很难找出其中性能很差的方法。

Answer 2

楼上说的对 Java中的方法没有性能很差的方法
只有在某些具体情况下 性能不如其他的方法
但是它们在自己擅长的地方性能都很好
Java版本的更新会去掉许多方法，Java不断更新里面的方法都是千锤百炼的

Answer 3

像 BigInteger, BigDecimal 这些类在很早以前的 JDK 版本中性能是很差的，但是 JAVA 已经走过了 16 年，这两个大数类已经经过非常精心的优化了。你不相信的话，你可以自己实现一个，然后再跟类库中的方法进行比较，看看有什么不足。类库中一般只会存在设计不佳的类或者方法，比如：1：Thread#stop, #resume, #suspend 等方法。JDK 的开发人员想当然地认为线程能够任意的被终止，而导致这个从 JDK 1.2 就废弃的方法2：滥用了继承的 java.util.Stack 类。这个类由于继承自 Vector，因此导致这个类有很多方法不应该属于栈的）3：java.util.Timer 由于采用的是绝对计时，如果执行期间抛出异常，或者更改系统时间会导致不可预料的结果。等等诸如此，但是 JDK 在这些之后都有经过补救，提供更优秀的类库。

Answer 4

java.math.BigXXX 最先是 c＋jni，后来才 pure java。据说性能提升了不少，

Answer 5

我知道String中间的一个Bug: String.contentEquals(CharSequence) calculates twice for AbstractStringBuilder
(http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6355654)
JDK 7中间已经修正(JDK7b03），据说JDK6及其他更低版本将不会修改    public boolean contentEquals(CharSequence cs) {
        if (count != cs.length())
            return false;
        // Argument is a StringBuffer, StringBuilder
        if (cs instanceof AbstractStringBuilder) {
            char v1[] = value;
            char v2[] = ((AbstractStringBuilder)cs).getValue();
            int i = offset;
            int j = 0;
            int n = count;
            while (n-- != 0) {
                if (v1[i++] != v2[j++])
                    return false;
            }
///////////// SINCE ALL CHARACTERS ARE EQUAL, WHY NOT RETURN TRUE HERE?
        }
        // Argument is a String
        if (cs.equals(this))
            return true;
        // Argument is a generic CharSequence
        char v1[] = value;
        int i = offset;
        int j = 0;
        int n = count;
        while (n-- != 0) {
            if (v1[i++] != cs.charAt(j++))
                return false;
        }
        return true;
    }

Answer 6

比如，"abc".contentEquals(new StringBuilder("abc"))将比较两次

Answer 7

String中间另外一个问题（也在7中修正），虽然谈不上性能影响，但是很傻:
    private static class CaseInsensitiveComparator
                         implements Comparator<String>, java.io.Serializable {
// use serialVersionUID from JDK 1.2.2 for interoperability
private static final long serialVersionUID = 8575799808933029326L;        public int compare(String s1, String s2) {
            int n1=s1.length(), n2=s2.length();
            for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
                char c1 = s1.charAt(i1);
                char c2 = s2.charAt(i2);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
    }i1 i2永远相等，何必用两个。还有一点，具体地方讲不全，就是代码用到了字符串拼接，但是由于代码很早，当时只有StringBuffer，而实际应用，这个buffer完全是方法内的局部变量，不存在线程安全性问题，用StringBuilder会快那么一点点。
正则之Matcher:
    public static String quoteReplacement(String s) {
        if ((s.indexOf('\\') == -1) && (s.indexOf('$') == -1))
            return s;
        StringBuffer sb = new StringBuffer(); // 可以使用StringBuilder，而且，最好设置一下初始大小，
// 否则，如果参数s的长度是1000，那么这个StringBuffer/Builder要增长好多次，才能满足大小
// see AbstractStringBuilder.expandCapacity(int)
        for (int i=0; i<s.length(); i++) {
            char c = s.charAt(i);
            if (c == '\\') {
                sb.append('\\'); sb.append('\\');
            } else if (c == '$') {
                sb.append('\\'); sb.append('$');
            } else {
                sb.append(c);
            }
        }
        return sb.toString();
    }

Answer 8

Java性能不错，就是太耗内存了。

Answer 9

每一种语言都有自己适合的领域，都有自己的长处。我认为，不需要讲求Java封装好的方法性能，首先，我们要是用Java的话，我们绝大多数不会重写已经定义好的方法，这一点不就证明Java方法的性能吗？性能的不同应该讲求到语言之间的不用，做界面，做底层等等各有长短！-----Java新手之见，望指正！

Answer 10

类a在sun的jvm可能很慢，但在ibm j9或者jrockit上可能很快，这个说不好的，再说有运行时优化，会编译成本地代码，不同的jvm优化算法也是大不相同，自然效率也就不一样

Answer 11

我知道有几个：第一，能用charAt()的时候不用startsWith()，看下源码就知道了。第二，遍历map的时候，别拆成key,value，直接得到entry遍历，原因是重hash影响效率。第三，别滥用foreach循环，这个实际是iterable，arraylist能用i,i<size,i++这种方式当然是最快的，不过一般情况下差不多。剩下就是自己编程时注意了，尽量重用对象，尽量少try catch。

Answer 12

那主题好像有点偏了 如果群主想知道13楼那样的 去看efficative java吧

Answer 13

JDK里的方法都是设计得很精良的了。

Answer 14

没想到lz要的是13f这种偏题的答案1 没看懂
3 非常容易误导，Iterator方式访问（包括foreach，这个只是代码，编译出来的内容就是Iterator方式）与i,i<size,i++相比，只快不慢，特别是大LinkedList，绝对绝对不能用i,i<size,i++
盖因LinkedList.get(int index)需要执行：    /**
     * Returns the indexed entry.
     */
    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;
    }