វិធីចាប់ផ្តើមអារេនៅក្នុងចាវ៉ា



អារេ កោះជ្វា

វិធីចាប់ផ្តើមអារេនៅក្នុងចាវ៉ា

អារេនៅក្នុងចាវ៉ាគឺជារចនាសម្ព័ន្ធទិន្នន័យដែលត្រូវបានប្រើយ៉ាងទូលំទូលាយបំផុតដែលផ្ទុកតម្លៃច្រើនប្រភេទនៃប្រភេទទិន្នន័យដូចគ្នាតាមលំដាប់លំដោយ។ អារេមានប្រវែងថេរហើយសន្ទស្សន៍ចាប់ផ្តើមពី 0 ដល់ n-1 ដែល n ជាប្រវែងនៃអារេ។ យើងអាចប្រើថ្នាក់អារេនៅក្នុងចាវ៉ាដើម្បីរក្សាទុកប្រភេទនៃតម្លៃណាមួយដូចជាខ្សែអក្សរលេខគត់តួអក្សរបៃនិងសូម្បីតែវត្ថុដែលកំណត់ដោយអ្នកប្រើប្រាស់។ យើងនឹងរៀនពីរបៀបចាប់ផ្តើមអារេនៅក្នុងចាវ៉ា?

ខាងក្រោមនេះគឺជាតំណាងដ្យាក្រាមនៃអារេមួយវិមាត្រនៃចំនួនគត់មាន ១១ ធាតុ។

អារេនៅចាវ៉ា

តារាង​មាតិកា

ជ្វាអារេលក្ខណៈពិសេស

  • អារេមានទំហំថេរហើយមិនអាចផ្លាស់ប្តូរបានទេ
  • ចាប់តាំងពីអារេមានមូលដ្ឋានលើលិបិក្រមវាងាយស្រួលក្នុងការចូលប្រើធាតុចៃដន្យ
  • បែងចែកការចងចាំជាបន្តបន្ទាប់សម្រាប់ធាតុអារេ។
  • អាចផ្ទុកបានទាំងពីរ ទិន្នន័យបឋមនិងមិនមែនបឋម តម្លៃ

តើធ្វើដូចម្តេចដើម្បីប្រកាសអារេនៅចាវ៉ា?

ការប្រកាសអាចាវ៉ាអារេ

អារេអាចត្រូវបានប្រកាសតាមរបៀបដូចខាងក្រោម។ ការប្រកាសអារេមាន ២ ផ្នែកដែលទីមួយគឺទិន្នន័យនៃធាតុដែលយើងត្រូវរក្សាទុកក្នុងអារេមួយ (ដូចជា int ខ្សែអក្សរ។ ល។ ) ហើយបន្តដោយឈ្មោះអារេ។ [] តង្កៀបបញ្ជាក់ថាវាជាអារេមួយ។ នៅពេលយើងប្រកាសអារេវាគ្រាន់តែប្រាប់អ្នកចងក្រងថាអថេរគឺជាអារេហើយពិតជាមិនបង្កើតអារេទេ។

datatype [] arrayName; (ឬ)

datatype [] arrayName; (ឬ)

អាដាប់ធ័រអាដាប់ធ័រឈ្មោះ [] -> ជាធម្មតាយើងមិនចូលចិត្តប្រើវិធីសាស្ត្រនេះទេទោះបីវាត្រឹមត្រូវក៏ដោយ។

ឧទាហរណ៍នៃការប្រកាសអារេ

int[] arrNumbers;
String[] arrNames;
float[] arrValues;
boolean[] arrBoolean;
char[] arrLetters;
byte[] arrBytes;
double[] arrWeight;

តើធ្វើដូចម្តេចដើម្បីបង្កើតអារេនៅក្នុងចាវ៉ា?

ខ្សែអក្សរអារេនៅចាវ៉ា

យើងបង្កើតអារេដោយប្រើអាដាប់ធ័រ ថ្មី ប្រតិបត្តិករ។ នៅក្នុងនេះយើងបញ្ជាក់ទំហំអារេនៅក្នុង [] ដែលបញ្ជាក់ពីចំនួនសតិដែលត្រូវការដើម្បីរក្សាទុកអថេរអារេ។

ឈ្មោះ = ទិន្នន័យឌីជីថលថ្មី [ទំហំ];

