(String) หรือ. toString ()?

ฉันมีวิธีการที่มีObject oพารามิเตอร์

ในวิธีนี้ฉันรู้ว่ามีStringใน "o" ซึ่งไม่เป็นโมฆะ ไม่จำเป็นต้องตรวจสอบหรือทำอย่างอื่น ฉันต้องปฏิบัติต่อมันเหมือนกับStringสิ่งของ

แค่อยากรู้อยากเห็น - อะไรถูกกว่า - โยนให้Stringหรือใช้Object.toString()? หรือมันเหมือนกันตามเวลา - / cpu- / mem- ราคา?

อัปเดต: วิธีนี้ยอมรับObjectเนื่องจากเป็นการใช้งานอินเทอร์เฟซ ไม่มีวิธีใดในการเปลี่ยนประเภทพารามิเตอร์

และมันไม่ได้nullเลย ฉันแค่อยากจะบอกว่าฉันไม่จำเป็นต้องตรวจสอบความว่างเปล่าหรือความว่างเปล่า ในกรณีของฉันมักจะมีสตริงที่ไม่ว่างเปล่า

การส่งไปยัง String มีราคาถูกกว่าเนื่องจากไม่จำเป็นต้องมีการเรียกใช้ฟังก์ชันภายนอกเพียงแค่ตรวจสอบประเภทภายใน

ฉันจะใช้นักแสดง ที่ตรวจสอบ "ความรู้" ของคุณว่าเป็นสตริง หากเหตุผลใดก็ตามที่คุณพบข้อผิดพลาดและมีคนส่งผ่านสิ่งอื่นที่ไม่ใช่สตริงฉันคิดว่ามันจะดีกว่าที่จะทิ้งข้อยกเว้น (ซึ่งนักแสดงจะทำ) มากกว่าที่จะดำเนินการกับข้อมูลที่มีข้อบกพร่องต่อไป

ตามการแสดงของ Silly: x.toString () vs (String) x

ในท้ายที่สุดผลลัพธ์ก็ชัดเจนอย่างน่าประหลาดใจ: อย่างน้อยสองเท่าในการส่ง Object to String เร็วกว่าการเรียก Object.toString ()

ถ้าคุณรู้ว่า Object o เป็น String ฉันจะบอกว่าแค่โยนมันเป็น String แล้วบังคับใช้แบบนั้น การเรียก toString () บนออบเจ็กต์ที่คุณรู้แน่นอนว่าเป็น String อาจเพิ่มความสับสน

ถ้า Object o เป็นอะไรก็ได้ที่ไม่ใช่ String คุณจะต้องเรียก toString ()

ฉันจะไม่กังวลกับประสิทธิภาพมากเกินไปหากการดำเนินการนี้เสร็จสิ้นแม้เพียงไม่กี่พันครั้งต่อวินาทีก็ไม่มีความแตกต่างที่จับต้องได้

อย่างไรก็ตามฉันจะกังวลเกี่ยวกับการ "รู้" ข้อมูลที่ป้อน คุณมีวิธีการที่ยอมรับObjectและคุณควรปฏิบัติเช่นนี้กล่าวคือคุณไม่ควร รู้อะไรเกี่ยวกับพารามิเตอร์นอกเหนือจากที่เป็นไปตามObjectอินเทอร์เฟซซึ่งจะมีtoString()วิธีการ ในกรณีนี้ฉันขอแนะนำอย่างยิ่งให้ใช้วิธีนั้นแทนการตั้งสมมติฐานอะไรเลย

OTOH ถ้าใส่เป็นเสมออย่างใดอย่างหนึ่ง Stringหรือnullเพียงแค่เปลี่ยนวิธีการที่จะยอมรับStrings และตรวจสอบอย่างชัดเจนสำหรับnulls (ซึ่งคุณควรจะทำยังไงเมื่อใดก็ตามที่การจัดการกับวิทยาการไม่ใช่ ... )

ระบุว่าประเภทการอ้างอิงเป็น Object และ Objects ทั้งหมดมี toString () เพียงแค่เรียก object.toString () String.toString () ส่งคืนค่านี้

• toString () คือรหัสที่จะพิมพ์น้อยกว่า
• toString () น้อยกว่า bytecode
• การหล่อเป็นการดำเนินการที่มีราคาแพง VS การเรียกหลายรูปแบบ
• นักแสดงอาจล้มเหลว
• ใช้ String.valueOf (object) ซึ่งเรียก object.toString () ถ้าไม่ใช่ null

หากสิ่งที่คุณมีใน "o" เป็นสตริงก็จะไม่มีความแตกต่างกันมากนัก (น่าจะแคสต์เร็วกว่า แต่นั่นเป็นสิ่งที่ใช้งาน VM / Library)

ถ้า "o" อาจไม่ใช่ String แต่ควรจะเป็น String ดังนั้นการแคสต์จะเป็นสิ่งที่คุณต้องการ (แต่คุณควรทำให้เมธอดใช้ String แทน Object)

ถ้า "o" เป็นประเภทใดก็ได้คุณต้องใช้ toString แต่อย่าลืมตรวจสอบค่าว่างก่อน

void foo(final Object o)
{
    final String str;

    // without this you would get a class cast exception
    // be wary of using instanceof though - it is usually the wrong thing to do
    if(o instanceof String)
    {
        str = (String)o;
    }    
}

หรือ

void foo(final Object o)
{
    final String str;

    // if you are 100% sure that o is not null then you can get rid of the else
    if(o != null)
    {
        str = o.toString();
    }
}

ฉันอยากจะเขียนโค้ดสุดท้ายเป็น:

void foo(final Object o)
{
    final String str;

    if(o == null)
    {
        throw new IllegalArgumentException("o cannot be null");
    }

    str = o.toString();
}

ฉันพบว่าแปลกที่นักแสดงช้ากว่าการค้นหา vtable โดยนัยโดยการเรียกแบบ tostring

ไม่สามารถมี 'สตริงว่างใน o' ถ้า o เป็นโมฆะจะไม่มีสตริงว่างจะเป็นเพียงค่าว่าง เพียงตรวจสอบ o เป็นค่าว่างก่อน หากคุณแคสต์หรือเรียก ToString () บน null คุณจะหยุดทำงาน