ວິທີການເລີ່ມຕົ້ນຂບວນໃນ Java



Array Java

ວິທີການເລີ່ມຕົ້ນຂບວນໃນ Java

Arrays in java ແມ່ນໂຄງສ້າງຂໍ້ມູນທີ່ຖືກ ນຳ ໃຊ້ຫຼາຍທີ່ສຸດເຊິ່ງເກັບມູນຄ່າຫລາຍປະເພດຂອງຂໍ້ມູນດຽວກັນຕາມ ລຳ ດັບ. ຂບວນມີຄວາມຍາວຄົງທີ່ແລະດັດສະນີເລີ່ມຈາກ 0 ເຖິງ n-1 ບ່ອນທີ່ n ແມ່ນຄວາມຍາວຂອງອາເລ. ພວກເຮົາສາມາດ ນຳ ໃຊ້ arrays class ໃນ Java ເພື່ອເກັບມູນຄ່າປະເພດໃດໆເຊັ່ນ: String, integer, character, byte ແລະແມ້ແຕ່ວັດຖຸທີ່ ກຳ ນົດໂດຍຜູ້ໃຊ້. ພວກເຮົາຈະຮຽນຮູ້ວິທີການເລີ່ມຕົ້ນຂບວນໃນ Java?

ຂ້າງລຸ່ມນີ້ແມ່ນການເປັນຕົວແທນຂອງແຜນວາດຂອງອາເລນຂະ ໜາດ ດຽວຂອງຕົວເລກເຕັມມີ 11 ອົງປະກອບ.

ແຖວຢູ່ໃນຈາວາ

ສາ​ລະ​ບານ

Java Arrays Features

  • ຂບວນມີຂະ ໜາດ ຄົງທີ່ແລະບໍ່ສາມາດປ່ຽນແປງໄດ້
  • ນັບຕັ້ງແຕ່ອາເລແມ່ນພື້ນຖານດັດສະນີ, ມັນງ່າຍທີ່ຈະເຂົ້າເຖິງອົງປະກອບແບບສຸ່ມ
  • ຈັດສັນຄວາມຊົງ ຈຳ ຢ່າງຕໍ່ເນື່ອງ ສຳ ລັບອົງປະກອບຂບວນ.
  • ສາມາດເກັບຮັກສາໄດ້ທັງສອງຢ່າງ ຂໍ້ມູນເບື້ອງຕົ້ນແລະບໍ່ແມ່ນແບບດັ້ງເດີມ ຄ່າ

ວິທີການປະກາດ Array ໃນ Java?

ການປະກາດ Java Arrays

ຂບວນການສາມາດປະກາດໃນວິທີຂ້າງລຸ່ມນີ້. ການປະກາດ Array ມີ 2 ພາກສ່ວນ, ທຳ ອິດແມ່ນຂໍ້ມູນຂອງອົງປະກອບທີ່ພວກເຮົາຕ້ອງການຈັດເກັບເປັນແຖວ (ເຊັ່ນ: int, String, etc) ແລະຕິດຕາມດ້ວຍຊື່ array. ວົງເລັບ [] ໝາຍ ຄວາມວ່າມັນເປັນອາເລ. ເມື່ອພວກເຮົາປະກາດອາເລ, ມັນພຽງແຕ່ບອກນັກຂຽນວ່າຕົວແປແມ່ນອາເລແລະຕົວຈິງບໍ່ໄດ້ສ້າງຂບວນ.

datatype [] arrayName; (ຫຼື)

datatype [] arrayName; (ຫຼື)

datatype arrayName []; -> ທຳ ມະດາພວກເຮົາບໍ່ມັກໃຊ້ວິທີນີ້ເຖິງວ່າມັນຖືກຕ້ອງ.

ຕົວຢ່າງຂອງການປະກາດຂບວນ

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

ວິທີການສ້າງ Array ໃນ Java?

ຊ່ອຍແນ່ Array ໃນ Java