យើងក៏អាចប្រកាសនិងបង្កើតឯកសារ អារេ នៅក្នុងសេចក្តីថ្លែងការណ៍តែមួយដូចខាងក្រោម។ សេចក្តីថ្លែងទីមួយបង្កើតអារេចំនួនគត់ដែលមានឈ្មោះថាទំហំ ៥ ។ ទីពីរបង្កើតអារេខ្សែអក្សរដែលមានឈ្មោះថាទំហំ ២

int[] arrNumbers = new int[5];
String[] arrNames = new String[2];

តើធ្វើដូចម្តេចដើម្បីចាប់ផ្តើមអារេនៅក្នុងចាវ៉ា?

តើធ្វើដូចម្តេចដើម្បីធ្វើឱ្យអារេរហ័សមួយ?

ការចាប់ផ្តើមអារេឬការធ្វើឱ្យរហ័សមានន័យថាការផ្តល់តម្លៃដល់អារេមួយដែលផ្អែកលើទំហំអារេ។ យើងក៏អាចបង្កើតនិងចាប់ផ្តើម (ធ្វើឱ្យភ្លាមៗ) នូវអារេជាមួយគ្នា (សូមមើលវិធីទី ១ ខាងក្រោម) ។ ក្នុងករណីនេះចំនួនធាតុបង្ហាញពីប្រវែងឬទំហំនៃអារេមួយ។ នៅក្នុងវិធីសាស្រ្តទី ២ យើងកំនត់តម្លៃដាច់ដោយឡែកពីគ្នា t1 ធាតុនីមួយៗ។ ចាប់តាំងពីលិបិក្រមអារេចាប់ផ្តើមពីលេខ ០ និងទំហំអារេនៅទីនេះគឺ ៣ ធាតុទី ៣ កាន់កាប់ទីតាំងទី ២ ដែលជា n-2 ដែល n ជាទំហំនៃអារេ។

//Method 1
int[] arrNumbers = {1,2,3};

//Method 2
int[] arrNumbers = new int[3];
arrNumbers[0] = 1;
arrNumbers[1] = 2;
arrNumbers[2] = 3;

ការចូលប្រើធាតុអារេនៅចាវ៉ា

យើងចូលប្រើធាតុអារេដោយប្រើតម្លៃសន្ទស្សន៍របស់វា។ ជាទូទៅយើងប្រើ សម្រាប់ រង្វិលជុំឬ សម្រាប់គ្នា រង្វិលជុំដើម្បីចូលប្រើធាតុអារេចាប់តាំងពីធាតុទាំងអស់មានទំហំដូចគ្នានិងមានទំហំថេរ។

ឧទាហរណ៍ៈបង្កើត, ចាប់ផ្តើមនិងចូលដំណើរការធាតុអារេ

នៅទីនេះយើងកំពុងបង្កើតនិងចាប់ផ្តើមខ្សែអក្សរជាច្រើននៅក្នុងសេចក្តីថ្លែងការណ៍តែមួយហើយចូលប្រើធាតុនីមួយៗដោយប្រើរង្វិលជុំ

public class ArrayDemo1 {

  public static void main(String[] args) {
    String[] arrMonths = {"May","June","July"};
    System.out.println("Length of array is: " + arrMonths.length);
    for(int i=0;i<arrMonths.length;i++)
    {
      System.out.println(arrMonths[i]); 
    }

  }

}
Output:
Length of array is: 3
May
June
July

ឧទាហរណ៍៖ វិធីសាស្រ្តមួយទៀតនៃការចាប់ផ្តើមអារេនិងការចូលប្រើធាតុអារេ

ក្នុងឧទាហរណ៍ខាងក្រោមដំបូងយើងប្រកាសនិងបង្កើតអារេនៃចំនួនគត់ហើយបន្ទាប់មកកំណត់តម្លៃទៅធាតុអារេនីមួយៗ។ នៅទីនេះយើងកំពុងប្រើសម្រាប់រង្វិលជុំនីមួយៗដើម្បីចូលប្រើធាតុអារេ។

public class ArrayDemo2 {

  public static void main(String[] args) {
    int[] numbers = new int[5];
    numbers[0] = 100;
    numbers[1] = 101;
    numbers[2] = 103;
    numbers[3] = 104;
    numbers[4] = 105;
    
    for(int i: numbers)
    {
      System.out.println(i);
    }

  }

}
Output:
100
101
103
104
105

ប្រភេទនៃអារេនៅចាវ៉ា

