Integer.toString (int i) vs String.valueOf (int i)

ฉันสงสัยว่าทำไมวิธีการที่String.valueOf(int i)มีอยู่? ฉันใช้วิธีนี้ในการแปลงintเป็นStringและเพิ่งค้นพบInteger.toString(int i)วิธี

หลังจากดูการใช้งานวิธีการเหล่านี้ฉันเห็นว่าคนแรกเรียกคนที่สอง ดังนั้นการโทรทั้งหมดของฉันจะString.valueOf(int i)เกี่ยวข้องกับการโทรมากกว่าการโทรโดยตรงโดยตรงInteger.toString(int i)

เพียงสองวิธีที่ต่างกันในการทำสิ่งเดียวกัน อาจเป็นเหตุผลทางประวัติศาสตร์ (จำไม่ได้ว่ามีใครมาก่อน)

ในประเภท String เรามีวิธีการหลายค่าของ

static String   valueOf(boolean b) 
static String   valueOf(char c) 
static String   valueOf(char[] data) 
static String   valueOf(char[] data, int offset, int count) 
static String   valueOf(double d) 
static String   valueOf(float f) 
static String   valueOf(int i) 
static String   valueOf(long l) 
static String   valueOf(Object obj) 

อย่างที่เราเห็นวิธีการเหล่านั้นสามารถแก้ไขตัวเลขทุกชนิดได้

การใช้งานวิธีการเฉพาะทุกอย่างที่คุณนำเสนอ: ดังนั้นสำหรับจำนวนเต็มเรามี

Integer.toString(int i)

สำหรับคู่

Double.toString(double d)

และอื่น ๆ

ในความคิดของฉันนี่ไม่ใช่สิ่งประวัติศาสตร์ แต่มีประโยชน์สำหรับนักพัฒนาที่จะใช้วิธีการvalueOfจากคลาส String มากกว่าจากประเภทที่เหมาะสมเนื่องจากมันนำไปสู่การเปลี่ยนแปลงน้อยลงสำหรับเรา

ตัวอย่างที่ 1:

public String doStuff(int num) {

  // Do something with num...

  return String.valueOf(num);

 }

Sample2:

public String doStuff(int num) {

 // Do something with num...

 return Integer.toString(num);

 }

ดังที่เราเห็นในตัวอย่างที่ 2 เราต้องทำการเปลี่ยนแปลงสองอย่างในทางตรงกันข้ามกับตัวอย่างที่หนึ่ง

ในบทสรุปของฉันการใช้valueOfวิธีจากคลาส String นั้นมีความยืดหยุ่นมากกว่า

สิ่งหนึ่งที่แตกต่างกันอย่างมากก็คือถ้าคุณเรียกใช้toString()วัตถุที่เป็นโมฆะคุณจะได้รับการใช้งานNullPointerExceptionในขณะที่String.valueOf()คุณไม่สามารถตรวจสอบค่าว่างได้

คลาส String ให้วิธีการ valueOf สำหรับประเภทดั้งเดิมและประเภทวัตถุดังนั้นฉันคิดว่ามันเป็นวิธีการอำนวยความสะดวกที่ทุกคนสามารถเข้าถึงได้ผ่านชั้นเดียว

NB ผลการจัดทำโปรไฟล์

Average intToString = 5368ms, ค่าเฉลี่ยสตริง = 5689ms (สำหรับการดำเนินการ 100,000,000 ครั้ง)

public class StringIntTest {