ພວກເຮົາສ້າງຂບວນການ ນຳ ໃຊ້ ໃຫມ່ ຜູ້ປະກອບການ. ໃນນີ້, ພວກເຮົາ ກຳ ນົດຂະ ໜາດ ຂອງອາເລຢູ່ໃນ [] ເຊິ່ງ ໝາຍ ເຖິງ ຈຳ ນວນ ໜ່ວຍ ຄວາມ ຈຳ ທີ່ ຈຳ ເປັນໃນການຈັດເກັບຕົວປ່ຽນຂອງອາເລ.

arrname = datatype ໃໝ່ [ຂະ ໜາດ];

ພວກເຮົາຍັງສາມາດປະກາດແລະສ້າງ array ໃນຖະແຫຼງການດຽວດັ່ງລຸ່ມນີ້. ຄຳ ຖະແຫຼງ ທຳ ອິດສ້າງຕົວເລກເຕັມທີ່ມີ ຈຳ ນວນຂະ ໜາດ 5. ທີສອງສ້າງອາເລນ String ທີ່ຕັ້ງຊື່ຂະ ໜາດ 2

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

ວິທີການເລີ່ມຕົ້ນຂບວນໃນ Java?

ວິທີການເລັ່ງດ່ວນອາເລ?

ການເລີ່ມຕົ້ນ Array ຫຼືການເຮັດວຽກດ່ວນ ໝາຍ ເຖິງການມອບ ໝາຍ ຄ່າໃຫ້ກັບອາເລອີງຕາມຂະ ໜາດ ຂບວນ. ພວກເຮົາຍັງສາມາດສ້າງແລະເລີ່ມຕົ້ນ (ກະຕຸ້ນ) ສ້າງຂບວນພ້ອມກັນ (ອ້າງອີງເຖິງວິທີທີ 1 ຂ້າງລຸ່ມນີ້). ໃນກໍລະນີນີ້, ຈຳ ນວນຂອງອົງປະກອບ ໝາຍ ເຖິງຄວາມຍາວຫລືຂະ ໜາດ ຂອງອາເລ. ໃນວິທີທີ 2, ພວກເຮົາ ກຳ ລັງມອບຄ່າຕ່າງໆໃຫ້ເປັນ t0 ແຕ່ລະອົງປະກອບ. ເນື່ອງຈາກດັດສະນີຂບວນເລີ່ມຕົ້ນຈາກ 0 ແລະຂະ ໜາດ ແຖວຢູ່ນີ້ແມ່ນ 3, ອົງປະກອບທີ 3 ຍຶດ ຕຳ ແໜ່ງ ທີ່ 2 ຊຶ່ງແມ່ນ n-1 ເຊິ່ງ n ແມ່ນຂະ ໜາດ ຂອງຂບວນ.

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

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

ການເຂົ້າຫາອົງປະກອບ Array ໃນ Java

ພວກເຮົາເຂົ້າເຖິງອົງປະກອບຕ່າງໆໂດຍໃຊ້ມູນຄ່າດັດສະນີຂອງມັນ. ໂດຍທົ່ວໄປ, ພວກເຮົາໃຊ້ ສໍາລັບການ loop ຫຼື ສໍາລັບແຕ່ລະຄົນ loop ເພື່ອເຂົ້າຫາອົງປະກອບ array ດັ່ງທີ່ທຸກໆອົງປະກອບມີຄືກັນແລະມີຂະ ໜາດ ຄົງທີ່.

ຕົວຢ່າງ: ສ້າງ, ລິເລີ່ມແລະເຂົ້າເຖິງອົງປະກອບ Array

ໃນທີ່ນີ້, ພວກເຮົາ ກຳ ລັງສ້າງແລະ ກຳ ນົດແຖວຂອງສາຍໃນ ຄຳ ຖະແຫຼງດຽວແລະເຂົ້າເຖິງແຕ່ລະອົງປະກອບໂດຍໃຊ້ loop

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

ຕົວຢ່າງ: ອີກວິທີ ໜຶ່ງ ໃນການເລີ່ມຕົ້ນ array ແລະເຂົ້າເຖິງອົງປະກອບ array

ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາປະກາດແລະສ້າງຂອດເລກສ່ວນ ທຳ ອິດແລະຫຼັງຈາກນັ້ນມອບຄ່າໃຫ້ກັບສ່ວນປະກອບຂບວນແຕ່ລະອັນ. ນີ້, ພວກເຮົາ ກຳ ລັງໃຊ້ແຕ່ລະ loop ເພື່ອເຂົ້າຫາອົງປະກອບ array.

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

