คอฟฟี่เบรค #176. ความเหมือนและความแตกต่างระหว่าง Array และ ArrayList วิธีการเขียนวิธีที่มีประสิทธิภาพเท่ากับ ()

ความเหมือนและความแตกต่างระหว่าง Array และ ArrayList

ที่มา:ปานกลาง บทความนี้มุ่งเน้นไปที่การทำความเข้าใจแนวคิดของ Array และ ArrayList และความแตกต่างระหว่างพวกเขา

อาร์เรย์จาวา

Arrayเป็นโครงสร้างข้อมูลที่ช่วยให้คุณสามารถจัดเก็บลำดับของค่าที่เป็นประเภทเดียวกันได้ ตัวอย่างเช่น คุณสามารถสร้างอาร์เรย์ของอักขระ ตัวเลข และอื่นๆ ได้ สิ่งนี้ใช้ได้กับทุกประเภทดั้งเดิมและแม้แต่วัตถุเช่นString เมื่อสร้างอาร์เรย์แล้ว เราไม่สามารถเปลี่ยนขนาดของอาร์เรย์ได้ นี่คือตัวอย่างทั่วไปของการประกาศตัวแปรอ้างอิงอาร์เรย์และการจัดสรรอาร์เรย์:

dataType[] arrayName = new dataType[numElements];

หากเราพยายามเพิ่มมากกว่าขนาดของอาร์เรย์ เราจะได้ ArrayIndexOutOfBoundsException

การประกาศอาร์เรย์

ในการประกาศอาร์เรย์ ให้ใช้ อักขระ [ ]หลังชนิดข้อมูล พวกเขาระบุว่าตัวแปรมีการอ้างอิงถึงอาร์เรย์ ตัวแปรอ้างอิงอาร์เรย์สามารถอ้างอิงถึงอาร์เรย์ขนาดต่างๆ คีย์เวิร์ดใหม่จะสร้างพื้นที่ในหน่วยความจำเพื่อจัดเก็บอาร์เรย์ตามจำนวนองค์ประกอบที่ระบุ ตัวแปรอ้างอิงอาร์เรย์ถูกกำหนดให้อ้างอิงถึงอาร์เรย์ที่จัดสรรใหม่นี้ ตัวอย่างต่อไปนี้ประกาศตัวแปรอ้างอิงอาร์เรย์gameScoresจัดสรรอาร์เรย์ที่มีจำนวนเต็มสี่จำนวน และกำหนดgameScoresเพื่ออ้างอิงถึงอาร์เรย์ที่จัดสรร

int[] gameScores = new int[4];

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

int[] gameScores;

gameScores = new int[4];

การเริ่มต้นอาร์เรย์ด้วยค่าที่ไม่ใช่ค่าเริ่มต้น

คุณสามารถเริ่มต้นองค์ประกอบอาร์เรย์ด้วยค่าที่ไม่ใช่ค่าเริ่มต้นได้โดยการระบุค่าเริ่มต้นในวงเล็บปีกกา{}คั่นด้วยเครื่องหมายจุลภาค

int [] myArray = { 5 , 7 , 11 };

ตัวอย่างด้านบนสร้างอาร์เรย์ขององค์ประกอบจำนวนเต็มสามองค์ประกอบที่มีค่า 5, 7 และ 11 การเริ่มต้นอาร์เรย์นี้ไม่จำเป็นต้องใช้ คีย์เวิร์ดใหม่เนื่องจากขนาดของอาร์เรย์จะถูกตั้งค่าโดยอัตโนมัติตามจำนวนองค์ประกอบใน วงเล็บปีกกา สำหรับอาร์เรย์ขนาดใหญ่ การเริ่มต้นสามารถทำได้โดยการกำหนดอาร์เรย์ก่อน จากนั้นจึงใช้การวนซ้ำเพื่อกำหนดองค์ประกอบของอาร์เรย์ องค์ประกอบอาร์เรย์สามารถเข้าถึงได้โดยใช้ดัชนีแบบศูนย์

Int[ ] intArray = new int [ ] {2};
intArray [0] = 1;
intArray [1] = 2;

ArrayList

ArrayListคือรายการเรียงลำดับขององค์ประกอบ ประเภทการอ้างอิง ที่ปรับขนาดได้ นอกจากนี้ยังเป็นคลาสจาก แพ็คเกจ java.utilที่เป็นของ Java Collection Framework ArrayListให้อาร์เรย์แบบไดนามิกแก่เราและจัดการการปรับขนาดโดยอัตโนมัติ เมื่อคุณเพิ่มองค์ประกอบลงใน ArrayList ขนาดหน่วยความจำจะเพิ่มขึ้นโดยอัตโนมัติ คุณสามารถ ใช้ArrayListโดยใช้การนำเข้า java.util.ArrayList; . นอกจากนี้เรายังสามารถสร้าง อินสแตนซ์ ArrayListโดยใช้คำสั่งต่อไปนี้:

ArrayList<Type> arrayList = new ArrayList<Type>();

ArrayList สามารถขยาย ขนาดเพื่อรองรับองค์ประกอบที่ต้องการได้ ArrayList ไม่รองรับ ประเภทดั้งเดิม เช่นintแต่สนับสนุนประเภทการอ้างอิง เช่นInteger ข้อผิดพลาดทั่วไปใน หมู่ผู้เริ่มต้นคือการประกาศArrayListประเภทดั้งเดิม เช่นintดังเช่นในArrayList<int> myVals ซึ่งส่งผลให้เกิดข้อผิดพลาดในการคอมไพล์: “ประเภทที่ไม่คาดคิด, พบ : int, จำเป็น: การอ้างอิง” ตัวอย่าง: มาสร้าง วัตถุ ArrayListชื่อcarsซึ่งจะเก็บสตริง:

import java.util.ArrayList;

ArrayList<String> cars = new ArrayList<String>();

หากต้องการเพิ่มองค์ประกอบให้กับArrayListให้ใช้ เมธอด add() ในการเข้าถึงองค์ประกอบของArrayList จะ ใช้เมธอด get ()

cars.add("Tesla");
cars.add("BMW");
cars.add("Kia");
cars.get(0);

ความแตกต่างระหว่างอาร์เรย์ในตัวและArrayListใน Java คือในกรณีแรก ขนาดของอาร์เรย์ไม่สามารถเปลี่ยนแปลงได้ (หากคุณต้องการเพิ่มหรือลบองค์ประกอบเข้า/ออกจากอาร์เรย์ คุณต้องสร้างองค์ประกอบใหม่ ). ในขณะที่ArrayListสามารถเพิ่มและลบองค์ประกอบได้ตลอดเวลา

ความคล้ายคลึงกันระหว่างอาร์เรย์และ ArrayList

• ArrayและArrayListใช้เพื่อจัดเก็บองค์ประกอบ
• ArrayและArrayListสามารถเก็บค่า Null ได้
• กระบวนการทั้งสองเกิดขึ้นในเวลาคงที่
• อาจมีค่าซ้ำกัน
• ArrayและArrayListไม่รับประกันการมีอยู่ขององค์ประกอบที่เรียงลำดับ

ความแตกต่างที่สำคัญระหว่างอาร์เรย์และ ArrayList

ความแตกต่างที่สำคัญระหว่างอาร์เรย์ ( Array ) และArrayListคือลักษณะคงที่ของอาร์เรย์และลักษณะไดนามิกของArrayList เมื่อสร้างแล้ว คุณจะไม่สามารถเปลี่ยนขนาดของอาร์เรย์ได้ ในขณะที่ArrayListสามารถเปลี่ยนขนาดได้ตามต้องการ ข้อแตกต่างที่สำคัญอีกประการหนึ่งคืออาร์เรย์เป็นฟังก์ชันพื้นฐานที่ Java มีให้ ในทางกลับกันArrayListเป็นส่วนหนึ่งของเฟรมเวิร์กคอลเลกชันใน Java เราสามารถเข้าถึงองค์ประกอบของอาร์เรย์ได้โดยใช้วงเล็บเหลี่ยมซึ่งเราสามารถระบุดัชนีได้ ในขณะที่มีชุดวิธีในการเข้าถึงองค์ประกอบของ ArrayListและทำการเปลี่ยนแปลง แม้จะต่างกันแต่ก็เทียบเคียงในด้านอื่นได้ โครงสร้างข้อมูลทั้งสองนี้ใน Java อิงตามดัชนีและอนุญาตให้คุณจัดเก็บอ็อบเจ็กต์ได้ นอกจากนี้ยังอนุญาตค่าว่างและการซ้ำซ้อน หากคุณทราบขนาดของวัตถุล่วงหน้า ควรใช้อาร์เรย์จะดีกว่า แต่ถ้าคุณไม่แน่ใจเกี่ยวกับขนาด คุณ ควร ใช้ ArrayListแทน

วิธีการเขียนวิธีที่มีประสิทธิภาพเท่ากับ ()

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

คุณสมบัติของวิธีเท่ากับ

แต่ละ วิธีเท่ากับใช้ความสัมพันธ์ที่เท่าเทียมกัน มันมีคุณสมบัติดังต่อไปนี้:

• Reflexive : สำหรับค่าอ้างอิงที่ไม่ใช่ค่าว่างใดๆ x นั้น x.equals (x)จะต้องคืนค่า true

• สมมาตร : สำหรับค่าอ้างอิงที่ไม่ใช่ค่าว่างใดๆxและ y , x.equals ( y)จะต้องคืนค่าจริงก็ต่อเมื่อ y.equals(x)คืนค่าจริง

• สกรรมกริยา : สำหรับค่าอ้างอิงใดๆ ที่ไม่ใช่ค่าว่าง x , y , zถ้า x.equals(y)ส่งคืน trueและ y.equals(z)ส่งคืน trueดังนั้น x.equals(z)จะต้องส่งคืน true ด้วย

• สอดคล้องกัน : สำหรับค่าอ้างอิงที่ไม่ใช่ค่าว่างใดๆ xและ y การเรียก x.equals(y)หลายครั้งจะต้องคืนค่าจริงอย่างหรือคืนค่าเท็จ อย่างสม่ำเสมอ

• ไม่เป็นโมฆะ : สำหรับค่า อ้างอิงที่ไม่ใช่ null ใดๆ x นั้น x.equals (null)จะต้องส่งคืน false

มาดูทรัพย์สินแต่ละอย่างกันดีกว่า:

การสะท้อนกลับ:

วัตถุจะต้องเท่ากับตัวมันเอง หากต้องการยืนยัน ให้เพิ่มอินสแตนซ์ของชั้นเรียนของคุณลงในคอลเล็กชัน วิธีการบรรจุอาจบ่งชี้ได้ดีว่าคอลเลกชันไม่มีอินสแตนซ์ที่คุณเพิ่งเพิ่ม

สมมาตร:

วัตถุสองชิ้น (อาจมาจากคลาสที่แตกต่างกัน) จะต้องเท่ากัน

ลำดับต่อมา:

อย่าเขียน วิธี เท่าเทียมกันซึ่งขึ้นอยู่กับทรัพยากรที่ไม่น่าเชื่อถือ/ผันผวน

ไม่ใช่ศูนย์:

คืนค่า เป็นจริงเสมอหากวัตถุที่ส่งผ่านไปยัง เท่ากับเป็นโมฆะ

สรุป:

ต่อไปนี้เป็นสูตรสำหรับ วิธี คุณภาพ เท่ากับ :

1. ใช้ ตัวดำเนินการ ==เพื่อทดสอบว่าอาร์กิวเมนต์มีการอ้างอิงถึงวัตถุนี้หรือไม่

2. ใช้ ตัวดำเนินการ instanceofเพื่อตรวจสอบว่าอาร์กิวเมนต์มีประเภทที่ถูกต้องหรือไม่

3. โยนข้อโต้แย้งให้เป็นประเภทที่ถูกต้อง

4. สำหรับแต่ละฟิลด์ "สำคัญ" ในคลาส ให้ตรวจสอบว่าฟิลด์อาร์กิวเมนต์นั้นตรงกับฟิลด์ที่สอดคล้องกันของวัตถุนั้นหรือไม่:

   • สำหรับฟิลด์ดั้งเดิม:ซึ่งประเภทไม่ใช่floatหรือdoubleให้ใช้ ตัวดำเนินการ ==เพื่อการเปรียบเทียบ
   • สำหรับฟิลด์การอ้างอิงวัตถุ:เรียกใช้เมธอดเท่ากับแบบเรียกซ้ำ สำหรับฟิลด์จุดลอยตัวให้ใช้วิธีคงที่Float.compare(float, float); และสำหรับฟิลด์คู่ให้ใช้Double.compare(double, double )
   • สำหรับช่องอาร์เรย์:ใช้หลักเกณฑ์เหล่านี้กับแต่ละองค์ประกอบ หากทุกองค์ประกอบในช่องอาร์เรย์มีความสำคัญ ให้ใช้ วิธี Arrays.equals() วิธีใดวิธี หนึ่ง
   • ช่องอ้างอิงออบเจ็กต์บางช่องอาจ มี ค่าว่าง เพื่อหลีกเลี่ยงการโยนNullPointerException ให้ตรวจสอบฟิลด์ดังกล่าวเพื่อความ เท่าเทียมกันโดยใช้วิธีคงที่Objects.equals(Object, Object)

5. เมื่อคุณเขียน วิธี เท่ากับ เสร็จแล้ว ให้ถามตัวเองสามคำถาม: มันสมมาตรหรือไม่? มันเป็นสกรรมกริยา? เขาสม่ำเสมอไหม?

และจำไว้ว่าให้แทนที่hashCode เสมอ เมื่อแทนที่ เท่ากับ