    public static long intToString () {
        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = Integer.toString(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static long stringValueOf () {

        long startTime = System.currentTimeMillis();
        for (int i = 0; i < 100000000; i++) {
            String j = String.valueOf(i);
        }
        long finishTime = System.currentTimeMillis();

        return finishTime - startTime;
    }

    public static void main(String[] args) {
        long intToStringElapsed = 0;
        long stringValueOfElapsed = 0;
        for (int i = 0; i < 10; i++) {
            intToStringElapsed += intToString();
            stringValueOfElapsed+= stringValueOf();
        }
        System.out.println("Average intToString = "+ (intToStringElapsed /10));
        System.out.println("Average stringValueOf = " +(stringValueOfElapsed / 10));
    }
}

จากแหล่ง Java:

/**
 * Returns the string representation of the {@code int} argument.
 * <p>
 * The representation is exactly the one returned by the
 * {@code Integer.toString} method of one argument.
 *
 * @param   i   an {@code int}.
 * @return  a string representation of the {@code int} argument.
 * @see     java.lang.Integer#toString(int, int)
 */
public static String valueOf(int i) {
    return Integer.toString(i);
}

ดังนั้นพวกเขาจึงให้ผลลัพธ์ที่เหมือนกันและหนึ่งในความเป็นจริงการโทรอื่น ๆ String.valueOf มีความยืดหยุ่นมากขึ้นถ้าคุณอาจเปลี่ยนชนิดในภายหลัง

ถ้าคุณดูที่รหัสแหล่งสำหรับStringชั้นก็จริงเรียกเมื่อคุณเรียกInteger.toString()valueOf()

ที่ถูกกล่าวว่าInteger.toString()อาจจะเร็วกว่าเล็กน้อยหากวิธีการโทรไม่ได้รับการปรับให้เหมาะสมในเวลารวบรวม (ซึ่งอาจเป็น)

การดำเนินการตามString.valueOf()ที่คุณเห็นเป็นวิธีที่ง่ายที่สุดในการทำตามสัญญาที่ระบุใน API: "การแสดงนั้นเป็นสิ่งที่ส่งคืนโดยInteger.toString()วิธีการของอาร์กิวเมนต์หนึ่งข้อ"

เพื่อตอบคำถาม OPs มันเป็นเพียงตัวช่วยห่อหุ้มเพื่อให้มีการโทรอีกสายหนึ่งและเลือกสไตล์ได้และนั่นก็คือ ฉันคิดว่ามีข้อมูลที่ผิดมากมายที่นี่และสิ่งที่ดีที่สุดที่นักพัฒนา Java สามารถทำได้คือดูที่การนำไปใช้สำหรับแต่ละวิธีมันคือคลิกหนึ่งหรือสองครั้งใน IDE ใด ๆ คุณจะเห็นได้อย่างชัดเจนว่าString.valueOf(int)เป็นเพียงการเรียกร้องInteger.toString(int)ให้คุณ

ดังนั้นจึงมีความแตกต่างเป็นศูนย์อย่างแน่นอนในการที่พวกเขาทั้งสองสร้างบัฟเฟอร์ถ่านเดินผ่านตัวเลขในจำนวนนั้นคัดลอกที่เป็นสตริงใหม่และส่งกลับ (ดังนั้นแต่ละคนกำลังสร้างวัตถุ String หนึ่ง) ข้อแตกต่างเพียงอย่างเดียวคือการโทรเพิ่มเติมหนึ่งครั้ง

ดังนั้นมันจึงไม่ใช่สิ่งที่คุณโทรหานอกจากความสอดคล้องกับรหัส ในฐานะที่เป็นความคิดเห็นเกี่ยวกับโมฆะก็ต้องใช้ดั้งเดิมดังนั้นจึงไม่สามารถเป็นโมฆะ! คุณจะได้รับข้อผิดพลาดในการคอมไพล์เวลาหากคุณไม่เริ่มต้น int ที่ถูกส่งผ่าน ดังนั้นจึงไม่มีความแตกต่างในวิธีการจัดการ nulls เนื่องจากไม่มีอยู่ในกรณีนี้

คุณไม่ควรกังวลเกี่ยวกับการโทรเพิ่มนี้ที่ทำให้คุณมีปัญหาเรื่องประสิทธิภาพ หากมีค่าใช้จ่ายใด ๆ มันจะน้อยมากและควรมีความสำคัญในภาพรวมของสิ่งต่าง ๆ

อาจเป็นเหตุผลว่าทำไมทั้งสองมีอยู่เพื่อให้สามารถอ่านได้ ในบริบทของการแปลงเป็นหลายประเภทการStringโทรที่หลากหลายไปยังString.valueOf(SomeType)อาจอ่านได้ง่ายกว่าการSomeType.toStringโทรที่หลากหลาย

openion ของฉันคือ valueof () มักจะเรียกว่า tostring () สำหรับ Representaion และดังนั้นสำหรับ rpresentaion ของประเภท primtive valueof คือ generalized.and java โดยค่าเริ่มต้นไม่สนับสนุนประเภทข้อมูล object .here Integer.toString (int i) สร้างขีด จำกัด การแปลงสำหรับจำนวนเต็มเท่านั้น

ไม่มีความแตกต่างระหว่าง Integer.toString (5) และ String.valueOf (5);

เนื่องจาก String.valueOf ส่งคืน:

public static String valueOf(int i) {
    return Integer.toString(i);
}
public static String valueOf(float f) {
    return Float.toString(f);
}

ฯลฯ ..

การใช้เมธอด String.valueOf () คุณไม่ต้องกังวลเกี่ยวกับข้อมูล (ไม่ว่าจะเป็น int, long, char, char [], บูลีน, Object) คุณสามารถโทร:

• String คงที่ valueOf ()

การใช้ไวยากรณ์ String.valueOf () เพียงอย่างเดียวสามารถทำสิ่งที่คุณผ่านเป็นพารามิเตอร์ที่ถูกแปลงเป็นสตริงและส่งกลับ ..

มิฉะนั้นถ้าคุณใช้ Integer.toString (), Float.toString () เป็นต้น (เช่น SomeType.toString ()) คุณจะต้องตรวจสอบประเภทข้อมูลของพารามิเตอร์ที่คุณต้องการแปลงเป็นสตริง ดังนั้นมันจะดีกว่าที่จะใช้ String.valueOf () สำหรับการแปลงดังกล่าว

หากคุณมีอาเรย์ของคลาสอ็อบเจ็กต์ที่มีค่าต่างกันเช่น Integer, Char, Float เป็นต้นโดยใช้เมธอด String.valueOf () คุณสามารถแปลงองค์ประกอบของอาเรย์เป็นรูปแบบสตริงได้อย่างง่ายดาย ในทางตรงกันข้ามถ้าคุณต้องการใช้ SomeType.toString () ในตอนแรกคุณจะต้องรู้ว่ามีคลาสประเภทข้อมูลของพวกเขา (อาจใช้โอเปอเรเตอร์ "instanceOf") จากนั้นคุณเท่านั้นที่จะสามารถดำเนินการพิมพ์ได้

String.valueOf () วิธีการเมื่อเรียกตรงกับพารามิเตอร์ที่ผ่าน (ไม่ว่าจะเป็นจำนวนเต็ม, Char, ลอย ฯลฯ ) และโดยใช้วิธีการมากไปเรียกว่า "valueOf ()" วิธีการที่พารามิเตอร์ได้รับการจับคู่แล้วภายในวิธีการของพวกเขา การโทรโดยตรงไปยังวิธีการ "toString ()" ที่สอดคล้องกัน ..

ดังนั้นเราสามารถดูว่าค่าใช้จ่ายในการตรวจสอบประเภทข้อมูลแล้วเรียกวิธีการ "toString ()" ที่สอดคล้องกันจะถูกลบออกเท่านั้นเราต้องการที่จะเรียกวิธีการ String.valueOf () ไม่สนใจว่าสิ่งที่เราต้องการแปลงเป็นสตริง

สรุป: วิธีการ String.valueOf () มีความสำคัญเพียงค่าใช้จ่ายของการโทรอีกหนึ่ง

toString ()

1. มีอยู่ในคลาส Object โดยทั่วไปจะแทนที่ในคลาสที่ได้รับ
2. จำเป็นต้องเรียกใช้เมธอด toString ()

มูลค่าของ()

1. วิธีคงที่โอเวอร์โหลดที่มีอยู่ในคลาส String

2. จัดการประเภทดั้งเดิมเช่นเดียวกับประเภทวัตถุ

   Integer a = null;
   System.out.println(Integer.toString()) ; NUll pointer exception
   System.out.println(String.valueOf() ; give NULL as value

ตรวจสอบลิงค์นี้มันดีมาก http://code4reference.com/2013/06/which-one-is-better-valueof-or-tostring/