อาร์เรย์ในภาษาจาวา

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

อาร์เรย์คืออะไร?

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

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

คุณจะประกาศอาร์เรย์ได้อย่างไร?

เช่นเดียวกับตัวแปรใดๆ อาร์เรย์จะต้องถูกประกาศในภาษาจาวา สามารถทำได้ด้วยวิธีใดวิธีหนึ่งจากสองวิธี พวกมันเทียบเท่ากัน แต่วิธีแรกนั้นสอดคล้องกับสไตล์ Java มากกว่า ประการที่สองเป็นมรดกของภาษา C: โปรแกรมเมอร์ C จำนวนมากเปลี่ยนไปใช้ Java และใช้วิธีอื่นเพื่อความสะดวก ตารางแสดงวิธีการประกาศอาร์เรย์ใน Java ทั้งสองวิธี: ในทั้งสองกรณีdataTypeคือประเภทของตัวแปรในอาร์เรย์ ในตัวอย่าง เราประกาศสองอาร์เรย์ หนึ่งจะเก็บint s และอื่น ๆ - วัตถุวัตถุ ดังนั้น การประกาศอาร์เรย์จึงมีชื่อและประเภท (ประเภทขององค์ประกอบของอาร์เรย์) ArrayNameคือชื่อของอาร์เรย์

การสร้างอาร์เรย์

คุณจะสร้างอาร์เรย์ได้อย่างไร?

เช่นเดียวกับอ็อบเจกต์อื่นๆ คุณสามารถสร้างอาร์เรย์ Java เช่น จองพื้นที่ในหน่วยความจำโดยใช้โอเปอเรเตอร์ใหม่ นี่คือวิธีการ:

new typeOfArray[length]; 

โดยที่typeOfArrayคือประเภทของอาร์เรย์และความยาวคือความยาว (เช่น จำนวนเซลล์) ที่แสดงเป็นจำนวนเต็ม ( int) แต่โปรดทราบว่าที่นี่เราจัดสรรหน่วยความจำสำหรับอาร์เรย์เท่านั้น — เราไม่ได้เชื่อมโยงอาร์เรย์ที่ประกาศกับตัวแปรที่ประกาศไว้ก่อนหน้านี้ โดยปกติ อาร์เรย์จะถูกประกาศก่อนแล้วจึงสร้างอินสแตนซ์ ตัวอย่างเช่น

int[] myArray; // Array declaration
myArray = new int[10]; // Create (allocate memory for) an array of 10 ints

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

int[] myArray = new int [10]; // Declare the array and allocate memory "in one blow"

โปรดทราบ:หลังจากสร้างอาร์เรย์โดยใช้ ตัวดำเนินการ ใหม่แล้ว เซลล์ของอาร์เรย์จะมีค่าเริ่มต้น สำหรับประเภทตัวเลข (ตามตัวอย่างของเรา) ค่าเริ่มต้นคือ 0 สำหรับประเภทบูลีนจะเป็นเท็จและสำหรับประเภทอ้างอิง จะเป็นnull ดังนั้นหลังจากดำเนินการตามคำสั่งนี้

int[] myArray = new int[10];

เราได้รับอาร์เรย์ของจำนวนเต็มสิบ และจนกว่าโปรแกรมจะทำบางสิ่งเพื่อเปลี่ยนแปลงค่า แต่ละเซลล์จะมี 0

ความยาวอาร์เรย์ใน Java

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

int[] myArray = new int[10]; // Create an int array for 10 elements and name it myArray
System.out.println(myArray.length); // Display the array's length, i.e. the number of elements we can put into the array

เอาท์พุต:

10

การเริ่มต้นอาร์เรย์และการเข้าถึงองค์ประกอบ

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

String[] seasons = new String[4]; /* Declare and create an array. Java allocates memory for an array of 4 strings, and each cell is set to null (since String is a reference type) */ 

seasons[0] = "Winter"; /* We set the first cell, i.e. the cell with index zero, to "Winter". Here we access the zeroth element of the array and write a specific value to it. */ 
seasons[1] = "Spring"; // We follow a similar procedure for the cell with index 1 (the second cell)
seasons[2] = "Summer"; // ... index 2
seasons[3] = "Autumn"; // and finally, index 3

ตอนนี้ชื่อของฤดูกาลถูกเขียนลงในเซลล์ทั้งสี่ของอาร์เรย์ของเรา เราสามารถเริ่มต้นอาร์เรย์ได้ด้วยวิธีอื่น โดยรวมการประกาศและการเริ่มต้น:

String[] seasons = new String[] {"Winter", "Spring", "Summer", "Autumn"};

