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

[桐桐-Dragon]

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


说明白的加分!!!

[24K純帥]

火龙果大哥，学习了~

[licip]

这个要具体项目中说可能才说得清楚。

[火龙果被占用了]

像 BigInteger, BigDecimal 这些类在很早以前的 JDK 版本中性能是很差的，但是 JAVA 已经走过了 16 年，这两个大数类已经经过非常精心的优化了。

你不相信的话，你可以自己实现一个，然后再跟类库中的方法进行比较，看看有什么不足。

类库中一般只会存在设计不佳的类或者方法，比如：

1：Thread#stop, #resume, #suspend 等方法。JDK 的开发人员想当然地认为线程能够任意的被终止，而导致这个从 JDK 1.2 就废弃的方法

2：滥用了继承的 java.util.Stack 类。这个类由于继承自 Vector，因此导致这个类有很多方法不应该属于栈的）

3：java.util.Timer 由于采用的是绝对计时，如果执行期间抛出异常，或者更改系统时间会导致不可预料的结果。

等等诸如此，但是 JDK 在这些之后都有经过补救，提供更优秀的类库。

[huntor]

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

[shine333]

我知道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;
    }

[shine333]

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

[shine333]

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();
    }

[healer_kx]

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

[a869467149]

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

[龙四]

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

[桐桐-Dragon]

要的就是13楼朋友的这种分享。。。谢谢哈，
也谢谢上面那些高手们的指点！！！！

[疯狂的驴子]

呵呵，看看，大侠们，的高见。

[mtv0199]

我知道有几个：

第一，能用charAt()的时候不用startsWith()，看下源码就知道了。

第二，遍历map的时候，别拆成key,value，直接得到entry遍历，原因是重hash影响效率。

第三，别滥用foreach循环，这个实际是iterable，arraylist能用i,i<size,i++这种方式当然是最快的，不过一般情况下差不多。

剩下就是自己编程时注意了，尽量重用对象，尽量少try catch。

[桐桐-Dragon]

自己顶起，精心学习了~~~~~

希望大家广泛说自己的经验~~~~

也许我描述的不大清楚-----补充一句：性能源于需求

比如说：把字符a转换成大写，会怎么做呢？？？我不是说toUpperCase()方法不好，
而是指有更快更简洁的办法去实现

[潇水汀寒]

额去
都系高手

[茫茫大海]

都是大牛啊，学习了。

[draftbeer]

感觉自己写的方法 很多是属于性能较差的

[jackingod]

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

[wingson_shen]

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

[shine333]

没想到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;
    }