2. 程式人生 > >java int轉String全部方式的效率對照與深入解析

java int轉String全部方式的效率對照與深入解析

阿新 • • 發佈：2017-07-29
表達 comm 個數 第一個 另一個 alt lock his ng-

　　在java中，大家肯定都會遇到int類型轉String類型的情形，知其然知其所以然。總結加分析一下，int類型轉String類型有下面幾種方式：　　

  1. a+”“
  2. String.valueOf(a)
  3. Integer.toString(a)
　　以上三種方法在實際使用過程中都是沒有問題的，可是效率上還是有些許區別的，所以寫個小程序來對照一下他們的效率：

int a = 123456789;
long start = System.currentTimeMillis();
for (int i=0; i<100000; i++){
    String m = a+"";
}
long end
 
 = System.currentTimeMillis();
Log.e("time", "a+\"\" = " + (end - start));

start = System.currentTimeMillis();
for (int i=0; i<100000; i++){
    String n = String.valueOf(a);
}
end = System.currentTimeMillis();
Log.e("time", "String.valueOf(a) = " +(end-start));

start = System.currentTimeMillis();
for
 
 (int i=0; i<100000; i++){
    String n = Integer.toString(a);
}
end = System.currentTimeMillis();
Log.e("time", "Integer.toString(a) = " +(end-start));

最後打印出來的運行時間：

E/time: a+"" = 257
E/time: String.valueOf(a) = 140
E/time: Integer.toString(a) = 159

能夠看到在效率上除了a+”“這樣的方式之外，其它兩種方式的效率差點兒相同。為什麽呢？看源代碼！

String.valueOf(a) && Integer.toString(a)

　　先看看後兩種方式的源代碼：
String.valueOf(a)->Integer.toString(a)->IntegralToString.intToString(a)->convertInt(null, a)

Integer.toString(a)->IntegralToString.intToString(a)->convertInt(null, a)
能夠看到String.valueOf是通過調用Integer.toString實現的，也難怪他們的效率如此接近。

他們最後都會調用到convertInt函數中：

private static String convertInt(AbstractStringBuilder sb, int i) {
    boolean negative = false;
    String quickResult = null;
    if (i < 0) {
        negative = true;
        i = -i;
        if (i < 100) {
            if (i < 0) {
                // If -n is still negative, n is Integer.MIN_VALUE
                quickResult = "-2147483648";
            } else {
                quickResult = SMALL_NEGATIVE_VALUES[i];
                if (quickResult == null) {
                    SMALL_NEGATIVE_VALUES[i] = quickResult =
                            i < 10 ? stringOf(‘-‘, ONES[i]) : stringOf(‘-‘, TENS[i], ONES[i]);
                }
            }
        }
    } else {
        if (i < 100) {
            quickResult = SMALL_NONNEGATIVE_VALUES[i];
            if (quickResult == null) {
                SMALL_NONNEGATIVE_VALUES[i] = quickResult =
                        i < 10 ?
 stringOf(ONES[i]) : stringOf(TENS[i], ONES[i]);
            }
        }
    }
    if (quickResult != null) {
        if (sb != null) {
            sb.append0(quickResult);
            return null;
        }
        return quickResult;
    }

    int bufLen = 11; // Max number of chars in result
    char[] buf = (sb != null) ?
 BUFFER.get() : new char[bufLen];
    int cursor = bufLen;

    // Calculate digits two-at-a-time till remaining digits fit in 16 bits
    while (i >= (1 << 16)) {
        // Compute q = n/100 and r = n % 100 as per "Hacker‘s Delight" 10-8
        int q = (int) ((0x51EB851FL * i) >>> 37);
        int r = i - 100*q;
        buf[--cursor] = ONES[r];
        buf[--cursor] = TENS[r];
        i = q;
    }

    // Calculate remaining digits one-at-a-time for performance
    while (i != 0) {
        // Compute q = n/10 and r = n % 10 as per "Hacker‘s Delight" 10-8
        int q = (0xCCCD * i) >>> 19;
        int r = i - 10*q;
        buf[--cursor] = DIGITS[r];
        i = q;
    }

    if (negative) {
        buf[--cursor] = ‘-‘;
    }

    if (sb != null) {
        sb.append0(buf, cursor, bufLen - cursor);
        return null;
    } else {
        return new String(cursor, bufLen - cursor, buf);
    }
}

