"abc".equals(str) ,str.equals("abc")哪个 效率高一些？

Question

"abc".equals(str) ,str.equals("abc")哪个 效率高一些？

Answer 1

不存在性能问题
"abc".equals(str)
这个更安全些

Answer 2

当str=null才会 出问题，为避免就把str放在后面，通常做法。

Answer 3

效率基本一样
"abc".equals(str)比较好。
避开了str=null 出现 null异常

Answer 4

"abc".equals(str)主要就是为了避免出现没有给str赋值而造成的空指针操作异常

Answer 5

效率一样吧，
"abc".equals(str)避免出现空指针操作异常

Answer 6

若str是new创建的，两者皆可；若str已经被赋值null,只能是str.equals("abc")，用前者会报
空指针异常，因为str不存在对象引用,就不能调用equals方法

Answer 7

测试代码
    public static void main(String[] args){
//        TestDialog dlg = new TestDialog();
//        dlg.showModal();        long start = System.currentTimeMillis();
        String str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
//String str = "a";        for(int i=0;i<99999999;i++){
            str.equals("aaa");
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);        start = System.currentTimeMillis();
        for(int i=0;i<99999999;i++){
             "aaa".equals(str);
        }
        end = System.currentTimeMillis();
        System.out.println(end-start);    }输出结果：
1213
1313
因此第一种[str.equals("aaa");]效率高
如果有人有不同的意见，请用原代码说话
不要凭直觉说话，我们是在讨论技术问题

Answer 8

晕，你怎么瞎下结论呢？
我最少点了100多次
每次测试都差不多这个结果
而且将执行顺序改变也是这种结论
不同的机器，我当然没测试
不过我可以肯定对于相同版本的JVM结果不会有变化
当然如果你仍然坚持你的观点，那就当我什么也没说

Answer 9

我的测试结果：第[1]次测试结果: 
str.equals("aaa")总共用时[1188]毫秒 
"aaa".equals(str)总共用时[687]毫秒 
====================================== 
第[2]次测试结果: 
str.equals("aaa")总共用时[1234]毫秒 
"aaa".equals(str)总共用时[688]毫秒 
====================================== 
第[3]次测试结果: 
str.equals("aaa")总共用时[1156]毫秒 
"aaa".equals(str)总共用时[688]毫秒 
====================================== 
第[4]次测试结果: 
str.equals("aaa")总共用时[1203]毫秒 
"aaa".equals(str)总共用时[719]毫秒 
====================================== 
第[5]次测试结果: 
str.equals("aaa")总共用时[1171]毫秒 
"aaa".equals(str)总共用时[719]毫秒 
====================================== 
第[6]次测试结果: 
str.equals("aaa")总共用时[1156]毫秒 
"aaa".equals(str)总共用时[704]毫秒 
====================================== 
第[7]次测试结果: 
str.equals("aaa")总共用时[1156]毫秒 
"aaa".equals(str)总共用时[687]毫秒 
====================================== 
第[8]次测试结果: 
str.equals("aaa")总共用时[1157]毫秒 
"aaa".equals(str)总共用时[703]毫秒 
====================================== 
第[9]次测试结果: 
str.equals("aaa")总共用时[1172]毫秒 
"aaa".equals(str)总共用时[719]毫秒 
====================================== 
第[10]次测试结果: 
str.equals("aaa")总共用时[1187]毫秒 
"aaa".equals(str)总共用时[672]毫秒 
====================================== 源代码： 
public static void main(String[] args) {
        String str = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
        //String str = "a";
        
        for(int k = 1; k <= 10; k ++){
            long start = System.currentTimeMillis();
            System.out.println("第[" + k + "]次测试结果:");
            for(int i=0;i<99999999;i++){
                str.equals("aaa");
            }
            long end = System.currentTimeMillis();
            System.out.println("str.equals(\"aaa\")总共用时[" + (end-start) + "]毫秒");
            
            start = System.currentTimeMillis();
            for(int i=0;i<99999999;i++){
                "aaa".equals(str);
            }
            end = System.currentTimeMillis();
            System.out.println("\"aaa\".equals(str)总共用时[" + (end-start) + "]毫秒");
            System.out.println("======================================");
        }
    }
由测试结果可以看出 "aaa".equals(str) 效率比 str.equals("aaa") 好， 
但是 99999999 次才高了500毫秒左右，平均每次相差1/200000毫秒，约合1/200纳秒，完全可以忽略。