นอกจากนี้ ยังสามารถละเว้นโอเปอเรเตอร์ ใหม่ ได้:

String[] seasons = {"Winter", "Spring", "Summer", "Autumn"};

คุณแสดงอาร์เรย์บนหน้าจอใน Java ได้อย่างไร

คุณสามารถแสดงองค์ประกอบอาร์เรย์บนหน้าจอ (เช่น บนคอนโซล) โดยใช้for loop อีกวิธีที่สั้นกว่าในการแสดงอาร์เรย์จะกล่าวถึงในย่อหน้าชื่อ " วิธีการที่เป็นประโยชน์สำหรับการทำงานกับอาร์เรย์ " ในระหว่างนี้ ให้ดูตัวอย่างที่แสดงอาร์เรย์โดยใช้ลูป:

String[] seasons = new String {"Winter", "Spring", "Summer", "Autumn"}; 
for (int i = 0; i < 4; i++) {
System.out.println(seasons[i]); 
}

โปรแกรมจะแสดงสิ่งต่อไปนี้:

Winter 
Spring 
Summer 
Autumn

อาร์เรย์หนึ่งมิติและหลายมิติใน Java

แต่ถ้าเราต้องการสร้างไม่ใช่อาร์เรย์ของตัวเลข สตริง หรือวัตถุอื่นๆ แต่เป็นอาร์เรย์ของอาร์เรย์ล่ะ Java ให้คุณทำสิ่งนี้ ประเภทของอาร์เรย์ที่เราคุ้นเคย ( int[] myArray = new int[8] ) เรียกว่าอาร์เรย์หนึ่งมิติ แต่อาร์เรย์ของอาร์เรย์เรียกว่าอาร์เรย์สองมิติ เหมือนกับตารางที่มีหมายเลขแถวและหมายเลขคอลัมน์ หรือถ้าคุณได้เรียนรู้พื้นฐานของพีชคณิตเชิงเส้นแล้ว คุณก็สามารถคิดว่ามันเป็นเมทริกซ์ได้ ทำไมเราต้องการอาร์เรย์ดังกล่าว เพื่อโปรแกรมเมทริกซ์และตารางรวมถึงวัตถุอื่น ๆ ที่มีโครงสร้างคล้ายกัน ตัวอย่างเช่น กระดานหมากรุกสามารถแสดงด้วยอาร์เรย์ขนาด 8x8 มีการประกาศและสร้างอาร์เรย์หลายมิติดังนี้:

Int[][] myTwoDimentionalArray = new int[8][8];

อาร์เรย์นี้มีทั้งหมด 64 องค์ประกอบ: myTwoDimentionalArray[0][0] , myTwoDimentionalArray[0][1] , myTwoDimentionalArray[1][0] , myTwoDimentionalArray[1][1]และอื่นๆ จนถึงmyTwoDimentionalArray[7][7] . ดังนั้น ถ้าเราใช้มันแทนกระดานหมากรุก A1 จะตรงกับmyTwoDimentionalArray[0][0]และ E2 จะตรงกับmyTwoDimentionalArray[4][1 ] แต่เราจะผลักดันสิ่งนี้ไปได้ไกลแค่ไหน? ใน Java คุณสามารถระบุอาร์เรย์ของอาร์เรย์... อาร์เรย์ของอาร์เรย์ของอาร์เรย์ และอื่นๆ แน่นอนว่ามีการใช้อาร์เรย์สามมิติและมิติที่สูงกว่าน้อยมาก ที่กล่าวว่า คุณสามารถใช้อาร์เรย์สามมิติเพื่อตั้งโปรแกรมลูกบาศก์ของรูบิค เป็นต้น

วิธีการที่เป็นประโยชน์สำหรับการทำงานกับอาร์เรย์

Java มี คลาส java.util.Arraysสำหรับทำงานกับอาร์เรย์ โดยทั่วไป การดำเนินการทั่วไปส่วนใหญ่ที่ดำเนินการกับอาร์เรย์ ได้แก่ การเริ่มต้น (การเติมองค์ประกอบ) การดึงข้อมูลองค์ประกอบ (ตามดัชนี) การเรียงลำดับ และการค้นหา การค้นหาและการจัดเรียงอาร์เรย์เป็นหัวข้อสำหรับวันอื่น ในแง่หนึ่ง การเขียนอัลกอริทึมการค้นหาและการเรียงลำดับหลายรายการด้วยตนเองถือเป็นแนวทางปฏิบัติที่ดี ในทางกลับกัน อัลกอริธึมที่ดีที่สุดทั้งหมดได้ถูกนำมาใช้แล้วและรวมอยู่ในไลบรารี Java มาตรฐาน และคุณสามารถใช้งานได้อย่างถูกกฎหมาย ต่อไปนี้คือสามวิธีที่มีประโยชน์ในชั้นเรียนนี้