分析一下，這個函數的工作主要能夠分為這幾步：

  1. 假設a為負數。將a變成正數，假設a還小於0，直接置為Integer.MIN_VALUE；假設a小於100。則直接使用TENS和ONES數組進行高速計算得出結果。加上’-‘號。直接返回該結果。

  2. 假設a為正數而且小於100。直接使用TENS和ONES數組進行高速計算得出結果返回。

  3. 假設上面兩步沒有處理完，說明a是大於100的數字，無法直接使用TENS和ONES數組進行高速計算。處理方式就是2位為一步循環處理，每次將這兩位使用TENS和ONES數組進行高速計算得出這兩位的結果存在數組的對應位置。直到僅僅剩一位。最後剩下的一位使用DIGITS數組得出16進制的結果放在最後。返回結果。

　　那麽問題來了。當a>=100的時候，那兩次while循環為什麽會使用0x51EB851FL和0xCCCD這兩個數字呢？這個問題不要問我，我也不知道技術分享技術分享技術分享，只是源代碼作者凝視寫的非常明確了：
// Compute q = n/100 and r = n % 100 as per "Hacker‘s Delight" 10-8
// Compute q = n/10 and r = n % 10 as per "Hacker‘s Delight" 10-8
去看《Hacker’s Delight》的10-8章。
　　接著另一個問題是TENS和ONES數組，直接看代碼。一目了然：

/** TENS[i] contains the tens digit of the number i, 0 <= i <= 99. */
private static final char[] TENS = {
        ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘, ‘0‘,
        ‘1‘, ‘1‘, ‘1‘, ‘1‘, ‘1‘, ‘1‘, ‘1‘, ‘1‘, ‘1‘, ‘1‘,
        ‘2‘, ‘2‘, ‘2‘, ‘2‘, ‘2‘, ‘2‘, ‘2‘, ‘2‘, ‘2‘, ‘2‘,
        ‘3‘, ‘3‘, ‘3‘, ‘3‘, ‘3‘, ‘3‘, ‘3‘, ‘3‘, ‘3‘, ‘3‘,
        ‘4‘, ‘4‘, ‘4‘, ‘4‘, ‘4‘, ‘4‘, ‘4‘, ‘4‘, ‘4‘, ‘4‘,
        ‘5‘, ‘5‘, ‘5‘, ‘5‘, ‘5‘, ‘5‘, ‘5‘, ‘5‘, ‘5‘, ‘5‘,
        ‘6‘, ‘6‘, ‘6‘, ‘6‘, ‘6‘, ‘6‘, ‘6‘, ‘6‘, ‘6‘, ‘6‘,
        ‘7‘, ‘7‘, ‘7‘, ‘7‘, ‘7‘, ‘7‘, ‘7‘, ‘7‘, ‘7‘, ‘7‘,
        ‘8‘, ‘8‘, ‘8‘, ‘8‘, ‘8‘, ‘8‘, ‘8‘, ‘8‘, ‘8‘, ‘8‘,
        ‘9‘, ‘9‘, ‘9‘, ‘9‘, ‘9‘, ‘9‘, ‘9‘, ‘9‘, ‘9‘, ‘9‘
};

/** Ones [i] contains the tens digit of the number i, 0 <= i <= 99. */
private static final char[] ONES = {
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
        ‘0‘, ‘1‘, ‘2‘, ‘3‘, ‘4‘, ‘5‘, ‘6‘, ‘7‘, ‘8‘, ‘9‘,
};

每一個數組都是100的長度，都是用來處理0~99這100個數字，個位和十位的處理方式也非常清楚。


　　從代碼角度來看，這個算法在數字小於100的和大於100的處理方式是不一樣的，小於100的高速計算法運行時間會遠遠短於大於100的方式。驗證一下。將a變量改動為10：

E/time: i+"" = 199
E/time: String.valueOf() = 7
E/time: Integer.toString() = 6

確實短了非常多。！！

a+”“

　　再來看看a+”“的方式，我承認這樣的方式我用的最多了，由於太簡單了，java源代碼對’+’運算符進行了重載。源代碼我找不到啊，只是從網上找一些資料：

