java arrays

ජාවා arrays 

මම මේ පොස්ට් එකින් ඔයාලට කියල දෙන්න යන්නේ අපි කොහොමද ජාවා වල arrays use කරන්නේ කියල.මුලික වශයෙන්ම ජාවා වල array එකක් කියන්නේ එක ළඟ තියන data items group එකකට තමා.අයි අපිට මේ arrays use කරන්න ඕනේ වෙන්නේ කියල මුලින්ම බලමු.

අපි arrays වැඩිපුරම use කරන්නේ programme එකකට විශාල data ප්‍රමාණයක් එක්ක වැඩ කරන්න වන වෙලාවල් වලට තමයි.

array එකක data store කරන position එකකට අපි කියනවා index එහම නැත්තම්  superscript එකක් සාමාන්‍යයෙම් මේ index පටන් ගන්නේ 0 කියන index එකින් .array එකක් තුල store කරන්න පුළුවන් එකම data type එකේ data items විතරයි .අපි බලමු array එකක් මොන වගේද කියල.

 

array එකක් කියන්නේ object එකක්.object එක ගැන තමා වැඩිය තෙරන්නේ නැතුව ඇති oop වලදී object ගැන වැඩිදුරට කතාකරමු දැන් අපි බලමු Arrays Defining සහ  Declaring කරන්නේ කොහමද කියල.array එකක් කියන්නේ ඇත්තටම array එකක් නොවේ.ඇත්තටම වන්නේ array veriable එක array object එකක් reference කරන එක තමා.

array එකක් Declare කරන්න ඕනේ පහත දක්වන ෆොර්මැට් එකට තමා

dataType[] variableName;

පහත දක්වල තියන්නේ එක එක data type වලට arrays Declare කරන ආකාරයන්

int[] nums;

String[] names;

int nums[]; // not recommended, but legal

int nums[], i, j; // declares one array and two single int values

Instantiating Arrays

array එකක් instantiating කරනකොට new කියන key word එක use කරනවා.එකට හේතුව array veriable එක object එක refer  කිරීමට.

int[] nums;//1

nums = new int[10];//2

 2 වැනි line එකින් කරන්නේ eliment 10 තියන integer array එකක් හදල ඒ සියලු eliment 0 කියන default අගයට  instantiating කිරීම.

int[] moreNums;

int size = 7;

moreNums = new int[size];

අපිට ඕනෙනම් මේ විදියත් කරන්න පුළුවන්.

ඔබට පුළුවන් declare කිරීම හා instantiate කිරීම එකවිට කරන්න පුළුවන්.මෙන්න මේ වගේ

String[] names = new String[3]

ඒ code එකේ වන්නේ මෙන්න මේ වගේ දෙයක් .

array එකට තියන මුලිකම proprty එකක් තමා length එක.ඒක read only property එකක්.

අපිට පුළුවන් තියන array එකකට අලුත් array එකක් assign කරන්න.එතකොට ඒ array එක reference කරන්නේ අලුත් array එක පරණ එකින් dereference වෙනවා .මෙන්න මේ වගේ

int[] nums;

nums = new int[10];

nums = new int[20];

nums array එකට eliment 20 තියනවා

Initializing Arrays

array එකක් Initializing කරන්න පලුවන් declare කරනකොටම

String[] names = { "Joe", "Jane", "Herkimer" };

or

String[] names = new String[] {"Joe", "Jane", "Herkimer" };

මේ ක්‍රමයට length එක දෙන්න ඕන නෑ .එයා automatically length එක define කරගන්නවා.වන වැඩේ රූපයකින් පෙන්නුවොත් මෙන්න මේ විදියට

Book[] titles;

titles = new Book[] {

    new Book(5011,"Fishing Explained"),

    new Book(1234, "Help is on the Way")

};

මේ code එකේ තියන්නේ titles කියන්නේ object array එකක් .එකට අපිට add කරන්න පලුවන් object විතරයි.oop වලදී ඒ ගැන වැඩිදුර බලමු.

Arrays සමග වැඩකිරීම

array එකක් සමග වැඩකිරීමට මුලින්ම දැනගන්න ඕනේ array index access කරන විදිය. index එකක් කියන්නේ eliment එකක් අංකයක්. array ඉඑෂ් සාමාන්යෙන් පට්ටන්ගන්නේ 0 න්.ඉවර වෙන්නේ length එකට එකක් අඩුවන්.අපි ගමු length එක 3 වන string  array එකක්.

