สำนวนภาษาจาวา
1. วงจร
ในลูปที่สำคัญ ให้ยกเลิกการเรียกใช้เมธอดเมื่อพิจารณาการยุติลูป
ตัวอย่างเช่น: จะ
สำหรับ(int i=0; i<collection.size();i++){ ... }
แทนที่ด้วย...
for(int i=0; n=collection.size();i<n;i++){...}
โดยปกติแล้ว ให้ย้ายรายการที่ไม่เกี่ยวข้องกับดัชนีลูปไปนอกลูป
สำหรับ (int i=0; เทอร์มินัล=x.length;i<เทอร์มินัล;i++){x[i] = x[i]/scaleA *scaleB;}
มันควรจะเป็น:
สเกลคู่ = scaleB*scaleA;for(int i=0; terminal=x.length;i<terminal;i++){x[i] = x[i]/scale;}
2. เชือก
กำจัดการต่อสตริง
เมื่อสร้างสตริงแบบยาว ให้ใช้ StringBuffter แทน String เสมอ
จัดสรรพื้นที่ StringBuffer ล่วงหน้า StringBuffer sb = StringBuffer ใหม่ (5000);
3. ชนิดข้อมูลพื้นฐาน
ใช้ประเภทข้อมูลพื้นฐานในลูปที่สำคัญ (ข้อมูล int มักจะเร็วกว่าข้อมูลแบบยาว/สองเท่า)
คลาสการตัดประเภทข้อมูลพื้นฐาน (บูลีน, จำนวนเต็ม ฯลฯ ) ส่วนใหญ่จะถูกใช้เมื่อพารามิเตอร์วิธีการส่งผ่านจะต้องอ้างอิงถึงออบเจ็กต์ (แทนที่จะเป็นประเภทข้อมูลพื้นฐาน)
ใช้ตัวแก้ไขขั้นสุดท้ายแบบคงที่กับนิพจน์พีชคณิตคงที่ทั้งหมดเพื่อให้การอ้างอิงค่าคงที่ง่ายขึ้น (คอมไพลเลอร์คำนวณนิพจน์คงที่ล่วงหน้า)
4. ผิดปกติ
ข้อยกเว้นจะใช้เฉพาะสำหรับเงื่อนไขข้อผิดพลาดจริงเดียวเท่านั้น เช่น การโยนข้อยกเว้นและการดำเนินการบล็อก catch มีราคาแพง (สาเหตุหลักมาจากการได้รับสแน็ปช็อตของเธรดสแต็กเมื่อสร้างข้อยกเว้น)
ข้อยกเว้นจะเกิดขึ้นเฉพาะเมื่อเงื่อนไขเป็นข้อยกเว้นอย่างแท้จริง หากต้องการส่งข้อยกเว้น คุณจะต้องสร้างออบเจ็กต์ใหม่ก่อน
ตัวสร้างของอินเทอร์เฟซ Throwable เรียกวิธีการดั้งเดิมที่ชื่อว่า fillInStackTrace() วิธีการ fillInStackTrace() จะตรวจสอบสแต็กและรวบรวมข้อมูลการติดตามการโทร
เมื่อใดก็ตามที่มีข้อยกเว้นเกิดขึ้น VM จะต้องปรับ call stack เนื่องจากมีการสร้างออบเจ็กต์ใหม่ในระหว่างการประมวลผล
ข้อยกเว้นควรใช้สำหรับการจัดการข้อผิดพลาดเท่านั้น และไม่ควรใช้เพื่อควบคุมโฟลว์ของโปรแกรม
ทำการเพิ่มประสิทธิภาพคอมไพลเลอร์และรันไทม์โดยวางการเรียกใช้เมธอดหลายวิธีในบล็อก try/catch แทนที่จะใช้บล็อก try/catch หลายบล็อกสำหรับการเรียกใช้เมธอดแต่ละครั้ง
ลอง { Some.method1(); // Difficut สำหรับ java1.4 }catch(method1Exception e){ จัดการข้อยกเว้น
1 // เพื่อเพิ่มประสิทธิภาพโค้ดนี้ } ลอง { Some.method2(); // ปัญหาสำหรับ java1.4 }catch(method2Exception e){ จัดการข้อยกเว้น
2 // เพื่อเพิ่มประสิทธิภาพโค้ดนี้ } ลอง { Some.method3(); // ปัญหาสำหรับ java1.4 }catch(method3Exception e){ จัดการข้อยกเว้น
3 // เพื่อเพิ่มประสิทธิภาพโค้ดนี้
-
ควรเขียนเป็น:
ลอง { Some.method1(); Some.method2(); Some.method3(); // Difficut สำหรับ java1.4 }catch(method1Exception e){ จัดการข้อยกเว้น 1 }catch(method2Exception e){ จัดการข้อยกเว้น 2 }catch( method3Exception e){ จัดการข้อยกเว้น 3 }
5. เกณฑ์มาตรฐาน
โปรดทราบว่าเคล็ดลับทั้งหมดเหล่านี้จะแตกต่างกันไปตามแพลตฟอร์มและเครื่องเสมือน
ตัวอย่างเช่น: ในคอนเทนเนอร์เซิร์ฟเล็ตบางตัว จะเร็วกว่าในการส่งออกไบต์ผ่าน OutputStream
2. ในคอนเทนเนอร์อื่นๆ จะแสดงผลอักขระผ่าน PrintWriter ได้เร็วกว่า
เคล็ดลับเหล่านี้อธิบายคำแนะนำแบบพกพาได้มากที่สุด
คุณอาจจำเป็นต้องเรียกใช้การวัดประสิทธิภาพเพื่อพิจารณาว่าอะไรเร็วที่สุดบนแพลตฟอร์มของคุณ
6. สร้างอินสแตนซ์ของคลาสโดยไม่ต้องใช้คีย์เวิร์ดใหม่
เมื่อคุณสร้างอินสแตนซ์ของคลาสโดยใช้คีย์เวิร์ดใหม่ ตัวสร้างทั้งหมดในห่วงโซ่ตัวสร้างจะถูกเรียกโดยอัตโนมัติ
แต่ถ้าวัตถุใช้อินเทอร์เฟซ Cloneable เราก็สามารถเรียกเมธอด clone() ของมันได้ เมธอด clone() ไม่ได้เรียกตัวสร้างคลาสใดๆ
เมื่อใช้รูปแบบการออกแบบ หากคุณใช้โหมดโรงงานเพื่อสร้างออบเจ็กต์ การใช้เมธอด clone() เพื่อสร้างอินสแตนซ์ออบเจ็กต์ใหม่นั้นง่ายมาก
ตัวอย่างเช่น ต่อไปนี้คือการใช้งานทั่วไปของรูปแบบ Factory:
เครดิตสาธารณะ getNewCredit() { คืนเครดิตใหม่ ();
หลังจากการเพิ่มประสิทธิภาพ:
BaseCredit เครดิตคงที่ส่วนตัว = เครดิตใหม่ (); เครดิตสาธารณะคงที่ getNewCredit () { ผลตอบแทน (เครดิต) BaseCredit.clone ();}
แนวคิดข้างต้นยังมีประโยชน์สำหรับการประมวลผลอาเรย์อีกด้วย
7. ใช้ I/O ที่ไม่ปิดกั้น
JDK ที่มีเวอร์ชัน Java ต่ำกว่าไม่รองรับ I/O API ที่ไม่บล็อก เพื่อหลีกเลี่ยงการบล็อก I/O แอปพลิเคชันบางตัวจะสร้างเธรดจำนวนมาก (ในกรณีที่ดีกว่า จะใช้พูลบัฟเฟอร์) เทคนิคนี้สามารถเห็นได้ในแอปพลิเคชันจำนวนมากที่ต้องรองรับสตรีม I/O พร้อมกัน เช่น เว็บเซิร์ฟเวอร์ แอปพลิเคชันใบเสนอราคาและการประมูล เป็นต้น อย่างไรก็ตาม การสร้างเธรด Java ต้องใช้ค่าใช้จ่ายจำนวนมาก
JDK 1.4 เปิดตัวไลบรารี I/O ที่ไม่ปิดกั้น (java.nio) หากแอปพลิเคชันของคุณต้องการ JDK เวอร์ชันเก่า แสดงว่ามีแพ็คเกจที่รองรับ I/O แบบไม่บล็อก
8. อย่าเริ่มต้นตัวแปรซ้ำๆ
ตามค่าเริ่มต้น เมื่อเรียก Constructor ของคลาส Java จะเริ่มต้นตัวแปรให้เป็นค่าที่กำหนด: อ็อบเจ็กต์ทั้งหมดถูกกำหนดเป็น null ตัวแปรจำนวนเต็ม (ไบต์, แบบสั้น, int, ยาว) ถูกกำหนดเป็น 0 และตัวแปร float และ double ถูกกำหนดเป็น 0.0 ค่าตรรกะถูกตั้งค่าเป็นเท็จ
สิ่งนี้ควรสังเกตเป็นพิเศษเมื่อคลาสได้รับมาจากคลาสอื่น เนื่องจากเมื่อวัตถุถูกสร้างขึ้นโดยใช้คีย์เวิร์ดใหม่ ตัวสร้างทั้งหมดในสายตัวสร้างจะถูกเรียกโดยอัตโนมัติ
9. พยายามระบุตัวแก้ไขสุดท้ายของคลาส
คลาสที่มีตัวแก้ไขขั้นสุดท้ายจะไม่ได้รับมา ใน Java core API มีตัวอย่างมากมายของการใช้ขั้นสุดท้าย เช่น java.lang.String การระบุขั้นสุดท้ายสำหรับคลาส String จะป้องกันไม่ให้ผู้คนแทนที่เมธอด length()
นอกจากนี้ หากชั้นเรียนถูกกำหนดให้เป็นที่สิ้นสุด วิธีการทั้งหมดของชั้นเรียนจะถือเป็นที่สิ้นสุด คอมไพเลอร์ Java จะมองหาโอกาสในการอินไลน์วิธีการสุดท้ายทั้งหมด (ขึ้นอยู่กับการใช้งานคอมไพเลอร์เฉพาะ) สิ่งนี้สามารถปรับปรุงประสิทธิภาพได้โดยเฉลี่ย 50%
10. ใช้ตัวแปรท้องถิ่นทุกครั้งที่เป็นไปได้
พารามิเตอร์ที่ส่งผ่านเมื่อเรียกใช้เมธอดและตัวแปรชั่วคราวที่สร้างขึ้นระหว่างการโทรจะถูกบันทึกไว้ในสแต็ก (สแต็ก) ซึ่งเร็วกว่า ตัวแปรอื่นๆ เช่น ตัวแปรคงที่ ตัวแปรอินสแตนซ์ ฯลฯ จะถูกสร้างขึ้นในฮีปและทำงานช้ากว่า นอกจากนี้ ขึ้นอยู่กับคอมไพเลอร์/JVM เฉพาะ ตัวแปรโลคัลอาจได้รับการปรับให้เหมาะสมเพิ่มเติม ดูใช้ตัวแปรสแต็กทุกที่ที่เป็นไปได้
11. การคูณและการหาร
พิจารณารหัสต่อไปนี้:
สำหรับ (val = 0; val < 100,000; val +=5) { alterX = val * 8; myResult = val * 2;
หลังจากการเพิ่มประสิทธิภาพ:
สำหรับ (val = 0; val < 100,000; val += 5) { alterX = val << 3; myResult = val << 1;
รหัสที่แก้ไขจะไม่ดำเนินการคูณด้วย 8 อีกต่อไป แต่จะใช้การดำเนินการที่เทียบเท่ากับการเลื่อน 3 บิตไปทางซ้ายแทน ในทำนองเดียวกัน การดำเนินการเลื่อนไปทางขวา 1 บิตจะเทียบเท่ากับการหารด้วย 2 เป็นที่น่าสังเกตว่าถึงแม้ว่าการดำเนินการกะจะรวดเร็ว แต่ก็อาจทำให้โค้ดเข้าใจยากขึ้น ดังนั้นจึงเป็นการดีที่สุดที่จะเพิ่มความคิดเห็น
BaseCredit เครดิตส่วนตัวคงที่ = เครดิตใหม่ (); เครดิตสาธารณะคงที่ getNewCredit () { ผลตอบแทน (เครดิต) BaseCredit.clone ();}