មានអារេចំនួន ២ ប្រភេទនៅចាវ៉ា៖

  • អារេវិមាត្រតែមួយ - នេះមានតែជួរដេកនិងជួរឈរ ១ ប៉ុណ្ណោះ។ ឧទាហរណ៍ទាំងអស់ខាងលើជាកម្មសិទ្ធិរបស់អារេវិមាត្រតែមួយ
  • អារេពហុវិមាត្រ - នេះមានជួរដេកនិងជួរឈរច្រើន។ និយាយម្យ៉ាងទៀតវាគឺជាជួរអារេដែលជួរទាំងអស់មានចំនួនជួរឈរដូចគ្នា។ ឧទាហរណ៏: ម៉ាទ្រីស ២ * ២
  • អារេច្រឹប - ជួរនីមួយៗមានចំនួនជួរឈរខុសគ្នា

អារេពហុវិមាត្រនៅចាវ៉ា

អារេពហុមុខអាចមានជួរដេកនិងជួរឈរច្រើន។ លិបិក្រមនៅក្នុង [ដំបូង] តំណាងឱ្យជួរដេកនិងទីពីរ [] តំណាងឱ្យជួរឈរ។

ឧទាហរណ៏: int [] [] a = ថ្មី int [2] [3]

នេះមានន័យថាអារេមាន ២ ជួរនិង ៣ ជួរ។ ខាងក្រោមនេះគឺជាតំណាងដ្យាក្រាមនៃអារេពហុវិមាត្រ

អារេនៅចាវ៉ា

ឧទាហរណ៍នៃការបង្កើតអារេពហុវិមាត្រនៃខ្សែអក្សរ

ឧទាហរណ៍ខាងក្រោមបង្ហាញពីរបៀបបង្កើតប្រកាសនិងចូលប្រើធាតុអារេពហុវិមាត្រ។ នៅទីនេះយើងចូលប្រើធាតុអារេដោយផ្ទាល់ដោយប្រើសន្ទស្សន៍ជួរដេកនិងជួរឈរ។

public class ArrayMulti {

  public static void main(String[] args) {
    String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
    System.out.println(arrNames[0][0] + " " + arrNames[0][1]);
    System.out.println(arrNames[1][0] + " " + arrNames[1][1]);

  }

}
Output:
John Jacob 
Thomas Martin

ឧទាហរណ៍នៃអារេចំនួន ២D

នៅទីនេះយើងកំពុងបង្កើតអារេចំនួន ២ វិមាត្រនៃចំនួនគត់មាន ២ ជួរនិង ៣ ជួរឈរ។ យើងកំណត់តម្លៃទៅធាតុអារេទាំងនេះនៅខាងក្នុងសម្រាប់រង្វិលជុំ។ ទី 2 សម្រាប់រង្វិលជុំតំណាងជួរដេកនិងទី 2 សម្រាប់រង្វិលជុំបង្ហាញជួរឈរ។

public class ArrayMulti {

  public static void main(String[] args) {
    //Declare and create multidimensional array
    int[][] arrnum = new int[2][3];
    for(int i=0;i<2;i++) {
      for(int j=0;j<3;j++) {
        //Assign values to array elements
        arrnum[i][j] = i+1;
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }

  }

}
Output:
1 1 1 
2 2 2 

អារេជ្វានៅចាវ៉ា

អារេជ្វាក៏ជាអារេ ២ វិមាត្រមានចំនួនជួរឈរខុសគ្នា។ និយាយម្យ៉ាងទៀតជួរនីមួយៗមានចំនួនជួរឈរខុសគ្នា។ ការចាប់ផ្តើមអារេមួលគឺខុសពីអារេធម្មតា ២D ។

ការផ្តួចផ្តើមនៃការ Jagged អារេ

ក្នុងអំឡុងពេលបង្កើតអារេយើងបញ្ជាក់ចំនួនជួរដេក។ ក្នុងឧទាហរណ៍នេះវាគឺ ២ ។ នៅក្នុងសេចក្តីថ្លែង ២ បន្ទាប់សម្រាប់ជួរដេកនីមួយៗយើងបញ្ជាក់ចំនួនជួរឈរ។ នៅទីនេះជួរទី ១ មាន ៣ ជួរឈរនិងជួរទី ២ មាន ៤ ជួរឈរ។

int[][] arrnum = new int[2][];
arrnum[0] = new int[3];
arrnum[1] = new int[4];

ឧទាហរណ៏នៃអារេរដុបដោយកំណត់តម្លៃនៅក្នុងរង្វិលជុំ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arrnum = new int[2][];
    arrnum[0] = new int[3];
    arrnum[1] = new int[4];