Answer 10

非权威人士说
"abc".equals(str)
要好一点
^_^

Answer 11

第[1]次测试结果:
"aaa".equals(str)总共用时[1391]毫秒
str.equals("aaa")总共用时[1281]毫秒
======================================
第[2]次测试结果:
"aaa".equals(str)总共用时[1391]毫秒
str.equals("aaa")总共用时[1250]毫秒
======================================
第[3]次测试结果:
"aaa".equals(str)总共用时[1406]毫秒
str.equals("aaa")总共用时[1281]毫秒
======================================
第[4]次测试结果:
"aaa".equals(str)总共用时[1438]毫秒
str.equals("aaa")总共用时[1281]毫秒
======================================
第[5]次测试结果:
"aaa".equals(str)总共用时[1406]毫秒
str.equals("aaa")总共用时[1281]毫秒
======================================
第[6]次测试结果:
"aaa".equals(str)总共用时[1391]毫秒
str.equals("aaa")总共用时[1297]毫秒
======================================
第[7]次测试结果:
"aaa".equals(str)总共用时[1437]毫秒
str.equals("aaa")总共用时[1282]毫秒======================================
第[8]次测试结果:
"aaa".equals(str)总共用时[1406]毫秒
str.equals("aaa")总共用时[1250]毫秒
======================================
第[9]次测试结果:
"aaa".equals(str)总共用时[1375]毫秒
str.equals("aaa")总共用时[1250]毫秒
======================================
第[10]次测试结果:
"aaa".equals(str)总共用时[1375]毫秒
str.equals("aaa")总共用时[1266]毫秒
======================================测试结果
[str.equals("aaa")]效率高 测试环境：
WindowsXP sp2
JBuilder9.0
JDK1.4.2-b28

Answer 12

测试结果"aaa".equals(str);效率高

Answer 13

效率基本一样 
"abc".equals(str)比较好。 
避开了str=null 出现 null异常 

Answer 14

"abc".equals(str) 无论从安全性还是效率 都要高些. 老师就是这样说的哦  呵呵

Answer 15

从字节码看不过交换了两条指令aload_1和ldc而已，它们会造成影响吗？
请高手指点。

Answer 16

public class Change { /**
 * @param args
 */
public static void main(String[] args) {
String str = null;
if("bbb".equals(str))
str = "no change 1";

if(str.equals("bbb"))
str = "no change 2";
}}javap -c Change 字节码如下：
F:\workspace\Test>javap -c Change
Compiled from "Change.java"
public class Change extends java.lang.Object{
public Change();
  Code:
   0:   aload_0
   1:   invokespecial   #9; //Method java/lang/Object."<init>":()V
   4:   returnpublic static void main(java.lang.String[]);
  Code:
   0:   aconst_null
   1:   astore_1
   2:   ldc     #17; //String bbb
   4:   aload_1
   5:   invokevirtual   #23; //Method java/lang/String.equals:(Ljava/lang/Object
;)Z
   8:   ifeq    14
   11:  ldc     #25; //String no change 1
   13:  astore_1
   14:  aload_1
   15:  ldc     #17; //String bbb
   17:  invokevirtual   #23; //Method java/lang/String.equals:(Ljava/lang/Object
;)Z
   20:  ifeq    26
   23:  ldc     #27; //String no change 2
   25:  astore_1
   26:  return}楼上说的 两条指令aload_1和ldc交换 
aload_1： 变量到操作数栈
ldc    ： 常数到操作数栈在我的机器上 jre： 1.6.0_10
             cpu:Inter(R) Core(TM)2 Duo CPU T5800 @2.00GHZ 上还是常数到操作数栈快。
             既： "aaa".equals(str) 快。
 请高手指正。smile

Answer 17

结合上面的验证和自己的验证:
哪个长放在后面比较快一点。
理论上是一样的。
下面是比较的测试结果：
1188
1265public static void main(String[] args){
//      TestDialog dlg = new TestDialog();
//      dlg.showModal();      long start = System.currentTimeMillis();
      String str = "aaa";
//String str = "a";      for(int i=0;i<99999999;i++){
          str.equals("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
      }
      long end = System.currentTimeMillis();
      System.out.println(end-start);      start = System.currentTimeMillis();
      for(int i=0;i<99999999;i++){
       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".equals(str);
      }
      end = System.currentTimeMillis();
      System.out.println(end-start);  }

Answer 18

"abc".equals(str)主要是为了避免空指针异常