การเรียงลำดับอาร์เรย์

โมฆะsort(int[] myArray, int fromIndex, int toIndex)วิธีการเรียงลำดับอาร์เรย์จำนวนเต็มหรือ subarray จากน้อยไปหามาก

ค้นหาองค์ประกอบในอาร์เรย์

int binarySearch(int[] myArray, int fromIndex, int toIndex, int คีย์ ) วิธี นี้ค้นหา องค์ประกอบ หลักใน อาร์เรย์ myArrayหรือ subarray ที่เรียงลำดับ จาก fromIndexถึงtoIndex หากพบรายการก็จะส่งคืนดัชนี มิฉะนั้นจะส่งกลับ(-fromIndex) -1

การแปลงอาร์เรย์เป็นสตริง

เมธอด String toString(int[] myArray)แปลงอาร์เรย์เป็นสตริง ใน Java อาร์เรย์จะไม่แทนที่toString( ) ซึ่งหมายความว่าหากคุณพยายามแสดงอาร์เรย์ทั้งหมดพร้อมกัน(System.out.println(myArray))แทนที่จะแสดงทีละองค์ประกอบดังในย่อหน้าชื่อ " แสดงอาร์เรย์บนหน้าจอ " คุณจะได้รับ ชื่อของคลาสและแฮชเลขฐานสิบหกของอาร์เรย์ (กำหนดโดยObject.toString() ) หากคุณเป็นมือใหม่ คุณอาจไม่เข้าใจคำอธิบายเกี่ยวกับเมธอดtoString ในขั้นต้น คุณไม่จำเป็นต้องทำ แต่การใช้วิธีนี้จะทำให้แสดงอาร์เรย์ได้ง่ายขึ้น Java ช่วยให้คุณแสดงอาร์เรย์โดยไม่ต้องใช้การวนซ้ำ ตัวอย่างด้านล่างแสดงให้เห็นสิ่งนี้

ตัวอย่างการใช้ sort, binarySearch และ toString

มาสร้างอาร์เรย์ของจำนวนเต็ม แสดงโดยใช้toStringจัดเรียงด้วย วิธี sortแล้วหาตัวเลขในนั้น

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; // Declare and initialize the array
        System.out.println(array); // Try to display our array without using the toString method — the result is a hexadecimal number
        System.out.println(Arrays.toString(array)); // Display the array correctly 
        Arrays.sort(array, 0, 4); // Sort the entire array from the zeroth to the fourth element
        System.out.println(Arrays.toString(array)); // Display the sorted array
        int key = Arrays.binarySearch(array, 5); // Look for the number 5 in the sorted array. 
        // The binarySearch method will return the index of the array element we are searching for
        System.out.println(key); // Display the index of the number we searched for 
System.out.println(Arrays.binarySearch(array, 0)); // Now try to find a number that isn't in the array, 
        // and immediately display the result

    }
}

เอาท์พุต:

[I@1540e19d 
[1, 5, 4, 3, 7] 
[1, 3, 4, 5, 7] 
3 
-1

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

สรุปอาร์เรย์

• ลักษณะที่สำคัญของอาร์เรย์: ประเภทของข้อมูลที่อยู่ในนั้น ชื่อและความยาวของอาร์เรย์
  คุณสมบัติสุดท้ายถูกกำหนดเมื่อสร้างอาร์เรย์ (เมื่อจัดสรรหน่วยความจำสำหรับอาร์เรย์) คุณสมบัติสองข้อแรกถูกกำหนดเมื่อมีการประกาศอาร์เรย์

• ขนาดอาร์เรย์ (จำนวนเซลล์) ต้องเป็นint

• เป็นไปไม่ได้ที่จะเปลี่ยนความยาวของอาร์เรย์หลังจากสร้างแล้ว

• องค์ประกอบอาร์เรย์สามารถเข้าถึงได้โดยดัชนี

• องค์ประกอบในอาร์เรย์ เช่นเดียวกับสิ่งอื่นๆ ใน Java มีหมายเลขเริ่มต้นจากศูนย์

• หลังจากสร้างอาร์เรย์แล้ว อาร์เรย์จะเต็มไปด้วยค่าเริ่มต้น

• อาร์เรย์ใน Java ไม่เหมือนกับอาร์เรย์ใน C++ มันเกือบจะเหมือนตัวชี้ไปยังอาร์เรย์แบบไดนามิก

วัสดุที่เป็นประโยชน์เกี่ยวกับอาร์เรย์

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