อาร์เรย์ใน Java

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

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

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

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

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

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

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

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

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

new typeOfArray [length];

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

int[] myArray; // array declaration
myArray = new int[10]; // creation, that is, allocation of memory for an array of 10 elements of type int

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

int[] myArray = new int[10]; // declaration and allocation of memory "in one bottle"

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

int[] myArray = new int[10];

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

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

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

int[] myArray = new int[10]; // created an array of integers with 10 elements and named it myArray
System.out.println(myArray.length); // printed to the console the length of the array, that is, the number of elements that we can put in the array

ผลลัพธ์ของโปรแกรม:

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

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

String[] seasons  = new String[4]; /* declared and created an array. Java allocated memory for an array of 4 strings, and now each cell is null (because the string is a reference type)*/

seasons[0] = "Winter"; /* in the first cell, that is, in the cell with a zero number, we wrote the string Winter. Here we get access to the zero element of the array and write a specific value there */
seasons[1] = "Spring"; // do the same procedure with cell number 1 (second)
seasons[2] = "Summer"; // ...number 2
seasons[3] = "Autumn"; // and with the last one, number 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]);
}

ดังนั้นโปรแกรมจะแสดงผลดังนี้:

อาร์เรย์ 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 แล้ว และสามารถนำมาใช้ได้อย่างถูกกฎหมาย ต่อไปนี้เป็นสามวิธีที่เป็นประโยชน์ของคลาสนี้

จัดเรียงอาร์เรย์

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

ค้นหาอาร์เรย์สำหรับองค์ประกอบที่ต้องการ

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

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

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

ตัวอย่างการเรียงลำดับ binarySearch และ toString

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

class Main {
    public static void main(String[] args) {
        int[] array = {1, 5, 4, 3, 7}; //declaring and initializing the array
        System.out.println(array);//trying to display our array on the screen without the toString method - we get a hexadecimal number
        System.out.println(Arrays.toString(array));//печатаем массив "правильно"
        Arrays.sort(array, 0, 4); // sort the entire array from zero to the fourth member
        System.out.println(Arrays.toString(array));//print the sorted array to the screen
        int key = Arrays.binarySearch(array, 5); // ищем key - число 5 в отсортированном массиве.
        //binarySearch method will return the index of the sorted array element, in which the required number is "hidden"
        System.out.println(key);//распечатываем индекс искомого числа
System.out.println(Arrays.binarySearch(array, 0));//а теперь попробуем найти число, которого в массиве нет,
        // and immediately display the result on the screen

    }
}

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

สิ่งสำคัญเกี่ยวกับอาร์เรย์

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

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

• คุณไม่สามารถเปลี่ยนความยาวของอาร์เรย์หลังจากที่ถูกสร้างขึ้นแล้ว

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

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

• หลังจากขั้นตอนการสร้างอาร์เรย์ จะถูกเติมด้วยค่าเริ่มต้น

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

เนื้อหาที่เป็นประโยชน์เกี่ยวกับอาร์เรย์

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

1. บางอย่างเกี่ยวกับอาร์เรย์ - บทความที่มีรายละเอียดดีเกี่ยวกับอาร์เรย์

2. คลาส Arrays และการใช้งาน - บทความนี้จะอธิบายวิธีการบางอย่างของ คลาส Array

3. อาร์เรย์หลายมิติ - บทความโดยละเอียดเกี่ยวกับอาร์เรย์หลายมิติพร้อมตัวอย่าง

4. ส่งคืนอาร์เรย์ที่มีความยาวเป็นศูนย์ ไม่ใช่ null - ผู้เขียนการเขียนโปรแกรมที่มีประสิทธิภาพ Joshua Bloch พูดถึงวิธีส่งคืนอาร์เรย์ว่างได้ดีขึ้น