The Java language provides special support for the string concatenation operator ( + ), and for conversion of other objects to strings. String concatenation is implemented through the StringBuilder(or StringBuffer) class and its append method. String conversions are implemented through the method toString, defined by Object and inherited by all classes in Java. For additional information on string concatenation and conversion, see Gosling, Joy, and Steele, The Java Language Specification.

地址：http://docs.oracle.com/javase/6/docs/api/java/lang/String.html

能夠看到，’+’運算符的主要方式是使用StringBuilder或者StringBuffer來實現的。相似於：

StringBuilder sb = new StringBuilder();
sb.append("");
sb.append(i);
String strI = sb.toString();

再來看看append的源代碼：
StringBuffer.append->IntegralToString.appendInt(this, a)->convertInt(sb, i)
能夠看到’+’運算符最後也是調用到了同一個函數。僅僅只是第一個參數的sb不為null而已。所以已經非常清楚了，’+’運算符的運行效率不高的原因應該就在之前的new StringBuilder等操作和之後的StringBuilder.toString等操作，反編譯class文件也能夠得出一樣的結論：
http://stackoverflow.com/a/4105406。


　　所以a+”“的方式以後就少用一點了，效率不高，也顯得不太專業。

擴展

　　String 擴展的相關知識：
常量池的內存分配在 JDK6、7、8中有不同的實現：
1. JDK6及之前版本號中，常量池的內存在永久代PermGen進行分配。所以常量池會受到PermGen內存大小的限制。
2. JDK7中，常量池的內存在Java堆上進行分配。意味著常量池不受固定大小的限制了。


3. JDK8中，虛擬機團隊移除了永久代PermGen。
關於永久代移除：http://www.infoq.com/cn/articles/Java-PERMGEN-Removed
樣例1：

public class StringTest {
    public static void main(String[] args) {
        String a = "java";
        String b = "java";
        String c = "ja" + "va";
    }
}

變量 a、b 和 c 都指向常量池的 “java” 字符串，表達式 “ja” + “va” 在編譯期間會把結果值”java”直接賦值給c。所以終於的結果 a==c 為 true。

樣例2：

public class StringTest {
    public static void main(String[] args) {
        String a = "hello ";
        String b = "world";
        String c = a + b;
        String d = "hello world";
    }
}

我們依據上面知道在 java 中 “+” 運算符實際上是使用 StringBuilder.append 去實現的。所以此時會在 Java 堆上新建一個 String 對象，這個 String 對象終於指向常量池的 “hello world”。所以說此時 c==d 為 false。


只是有種特殊情況。當final修飾的變量發生連接動作時，編譯器會進行優化，將表達式結果直接賦值給目標變量：

public class StringTest {
    public static void main(String[] args) {
        final String a = "hello ";
        final String b = "world";
        String c = a + b;
        String d = "hello world";
    }
}

所以此時 c==d 為 true。

引用

http://www.importnew.com/21711.html
http://www.importnew.com/21720.html

java int轉String全部方式的效率對照與深入解析

相關推薦

java int轉String全部方式的效率對照與深入解析

表達 comm 個數 第一個 另一個 alt lock his ng- 　　在java中，大家肯定都會遇到int類型轉String類型的情形，知其然知其所以然。總結加分析一下，int類型轉String類型有下面幾種方式：　　a+”“String.valu

java int轉String所有方式的效率對比與深入解析

　　在java中，大家肯定都會遇到int型別轉String型別的情形，知其然知其所以然，總結加分析一下，int型別轉String型別有以下幾種方式：　　a+”“String.valueOf(a)Integer.toString(a)　　以上三種方法在實際使用過程

java中int轉string，string轉int效率對比