    int val=1;
    //Assign values
    for(int i=0;i<arrnum.length;i++) {
      for(int j=0;j<arrnum[i].length;j++) {
        arrnum[i][j] = val;
      }
    }
    
    //Print the values
    for(int i=0;i<arrnum.length;i++)
    {
      for(int j=0;j<arrnum[i].length;j++)
      {
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }
  }

}
Output:
1 1 1 
1 1 1 1 

ឧទាហរណ៍តំរែតំរង់ដោយដាក់តម្លៃក្នុងកំឡុងពេលបង្កើតអារេ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arr = {{4,5,6},{1,2},{7,9,8}};
    for(int i=0;i<3;i++)
    {
      for(int j=0;j<arr[i].length;j++) {
        System.out.print(arr[i][j] + " ");
      }
      System.out.println();
    }
  }
}
Output:
4 5 6 
1 2 
7 9 8 

វិធីសាស្ត្រអារេចាវ៉ា

ខាងក្រោមនេះជាវិធីសាស្ត្រផ្ទាល់ដែលគាំទ្រដោយអារេនៅក្នុងចាវ៉ា

វិធីសាស្រ្តការពិពណ៌នា
ក្លូនចាត់ទុកជាមោឃៈ ()ក្លូនតម្លៃអារេដែលមានស្រាប់ដែលសេចក្តីយោងមិនត្រូវបានចម្លង
ប៊ូលីនស្មើ (វត្ថុ ០)ពិនិត្យមើលថាតើវត្ថុមួយចំនួនផ្សេងទៀតស្មើនឹងវត្ថុបច្ចុប្បន្នដែរឬទេ
ថ្នាក់ getClass ()ត្រឡប់ឈ្មោះថ្នាក់
ខ្សែអក្សរ toString ()ត្រឡប់ការបង្ហាញខ្សែអក្សររបស់វត្ថុ
ប្រវែង int ()ត្រឡប់ប្រវែងនៃអារេ

ការលើកលែងអារេចាវ៉ា

អារេចូល ជ្វាជះ ករណីលើកលែងខាងក្រោម៖

  • ArrayIndexOutOfBoundsException: នេះកើតឡើងនៅពេលដែលតម្លៃលិបិក្រមដែលយើងបញ្ជាក់ធំជាងប្រវែងនៃអារេឬនៅពេលដែលវាអវិជ្ជមាន។ បញ្ហានេះកើតឡើងភាគច្រើននៅពេលផ្តល់តម្លៃឬចូលប្រើធាតុអារេ។

ចម្លងអារេ

យើងអាចចម្លងធាតុពីអារេមួយទៅមួយទៀតដោយប្រើវិធីសាស្ត្រអារេនៃថ្នាក់ប្រព័ន្ធ។

ចម្លងវាក្យសម្ព័ន្ធអារេ

អេឡិចត្រូនិកចាត់ទុកជាមោឃៈជាសាធារណៈ (វត្ថុ src, int srcPos, កម្មវត្ថុវាសនា, វូថោផូ, ប្រវែងវែង)

src-source array object ដើម្បីចម្លងពី

srcPos - ទីតាំងចាប់ផ្តើមនៅក្នុងអារេប្រភព

dest - ទិសដៅអារេទិសដៅត្រូវចម្លងទៅ

ទិសដៅ - ទីតាំងចាប់ផ្តើមនៅក្នុងអារេទិសដៅ

ប្រវែង - ចំនួននៃធាតុអារេដើម្បីចម្លង

ឧទាហរណ៍នៃការចម្លងអារេ

ក្នុងឧទាហរណ៍ខាងក្រោមយើងកំពុងចម្លងធាតុទាំងបួនពីអារេប្រភពទៅអារេទិសដៅ។ ដូច្នេះលទ្ធផលបោះពុម្ព "ចាវ៉ា"

public class ArrayCopy {

  public static void main(String[] args) {
    char[] a = {'d','l','h','y','j','a','v','a','g','r','t'};
    char[] b = new char[4];
    
    System.arraycopy(a, 4, b, 0, 4);
    System.out.println(String.valueOf(b));

  }

}
Output:
java