String[] names = new String[3];

මේකේ index වන්නේ 0,1,2 යන ඒවා .මේ index වලට eliment add කරන විදිය පහත දක්වල තියනවා.

names[0] = "kasun";

names[1] = "lakmal";

names[2] = "Abaywardana";

මේ element ටික බලාගන්න ඕනනම් අපිට forloop එකක් දාල s.o.p එකකින් ලෙසියන්ම පලුවන්.

for (int i = 0; i < 3; i++) {

System.out.println(names[i]);

}

or

for (int i = 0; i < names.length; i++) {

System.out.println(names[i]);

}

අපි දැන් බලමු arrays යොදාගෙන ලියපු පුංචි programme එකක්.

මුලින් තියන array එකට eliment ගන්නේ random නුම්බෙර් generator එකකින්.එක පෙන්නලා තියන විදියට උඩින් ඉම්පෝර්ට් කරගන්න ඕනේ.ඊටපස්සේ කරන්න තියේන්නේ කලින් විස්තර කරපු ටිකමයි.

ඉහත කිවේ array වල මුලික ටික.

දැන් අපි බලමු array එකක් තවත් array එකකට copy කරන්නේ ක්හොමද කියල.

public class CopyArray {

  public static void main(String[] args) {

    int nums[] = { 6, 2, 4, 9, 1 };

    int biggerNums[] = new int[10];

    System.arraycopy(nums, 0, biggerNums, 0, nums.length);//1

    System.arraycopy(nums, 0, biggerNums,nums.length, nums.length);//2

    for (int i = 0; i < biggerNums.length; i++)

      System.out.println(biggerNums[i]);

  }

}

line 1 කරන්නේ nums array eliment ,bignumbers array එකේ 0 index එකේ ඉඳන් copy කරනවා.line 2 කරන්නේ nums වල length එකින් පට්ටන්ගන්න index එකේ ඉඳන් ඉස්සරහට copy කරන එක.

Multi-Dimensional Arrays

array එකට dimension එකකට වඩා තියනවනම් එක multi dimension array එකක්.උදාහරණයක් ගත්තොත් මේවගේ ..

datatype[][] ... [] arrayName;

array එක instantiating කරන්නේ පහත දක්වන විදියට

arrayName = new datatype[size1][size2] ... [sizeN];

උදාහරණ :-

int[][] picture = new int[480][640];//2 D

int[][][] picture = new int[3][480][640];//3 D

multi dimension array එකක් memory එකේ represent කරන විදිය රුපයේ පෙන්නලා තියනවා

int[][] nums = new int[3][6];

දැන් අපි පොඩි programme එකක් බලමු 2 D arrays ගැන

import java.util.*;

class kasun {

  public static void main(String[] args) {

    Scanner scanner = new Scanner(System.in);

    int[][] a = new int[2][3];

    System.out.print("Enter 2x3=6 integers: ");

    for (int i=0; i<2; i++)

      for (int j=0; j<3; j++)

        a[i][j] = scanner.nextInt();

    System.out.println("Here are those 6 integers in a 2x3 2d-array:");

         for (int i=0; i<2; i++)

      for (int j=0; j<3; j++)

                    System.out.println(a[i][j]);

  }

}

මේ array එකට eliment add කරගන්නේ key board input එකකින්.

Typecasting with Arrays of Primitives

ඔයාලට මතක ඇති primitive variabl cast කරා අපි කලින් පොස්ට් එකකදි.ඒ වගේ arrays අපිට cast කරන්න බැ .පහත programme එක බලන්න.

public class ArrayTypecast {

  public static void main(String[] args) {

    int i = 5;

    double d;

    d = i;

    i = (int) d;

    int inums[] = { 1, 2, 3, 4, 5 };

    double[] dnums;

    // line below fails

    //dnums = inums;

    dnums = new double[] { 1.1, 2.2, 3.3, 4.4 };

    // line below fails

    //inums = (int[]) dnums;

  }

}

cast කරන්න හැදුවොත් compile  error එකක් එනවා.

මන් හිතන්නේ arrays ගැන පොඩි හරි ඉදෙඅ එකක් මේ පොස්ට් එක කියවීම තුලින් එන්න ඇති.අපි ඊළඟ පොස්ට් එකේ ඉඳන් oop පාඩම් වලින් හමුවෙමු..............................