ປະເພດຂອງຂບວນໃນ Java

ຢູ່ໃນ Java ມີ 2 ປະເພດຂອງ Arrays:

  • ແຖວຂະ ໜາດ ດຽວ - ນີ້ມີພຽງແຕ່ 1 ແຖວແລະ 1 ຖັນ. ຕົວຢ່າງທັງ ໝົດ ຂ້າງເທິງແມ່ນຂອງຂະ ໜາດ ດຽວ
  • ອາເລທີ່ມີຫຼາຍມິຕິ - ອັນນີ້ປະກອບມີຫຼາຍແຖວແລະຫຼາຍຖັນ. ເວົ້າອີກຢ່າງ ໜຶ່ງ, ມັນແມ່ນແຖວຂອງແຖວທີ່ທຸກແຖວມີ ຈຳ ນວນຖັນດຽວກັນ. ຕົວຢ່າງ: 2 * 2 ມາຕຣິກເບື້ອງ
  • ແຖວທີ່ຖືກຂູດ - ແຕ່ລະແຖວມີ ຈຳ ນວນຖັນທີ່ແຕກຕ່າງກັນ

ອາຄານຫຼາຍມິຕິໃນເກາະຈາວາ

ອາຄານທີ່ມີຫຼາຍມິຕິສາມາດມີແຖວແລະຖັນຫຼາຍແຖວ. ດັດສະນີໃນ [ທຳ ອິດ] ສະແດງແຖວແລະແຖວທີສອງ [ເປັນຕົວແທນໃຫ້ຖັນ.

ຕົວຢ່າງ: int [] [] a = new int [2] [3]

ນີ້ ໝາຍ ຄວາມວ່າອາເລປະກອບມີ 2 ແຖວແລະ 3 ຖັນ. ຂ້າງລຸ່ມນີ້ແມ່ນການເປັນຕົວແທນແຜນວາດຂອງຂບວນການທີ່ມີຫຼາຍຮູບຫຼາຍແບບ

ແຖວຢູ່ໃນຈາວາ

ຕົວຢ່າງຂອງການສ້າງແຖວຫລາຍໆແຖວຂອງ Strings

ຕົວຢ່າງຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນວິທີການສ້າງ, ປະກາດແລະເຂົ້າເຖິງອົງປະກອບຂບວນຫຼາຍຮູບແບບ. ທີ່ນີ້, ພວກເຮົາເຂົ້າເຖິງອົງປະກອບຕ່າງໆຂອງອາເລໂດຍກົງໂດຍ ນຳ ໃຊ້ດັດຊະນີແຖວແລະຄໍ ລຳ.

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

ຕົວຢ່າງຂອງແຖວ 2D ຂອງຕົວເລກເຕັມ

ໃນນີ້, ພວກເຮົາ ກຳ ລັງສ້າງຂີດ ຈຳ ນວນ 2 ມິຕິຂອງຕົວເລກລວມມີ 2 ແຖວແລະ 3 ຖັນ. ພວກເຮົາມອບຄ່າຕ່າງໆໃຫ້ກັບບັນດາອົງປະກອບເຫຼົ່ານີ້ພາຍໃນ ສຳ ລັບ loop. ທີ 1 ສຳ ລັບ loop ໝາຍ ເຖິງແຖວແລະທີ 2 ສຳ ລັບ loop ໝາຍ ເຖິງຄໍ ລຳ.

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 

Jagged Arrays ໃນ Java

ຂບວນວຸ້ນໆແມ່ນຂບວນ 2 ມິຕິມີຕົວເລກຖັນຕ່າງກັນ. ໃນຄໍາສັບຕ່າງໆອື່ນໆ, ແຕ່ລະແຖວມີຈໍານວນຖັນທີ່ແຕກຕ່າງກັນ. ການເລີ່ມຕົ້ນຂບວນຂື່ນແມ່ນແຕກຕ່າງຈາກອາເລ 2D ທຳ ມະດາ.

ການເລີ່ມຕົ້ນຂອງ Jagged Array

ໃນລະຫວ່າງການສ້າງຂບວນ, ພວກເຮົາ ກຳ ນົດ ຈຳ ນວນແຖວ. ໃນຕົວຢ່າງນີ້, ມັນແມ່ນ 2. ໃນ 2 ຄຳ ຖະແຫຼງຕໍ່ໄປ, ສຳ ລັບແຕ່ລະແຖວແຖວ, ພວກເຮົາ ກຳ ນົດ ຈຳ ນວນຖັນ. ຢູ່ນີ້, ແຖວທີ 1 ມີ 3 ຖັນແລະແຖວທີ 2 ມີ 4 ຖັນ.

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

ຕົວຢ່າງຂອງແຖວທີ່ມີການວຸ້ນວາຍໂດຍການ ກຳ ນົດຄ່າຕ່າງໆ ສຳ ລັບ loop

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 

Jagged array ຕົວຢ່າງໂດຍການເລີ່ມຕົ້ນຄ່າຕ່າງໆໃນລະຫວ່າງການສ້າງ array

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 

ວິທີ Array Java

ຂ້າງລຸ່ມນີ້ແມ່ນວິທີການໂດຍກົງທີ່ສະ ໜັບ ສະ ໜູນ ໂດຍ Arrays ໃນ Java

ວິທີການລາຍລະອຽດ
ໂຄນເປົ່າ ()Clones ຄ່າ array ທີ່ມີຢູ່ແລ້ວບ່ອນທີ່ການອ້າງອິງບໍ່ຖືກຄັດລອກ
Boolean ເທົ່າກັບ (ວັດຖຸ 0)ກວດເບິ່ງວ່າວັດຖຸອື່ນໃດ ໜຶ່ງ ເທົ່າກັບວັດຖຸປັດຈຸບັນ
ຫ້ອງຮຽນ getClass ()ກັບຄືນຄ່າ classname
String toString ()ສົ່ງຄືນຕົວແທນສະຕິງຂອງວັດຖຸ
ຄວາມຍາວ int ()ສົ່ງຄືນຄວາມຍາວຂອງແຖວ

ຂໍ້ຍົກເວັ້ນ Array Java

Arrays ໃນ Java ຖິ້ມ ຂໍ້ຍົກເວັ້ນຂ້າງລຸ່ມນີ້:

  • ArrayIndexOutOfBoundsException: ສິ່ງນີ້ເກີດຂື້ນເມື່ອມູນຄ່າດັດສະນີທີ່ພວກເຮົາລະບຸວ່າໃຫຍ່ກວ່າຄວາມຍາວຂອງອາເລຫລືເມື່ອມັນມີຄ່າລົບ. ນີ້ເກີດຂື້ນສ່ວນໃຫຍ່ແມ່ນໃນຂະນະທີ່ມອບ ໝາຍ ຄ່າຫລືເຂົ້າເຖິງອົງປະກອບຕ່າງໆຂອງ array.

ຄັດລອກຂບວນ

ພວກເຮົາສາມາດຄັດລອກອົງປະກອບຕ່າງໆຈາກແຖວ ໜຶ່ງ ໄປຫາອີກຊຸດ ໜຶ່ງ ໂດຍ ນຳ ໃຊ້ວິທີການຂບວນການຂອງລະບົບ.

ສຳ ເນົາ syntax array

public void arraycopy (Object src, int srcPos, object dest, int destPos, int length);

src-source array object ເພື່ອຄັດລອກຈາກ

srcPos - ຕຳ ແໜ່ງ ເລີ່ມຕົ້ນໃນແຖວແຫຼ່ງຂໍ້ມູນ

dest - ຈຸດ ໝາຍ ປາຍທາງຈຸດປະສົງເພື່ອຄັດລອກໄປ

destPos - ຕຳ ແໜ່ງ ເລີ່ມຕົ້ນໃນແຖວປາຍທາງ

ຄວາມຍາວ - ຈໍານວນຂອງອົງປະກອບຂບວນທີ່ຈະສໍາເນົາ

ຕົວຢ່າງຂອງການຄັດລອກຂບວນ

ໃນຕົວຢ່າງຂ້າງລຸ່ມນີ້, ພວກເຮົາ ກຳ ລັງຄັດລອກ 4 ອົງປະກອບຈາກແຫຼ່ງຂໍ້ມູນໄປຫາຂອດປາຍທາງ. ສະນັ້ນຜົນຜະລິດຈຶ່ງພິມ“ ຈາວາ”

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

ສົ່ງຂບວນໄປຫາວິທີການ

ໃນເກາະ Java, ພວກເຮົາສາມາດຜ່ານຈຸດປະສົງຂອງອາເລໄປຫາວິທີການ ສຳ ລັບການ ໝູນ ໃຊ້ຕໍ່ໄປຫຼືການ ດຳ ເນີນງານອື່ນໆ. ຕົວຢ່າງຂ້າງລຸ່ມນີ້ສະແດງໃຫ້ເຫັນວິທີທີ່ພວກເຮົາສາມາດຜ່ານ object object ຂອງເລກເຕັມໄປຫາວິທີການແລະປະຕິບັດການເພີ່ມເຕີມຂອງ array array ທັງ ໝົດ.

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

ສົ່ງຄືນອາເລຈາກວິທີການ

ພວກເຮົາສາມາດເຮັດໄດ້ເຊັ່ນກັນ ສົ່ງກັບຄືນອາເລ object ຈາກວິທີການຈົນເຖິງວິທີການຫລັກຫລັງຈາກປະຕິບັດງານທີ່ຕ້ອງການ.

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

ການ ໝູນ ໃຊ້ອາເລ

Arrays ໃນ Java ເປັນຂອງ java.util. ມີການ ດຳ ເນີນງານຫຼາຍຢ່າງທີ່ໄດ້ຮັບການສະ ໜັບ ສະ ໜູນ ຈາກ java.util.Array class ດັ່ງທີ່ກ່າວມາຂ້າງລຸ່ມນີ້:

  • ພວກເຮົາສາມາດ ນຳ ໃຊ້ copyOfRange ວິທີການຂອງ Array class ເພື່ອຄັດລອກອົງປະກອບຕ່າງໆຈາກ array ໄປອີກຊຸດ ໜຶ່ງ
  • ຄົ້ນຫາແຖວຂອງມູນຄ່າສະເພາະໂດຍອີງໃສ່ດັດສະນີ (ການຄົ້ນຫາຖານສອງ)
  • ປຽບທຽບກັບອາຄານເພື່ອກວດກາຄວາມສະ ເໝີ ພາບໂດຍໃຊ້ວິທີການທຽບເທົ່າ
  • ໃຊ້ວິທີການຕື່ມຂໍ້ມູນເພື່ອຕື່ມຂໍ້ມູນໃສ່ແຖວເພື່ອວາງມູນຄ່າສະເພາະໃນດັດສະນີ
  • ການຈັດຮຽງແຖວໂດຍໃຊ້ວິທີການຈັດຮຽງ

ການສ້າງຂບວນການໂດຍໃຊ້ວັດຖຸທີ່ ກຳ ນົດໂດຍຜູ້ໃຊ້

ໃນພາສາຈາວາ, ພວກເຮົາຍັງສາມາດສ້າງວັດຖຸທີ່ ກຳ ນົດໂດຍຜູ້ໃຊ້ຄືກັນກັບວິທີທີ່ພວກເຮົາສ້າງເຊືອກ, ຕົວເລກ, ແລະອື່ນໆ.

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;
  }
}

ສະຫຼຸບ

ບົດແນະ ນຳ ນີ້ໃຫ້ລາຍລະອຽດກ່ຽວກັບ Arrays Class ໃນ Java, ປະເພດຂອງ Arrays ໃນ Java, ປະກາດ, ສ້າງແລະເລີ່ມຕົ້ນ Arrays ດ້ວຍຮູບແຕ້ມຕ່າງໆ.

ກະສານອ້າງອີງ