ហុចអារេទៅវិធីសាស្ត្រមួយ

នៅចាវ៉ាយើងអាចបញ្ជូនវត្ថុអារេមួយទៅវិធីសាស្រ្តមួយសម្រាប់ការរៀបចំឬប្រតិបត្តិការផ្សេងទៀត។ ឧទាហរណ៍ខាងក្រោមបង្ហាញពីវិធីដែលយើងអាចហុចវត្ថុអារេនៃចំនួនគត់ទៅវិធីសាស្ត្រមួយនិងអនុវត្តការបន្ថែមធាតុអារេទាំងអស់។

public class ArrayDemo3 {

  public static void main(String[] args) {
    int[] num = {5,7,3,2,8};
    add(num);

  }
  
  public static void add(int[] num) {
    int sum = 0;
    for(int i=0;i<num.length;i++) {
      sum = sum + num[i];
    }
    System.out.println("Sum of array elements is : " + sum);
  }

}
Output:
Sum of array elements is : 25

ត្រឡប់អារេពីវិធីសាស្ត្រ

យើងក៏អាចធ្វើបានដែរ ត្រឡប់អារេមួយ វត្ថុពីវិធីសាស្ត្រមួយទៅវិធីសាស្រ្តមេបន្ទាប់ពីអនុវត្តប្រតិបត្តិការដែលត្រូវការ។

public class ArrayDemo4 {

  public static void main(String[] args) {
    String[] arr = getArrayValues();
    for(String cities:arr) {
      System.out.println(cities);
    }
      

  }
  
  public static String[] getArrayValues() {
    String[] arrCities = {"Chennai","Bangalore","Delhi"};
    return arrCities;
  }

}
Output:
Chennai
Bangalore
Delhi

ឧបាយកលអារេ

អារេចូល ចាវ៉ាជាកម្មសិទ្ធិរបស់កញ្ចប់ java.util។ មានប្រតិបត្ដិការជាច្រើនដែលគាំទ្រដោយថ្នាក់ java.util.Array ដូចដែលបានរៀបរាប់ខាងក្រោម៖

  • យើងអាចប្រើវិធីសាស្ត្រ copyOfRange នៃថ្នាក់អារេដើម្បីចម្លងធាតុជាច្រើនពីអារេមួយទៅមួយទៀត
  • ស្វែងរកអារេសម្រាប់តម្លៃជាក់លាក់ផ្អែកលើលិបិក្រម (ការស្វែងរកគោលពីរ)
  • ប្រៀបធៀបនឹងអារេដើម្បីពិនិត្យមើលភាពស្មើគ្នាដោយប្រើវិធីសាស្ត្រស្មើគ្នា
  • ប្រើវិធីសាស្ត្របំពេញដើម្បីបំពេញអារេមួយដើម្បីដាក់តម្លៃជាក់លាក់នៅសន្ទស្សន៍
  • ការតម្រៀបអារេដោយប្រើវិធីសាស្ត្រតម្រៀប

ការបង្កើតអារេដោយប្រើវត្ថុកំណត់ដោយអ្នកប្រើ

នៅក្នុងចាវ៉ាយើងក៏អាចបង្កើតវត្ថុដែលកំណត់ដោយអ្នកប្រើដូចគ្នានឹងរបៀបដែលយើងបង្កើតខ្សែអក្សរ, ចំនួនគត់ជាដើមនេះជាឧទាហរណ៍នៃវិធីដែលយើងអាចបង្កើតវត្ថុអារេសិស្សនិងចាប់ផ្តើមវត្ថុអារេ។

public class ArrayDemo5 {

  public static void main(String[] args) {
    Student[] s = new Student[2];
    s[0] = new Student(111,"Ajit");
    s[1] = new Student(112,"Biju");
  }

}
 class Student{
  public int rollno;
  public String name;
  public Student(int rno,String n) {
    rollno = rno;
    name = n;
  }
}

សេចក្តីសន្និដ្ឋាន

ការបង្រៀននេះផ្តល់នូវការពិពណ៌នាលំអិតនៃថ្នាក់អារេនៅក្នុងចាវ៉ាប្រភេទនៃអារេនៅក្នុងចាវ៉ាប្រកាសបង្កើតនិងចាប់ផ្តើមអារេជាមួយនឹងរូបភាពផ្សេងៗ។

ឯកសារយោង