string轉int，兩種方法： 1、Interger.parseInt(String) 2、Interger.valueOf(String).intValue() 第二種方法可以去看原始碼，實現了第一種方法。 註釋大概就是這樣的意思 /**       *返回一個包含整

int 轉 String 的效率大比拼

先說一下我自己的實驗結論吧，int 轉 String 的三個方法（假設 x 是int 型變數）： ①""+x，效率最低； ②Integer.toString( x )，效率最高； ③String.valueOf( x )，效率比②低一點比①好不少。 詳情如下： 有一

常用格式轉換整理（byte轉string， int轉string....）

1、String和int轉換 （1）Sting 轉為int String str = "123"; try { int a = Integer.parseInt(str); } catch (NumberFormatException e) { e.printStackT

C/C++ 中 int 轉 string，string 轉 int 的幾種方法

C int 轉 string sprintf int a = 1; char strDst[256] = {0}; sprintf_s(strDst,256,"%d",a); itoa int

java double轉String，去掉科學計數法

在數值型double轉String格式時，如果同時遇到數值較大的double和小數位較多的double處理方法： double a = 111111111111.00; double b = 2.22222222222222; java.text.NumberFormat NF = j

c++基礎(四）：int轉string及陣列預設值

使用java時，感覺字串轉換很方便，因為已經做了很好的封裝。然而，在c++中，如果像將一個int轉乘string，就需要注意一些... int轉string std::string str = "s" + 0; 如果在java中， 我們這樣寫很容易就

Android面試——java基礎：String各種方式建立時，做==運算結果

先看結果後分析 String s1 = "MileIsGoodBoy";//在常量池中 String s2 = new String("MileIsGoodBoy");//堆中 String s3 = "MileIs";/

java int和string之間的轉換

一、int轉為String .兩種方法，一個是再int後面+“”，就可以轉為字串。 另一個， int i=12345; String s=""; 第一種方法：s=i+""; 第二種方法：s=String.valueOf(i); 這兩種方法有什麼區別呢？作用是不是一樣的呢？是不是在任何

java list轉String,list轉map,String陣列轉list，帶逗號String轉list

專案中經常會遇到list轉String,list轉map,String轉list等情況，特在這裡記錄一下。 1.list轉String 將List集合轉化為用符號隔開的String字串，只要用StringUtils中的join就行。 String

java float[]轉String,String轉float[]

package index; import java.util.Arrays; //float[]轉String,String轉float[] public class Change { pub

int 轉 string

題目： int型別資料轉換為string 解析： 將int型別number重複做如下運算：number % 10；number /= 10;將取餘所得結果轉換為對應的字元加入string中。 注意

int轉String 使用0來填充長度

import java.text.DecimalFormat; //(1)、如果數字1是字串，如下處理： String str1=”1”; DecimalFormat df=new DecimalFormat(“0000”);

java ascii轉String

line sta append spl stat stringbu char 解決 問題： 最近處理asciitoString時，發現晚上多沒有處理行，這裏解決處理行的問題： public static String asciiToString(String te

pdo 查詢 mysql 返回值 int 轉 string 型別的問題

<?php $dsn = "mysql:dbname=$app[db_name];host=$app[db_host];port=$app[db_port];charset=utf8"; try { $dbh = @new PDO($dsn, $app['db_username'], $app[

java中關於String和StringBuffer的問題與解析

構造 表達式 數據 str 字符數 stringbu 傳遞 數值 動態 問題一：String 和 StringBuffer 的區別JAVA 平臺提供了兩個類： String 和 StringBuf fer ，它們可以儲存和操作字符串，即包含多個字符的字符數據。這個 Stri

java的兩種同步方式， Synchronized與ReentrantLock的區別

性能 避免 字節碼 數據 獲取對象 通過 finall 內核 構造函數 java在編寫多線程程序時，為了保證線程安全，需要對數據同步，經常用到兩種同步方式就是Synchronized和重入鎖ReentrantLock。 相似點： 這兩種同步方式有很多相似之

Java:Excel轉PDF實現方案;基於POI與Itext進行搭配.

由於此份文章比較久遠並且發現點選率也蠻高的，為了方便大夥的測試與研究我另外建立 了一份程式碼倉庫在GitHub中，請大夥直接從這個地址拉取： https://github.com/caryyu/excel2pdf 注意！注意！注意！分隔線以下的程式碼比較久遠了，最新

Excel轉Html(十)--POI處理HSSFWorkbook與XSSFWorkbook解析表項的邊框和字型顏色區別

1、增加HSSFWorkbook老Excel支援 2、注意：HSSFWorkbook與XSSFWorkbook解析表項的邊框和字型顏色區別 邊框和字型顏色，需要在HSSFPalette中獲取， HSSFPalette customPalette = wb.getCustomPalet