ජාවා හි අරාවක් ප්‍රකාශ කර ආරම්භ කරන්නේ කෙසේද?

ඔබට අරාව ප්‍රකාශ කිරීම හෝ අරාව වචනානුසාරයෙන් භාවිතා කළ හැකිය (නමුත් ඔබ විචල්‍යය ප්‍රකාශයට පත් කර බලපාන විට පමණක්, අරාව නැවත පැවරීම සඳහා අරාව සාක්ෂරතාව භාවිතා කළ නොහැක).

ප්‍රාථමික වර්ග සඳහා:

int[] myIntArray = new int[3];
int[] myIntArray = {1, 2, 3};
int[] myIntArray = new int[]{1, 2, 3};

// Since Java 8. Doc of IntStream: https://docs.oracle.com/javase/8/docs/api/java/util/stream/IntStream.html

int [] myIntArray = IntStream.range(0, 100).toArray(); // From 0 to 99
int [] myIntArray = IntStream.rangeClosed(0, 100).toArray(); // From 0 to 100
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).toArray(); // The order is preserved.
int [] myIntArray = IntStream.of(12,25,36,85,28,96,47).sorted().toArray(); // Sort 

පංති සඳහා, උදාහරණයක් ලෙස String, එය සමාන ය:

String[] myStringArray = new String[3];
String[] myStringArray = {"a", "b", "c"};
String[] myStringArray = new String[]{"a", "b", "c"};

ඔබ මුලින් අරාව ප්‍රකාශ කර එය ආරම්භ කරන විට ආරම්භක තුන්වන ක්‍රමය ප්‍රයෝජනවත් වේ. මෙහි රංගනය අවශ්‍ය වේ.

String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};

අරාව වර්ග දෙකක් තිබේ.

එක් මාන මාන

පෙරනිමි අගයන් සඳහා සින්ටැක්ස්:

int[] num = new int[5];

හෝ (අඩු කැමැත්තක් දක්වයි)

int num[] = new int[5];

ලබා දී ඇති අගයන් සහිත සින්ටැක්ස් (විචල්ය / ක්ෂේත්‍ර ආරම්භ කිරීම):

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

හෝ (අඩු කැමැත්තක් දක්වයි)

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

සටහන: පහසුව සඳහා int [] num වඩාත් සුදුසු වන්නේ එය ඔබ මෙහි අරාව ගැන කතා කරන බව පැහැදිලිව පවසන බැවිනි. එසේ නොමැතිනම් වෙනසක් නැත. කොහෙත්ම නැහැ.

බහුමානීය අරාව

ප්රකාශය

int[][] num = new int[5][2];

හෝ

int num[][] = new int[5][2];

හෝ

int[] num[] = new int[5][2];

ආරම්භ කිරීම

 num[0][0]=1;
 num[0][1]=2;
 num[1][0]=1;
 num[1][1]=2;
 num[2][0]=1;
 num[2][1]=2;
 num[3][0]=1;
 num[3][1]=2;
 num[4][0]=1;
 num[4][1]=2;

හෝ

 int[][] num={ {1,2}, {1,2}, {1,2}, {1,2}, {1,2} };

නවක අරා (හෝ සෘජුකෝණාස්රාකාර නොවන අරාව)

 int[][] num = new int[5][];
 num[0] = new int[1];
 num[1] = new int[5];
 num[2] = new int[2];
 num[3] = new int[3];

ඉතින් මෙන්න අපි තීරු පැහැදිලිව අර්ථ දක්වමු.
වෙනත් ක්රමයක්:

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

ප්‍රවේශ වීම සඳහා:

for (int i=0; i<(num.length); i++ ) {
    for (int j=0;j<num[i].length;j++)
        System.out.println(num[i][j]);
}

විකල්පයක් ලෙස:

for (int[] a : num) {
  for (int i : a) {
    System.out.println(i);
  }
}

නවක අරා යනු බහුමානීය අරා වේ.
පැහැදිලි කිරීම සඳහා නිල ජාවා නිබන්ධන වල බහුමානීය අරාව විස්තර බලන්න

Type[] variableName = new Type[capacity];

Type[] variableName = {comma-delimited values};



Type variableName[] = new Type[capacity]; 

Type variableName[] = {comma-delimited values};

වලංගු වේ, නමුත් මම වර්ගයට පසුව වරහන් වලට වැඩි කැමැත්තක් දක්වන්නෙමි, මන්ද විචල්යයේ වර්ගය සැබවින්ම අරාවක් බව දැකීම පහසුය.

ඔබට ජාවා හි අරාවක් ප්‍රකාශ කළ හැකි විවිධ ක්‍රම තිබේ:

float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};

ඔබට වැඩි විස්තර සන් නිබන්ධන වෙබ් අඩවියෙන් සහ ජාවා ඩොක් වෙතින් සොයාගත හැකිය .

ඔබ එක් එක් කොටස තේරුම් ගන්නේ නම් එය ප්‍රයෝජනවත් බව මට පෙනේ:

Type[] name = new Type[5];

Type[]යනු වර්ගය පිළිබඳ විචල්ය ලෙස නම ( "නම" කියාද හඳුනාගැනීමේ ). වචනයේ පරිසමාප්ත අර්ථයෙන්ම පාදක වර්ගය වන අතර වරහන් යන්නෙන් අදහස් කරන්නේ මෙය එම පාදමේ අරාව වර්ගයයි. අරා වර්ග ඒවායේම වර්ග වේ, එමඟින් ඔබට බහුමානීය අරා Type[][](අරා වර්ගය []) වැනි සෑදිය හැකිය. newනව අරාව සඳහා මතකය වෙන් කිරීමට යතුරුපදය පවසයි. වරහන අතර ඇති සංඛ්‍යාවෙන් කියැවෙන්නේ නව අරාව කොතරම් විශාලද සහ කොපමණ මතකයක් වෙන් කළ යුතුද යන්නයි. උදාහරණයක් ලෙස, මූලික වර්ගයට Typeබයිට් 32 ක් අවශ්‍ය බව ජාවා දන්නේ නම් සහ ඔබට 5 ප්‍රමාණයේ අරාවක් අවශ්‍ය නම්, එයට අභ්‍යන්තරව බයිට් 32 * 5 = 160 වෙන් කළ යුතුය.

ඔබට දැනටමත් එහි ඇති අගයන් සමඟ අරා සෑදිය හැකිය

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

එය හිස් අවකාශය නිර්මාණය කරනවා පමණක් නොව එම අගයන්ගෙන් එය පුරවයි. ප්‍රාථමිකයන් පූර්ණ සංඛ්‍යාවක් බවත් ඒවායින් 5 ක් ඇති බවත් ජාවාට පැවසිය හැකිය, එබැවින් අරාවේ ප්‍රමාණය ව්‍යංගයෙන් තීරණය කළ හැකිය.

පහත දැක්වෙන්නේ අරාව ප්‍රකාශ කිරීමකි, නමුත් අරාව ආරම්භ කර නොමැත:

 int[] myIntArray = new int[3];

පහත දැක්වෙන්නේ ප්‍රකාශය මෙන්ම අරාව ආරම්භ කිරීම ය:

int[] myIntArray = {1,2,3};

දැන්, පහත දැක්වෙන්නේ ප්‍රකාශය මෙන්ම අරාව ආරම්භ කිරීම ද වේ:

int[] myIntArray = new int[]{1,2,3};

නමුත් මෙම තෙවනුව නිර්නාමික අරාව-වස්තු නිර්මාණය කිරීමේ ගුණාංගය පෙන්වන අතර එය යොමු විචල්‍යයක් වන “myIntArray” මගින් දක්වනු ලැබේ, එබැවින් අපි “නව int [] {1,2,3}; එවිට නිර්නාමික අරාව-වස්තුව නිර්මාණය කළ හැක්කේ එලෙසිනි.

අපි ලියන්නේ නම්:

int[] myIntArray;

මෙය අරාව ප්‍රකාශ කිරීමක් නොවේ, නමුත් පහත ප්‍රකාශය මඟින් ඉහත ප්‍රකාශය සම්පූර්ණ කරයි:

myIntArray=new int[3];

විකල්පයක් ලෙස,

// Either method works
String arrayName[] = new String[10];
String[] arrayName = new String[10];

එය arrayName10 වන ප්‍රමාණයේ අරාව ප්‍රකාශ කරයි (ඔබට භාවිතා කිරීමට 0 සිට 9 දක්වා මූලද්‍රව්‍ය ඇත).

එසේම, ඔබට වඩා ගතික යමක් අවශ්‍ය නම් ලැයිස්තු අතුරුමුහුණත ඇත. මෙය ද ක්‍රියාත්මක නොවනු ඇත, නමුත් වඩාත් නම්‍යශීලී වේ:

List<String> listOfString = new ArrayList<String>();

listOfString.add("foo");
listOfString.add("bar");

String value = listOfString.get(0);
assertEquals( value, "foo" );

අරාවක් සෑදීමට ප්‍රධාන ක්‍රම දෙකක් තිබේ:

මෙය හිස් අරා සඳහා:

int[] array = new int[n]; // "n" being the number of spaces to allocate in the array

ආරම්භක අරාව සඳහා මෙය:

int[] array = {1,2,3,4 ...};

ඔබට මේ ආකාරයට බහුමානීය අරා සෑදිය හැකිය:

int[][] array2d = new int[x][y]; // "x" and "y" specify the dimensions
int[][] array2d = { {1,2,3 ...}, {4,5,6 ...} ...};

intඋදාහරණයක් ලෙස ප්‍රාථමික වර්ගය ගන්න . ප්‍රකාශ කිරීමට හා intපෙළගස්වා ගැනීමට ක්‍රම කිහිපයක් තිබේ :

int[] i = new int[capacity];
int[] i = new int[] {value1, value2, value3, etc};
int[] i = {value1, value2, value3, etc};

මේ සියල්ල තුළ, ඔබට int i[]ඒ වෙනුවට භාවිතා කළ හැකිය int[] i.

පරාවර්තනය සමඟ, ඔබට භාවිතා කළ හැකිය (Type[]) Array.newInstance(Type.class, capacity);

ක්‍රම පරාමිතීන්හි ...දැක්වෙන බව සලකන්න variable arguments. අත්යවශ්යයෙන්ම, ඕනෑම පරාමිති සංඛ්යාවක් හොඳයි. කේතය සමඟ පැහැදිලි කිරීම පහසුය:

public static void varargs(int fixed1, String fixed2, int... varargs) {...}
...
varargs(0, "", 100); // fixed1 = 0, fixed2 = "", varargs = {100}
varargs(0, "", 100, 200); // fixed1 = 0, fixed2 = "", varargs = {100, 200};

ක්රමය තුළ, varargsසාමාන්ය ලෙස සලකනු ලැබේ int[]. Type...භාවිතා කළ හැක්කේ ක්‍රම පරාමිතීන් තුළ පමණි, එබැවින් int... i = new int[] {}සම්පාදනය නොකෙරේ.

int[]ක්‍රමයකට (හෝ වෙනත් ඕනෑම දෙයකට Type[]) පිවිසීමේදී ඔබට තුන්වන ක්‍රමය භාවිතා කළ නොහැකි බව සලකන්න . ප්රකාශයේ int[] i = *{a, b, c, d, etc}*දී, සම්පාදකයා උපකල්පනය {...}කරන්නේ අ int[]. නමුත් එයට හේතුව ඔබ විචල්‍යයක් ප්‍රකාශ කිරීමයි. ගැනීමට ක්රමයක් රැසක් පසුකර විට, ප්රකාශයට පත් එක්කෝ විය යුතුය new Type[capacity]හෝ new Type[] {...}.

බහුමානීය අරා

බහුවිධ අරා සමඟ කටයුතු කිරීමට වඩා දුෂ්කර ය. අත්යවශ්යයෙන්ම, 2D අරාව යනු අරා සමූහයකි. s int[][]යනු අරාවකි int[]. ප්රධාන දෙය නම්, int[][]ප්රකාශයක් නම් int[x][y], උපරිම දර්ශකය වේ i[x-1][y-1]. අත්යවශ්යයෙන්ම, සෘජුකෝණාස්රාකාර int[3][5]යනු:

[0, 0] [1, 0] [2, 0]
[0, 1] [1, 1] [2, 1]
[0, 2] [1, 2] [2, 2]
[0, 3] [1, 3] [2, 3]
[0, 4] [1, 4] [2, 4]

ජාවා 9 හි

විවිධ IntStream.iterateසහ IntStream.takeWhileක්‍රම භාවිතා කිරීම:

int[] a = IntStream.iterate(10, x -> x <= 100, x -> x + 10).toArray();

Out: [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]


int[] b = IntStream.iterate(0, x -> x + 1).takeWhile(x -> x < 10).toArray();

Out: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

ජාවා 10 හි

දේශීය විචල්ය වර්ගය අනුමානය භාවිතා කිරීම :

var letters = new String[]{"A", "B", "C"};

පරාවර්තනයන් භාවිතා කරමින් අරා නිර්මාණය කිරීමට ඔබට අවශ්‍ය නම් ඔබට මේ ආකාරයට කළ හැකිය:

 int size = 3;
 int[] intArray = (int[]) Array.newInstance(int.class, size ); 

වස්තු යොමු සමූහයක් ප්‍රකාශ කිරීම:

class Animal {}

class Horse extends Animal {
    public static void main(String[] args) {

        /*
         * Array of Animal can hold Animal and Horse (all subtypes of Animal allowed)
         */
        Animal[] a1 = new Animal[10];
        a1[0] = new Animal();
        a1[1] = new Horse();

        /*
         * Array of Animal can hold Animal and Horse and all subtype of Horse
         */
        Animal[] a2 = new Horse[10];
        a2[0] = new Animal();
        a2[1] = new Horse();

        /*
         * Array of Horse can hold only Horse and its subtype (if any) and not
           allowed supertype of Horse nor other subtype of Animal.
         */
        Horse[] h1 = new Horse[10];
        h1[0] = new Animal(); // Not allowed
        h1[1] = new Horse();

        /*
         * This can not be declared.
         */
        Horse[] h2 = new Animal[10]; // Not allowed
    }
}

අරාව යනු අනුක්‍රමික අයිතම ලැයිස්තුවකි

int item = value;

int [] one_dimensional_array = { value, value, value, .., value };

int [][] two_dimensional_array =
{
  { value, value, value, .. value },
  { value, value, value, .. value },
    ..     ..     ..        ..
  { value, value, value, .. value }
};

එය වස්තුවක් නම් එය එකම සංකල්පයකි

Object item = new Object();

Object [] one_dimensional_array = { new Object(), new Object(), .. new Object() };

Object [][] two_dimensional_array =
{
  { new Object(), new Object(), .. new Object() },
  { new Object(), new Object(), .. new Object() },
    ..            ..               ..
  { new Object(), new Object(), .. new Object() }
};

වස්තූන් සම්බන්ධයෙන්, nullඒවා භාවිතා කිරීම ආරම්භ කිරීම සඳහා ඔබට එය පැවරිය යුතුය new Type(..), පන්ති වැනි Stringසහ Integerපහත දැක්වෙන පරිදි හැසිරවිය හැකි විශේෂ අවස්ථා

String [] a = { "hello", "world" };
// is equivalent to
String [] a = { new String({'h','e','l','l','o'}), new String({'w','o','r','l','d'}) };

Integer [] b = { 1234, 5678 };
// is equivalent to
Integer [] b = { new Integer(1234), new Integer(5678) };

පොදුවේ ඔබට Mමානයන්ගෙන් යුත් අරා නිර්මාණය කළ හැකිය

int [][]..[] array =
//  ^ M times [] brackets

    {{..{
//  ^ M times { bracket

//            this is array[0][0]..[0]
//                         ^ M times [0]

    }}..}
//  ^ M times } bracket
;

Mඅවකාශය අනුව මාන අරාවක් නිර්මාණය කිරීම මිල අධික බව සටහන් කිරීම වටී . ඔබ සියලු Mමානයන් සමඟ මාන අරාවක් නිර්මාණය කරන විට, අරාවෙහි Nමුළු ප්‍රමාණය වඩා විශාල වේ N^M, මන්ද සෑම අරාවකටම යොමු දැක්වීමක් ඇති අතර, එම්-මානයන්හි (M-1) මාන මාන යොමුව ඇත. මුළු ප්‍රමාණය පහත පරිදි වේ

Space = N^M + N^(M-1) + N^(M-2) + .. + N^0
//      ^                              ^ array reference
//      ^ actual data

ජාවා 8 හි ඔබට මේ ආකාරයට භාවිතා කළ හැකිය.

String[] strs = IntStream.range(0, 15)  // 15 is the size
    .mapToObj(i -> Integer.toString(i))
    .toArray(String[]::new);

පන්ති වස්තු වල අරා නිර්මාණය කිරීම සඳහා ඔබට භාවිතා කළ හැකිය java.util.ArrayList. අරාව අර්ථ දැක්වීමට:

public ArrayList<ClassName> arrayName;
arrayName = new ArrayList<ClassName>();

අරාව වෙත අගයන් පවරන්න:

arrayName.add(new ClassName(class parameters go here);

අරාවෙන් කියවන්න:

ClassName variableName = arrayName.get(index);

සටහන:

variableNameඅරාව වෙත යොමු කිරීම variableNameයනු හැසිරවීම හසුරුවනු ඇති බවයිarrayName

ලූප සඳහා:

//repeats for every value in the array
for (ClassName variableName : arrayName){
}
//Note that using this for loop prevents you from editing arrayName

ඔබට සංස්කරණය කිරීමට ඉඩ දෙන ලූප සඳහා arrayName(සාම්ප්‍රදායික ලූප සඳහා):

for (int i = 0; i < arrayName.size(); i++){
    //manipulate array here
}

ජාවා 8 සහ පසුව ප්‍රකාශ කරන්න සහ ආරම්භ කරන්න. සරල පූර්ණ සංඛ්‍යා පෙළක් සාදන්න:

int [] a1 = IntStream.range(1, 20).toArray();
System.out.println(Arrays.toString(a1));
// Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

[-50, 50] සහ ද්විත්ව [0, 1E17] අතර පූර්ණ සංඛ්‍යා සඳහා අහඹු අරාවක් සාදන්න:

int [] a2 = new Random().ints(15, -50, 50).toArray();
double [] a3 = new Random().doubles(5, 0, 1e17).toArray();

බලයේ දෙකේ අනුක්‍රමය:

double [] a4 = LongStream.range(0, 7).mapToDouble(i -> Math.pow(2, i)).toArray();
System.out.println(Arrays.toString(a4));
// Output: [1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0]

String [] සඳහා ඔබ ඉදිකිරීම්කරුවෙකු නියම කළ යුතුය:

String [] a5 = Stream.generate(()->"I will not squeak chalk").limit(5).toArray(String[]::new);
System.out.println(Arrays.toString(a5));

බහුමානීය අරා:

String [][] a6 = List.of(new String[]{"a", "b", "c"} , new String[]{"d", "e", "f", "g"})
    .toArray(new String[0][]);
System.out.println(Arrays.deepToString(a6));
// Output: [[a, b, c], [d, e, f, g]]

ArrayList ප්‍රකාශ කිරීමට සහ ආරම්භ කිරීමට තවත් ක්‍රමයක්:

private List<String> list = new ArrayList<String>(){{
    add("e1");
    add("e2");
}};

මෙහි පිළිතුරු ගොඩක් තිබේ. මම අරා නිර්මාණය කිරීම සඳහා උපක්‍රමශීලී ක්‍රම කිහිපයක් එකතු කරමි ( විභාග දෘෂ්ටි කෝණයකින් මෙය දැන ගැනීම හොඳය)

1. අරාවක් ප්‍රකාශ කර අර්ථ දක්වන්න

   int intArray[] = new int[3];

   මෙය දිග 3 ක අරාවක් නිර්මාණය කරයි. එය ප්‍රාථමික වර්ගයක් වන int හි ඇති බැවින් සියලු අගයන් පෙරනිමියෙන් 0 ලෙස සකසා ඇත. උදාහරණයක් වශයෙන්,

   intArray[2]; // Will return 0

2. විචල්ය නාමයට පෙර කොටු වරහන් භාවිතා කිරීම []

   int[] intArray = new int[3];
   intArray[0] = 1;  // Array content is now {1, 0, 0}

3. අරාව සඳහා දත්ත ආරම්භ කිරීම සහ සැපයීම

   int[] intArray = new int[]{1, 2, 3};

   මෙවර කොටු වරහනෙහි ප්‍රමාණය සඳහන් කිරීමේ අවශ්‍යතාවයක් නොමැත. මෙහි සරල ප්‍රභේදයක් පවා:

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

4. දිග 0 අරාව

   int[] intArray = new int[0];
   int length = intArray.length; // Will return length 0

   බහු-මාන අරා සඳහා සමාන වේ

   int intArray[][] = new int[2][3];
   // This will create an array of length 2 and
   //each element contains another array of length 3.
   // { {0,0,0},{0,0,0} }
   int lenght1 = intArray.length; // Will return 2
   int length2 = intArray[0].length; // Will return 3

විචල්‍යයට පෙර කොටු වරහන් භාවිතා කිරීම:

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

ඔබ එක් කොටු වරහනක් අවසානයේ තැබුවහොත් එය ඉතා හොඳයි:

    int[] intArray [] = new int[2][4];
    int[] intArray[][] = new int[2][3][4]

උදාහරණ කිහිපයක්

    int [] intArray [] = new int[][] {{1,2,3},{4,5,6}};
    int [] intArray1 [] = new int[][] {new int[] {1,2,3}, new int [] {4,5,6}};
    int [] intArray2 [] = new int[][] {new int[] {1,2,3},{4,5,6}}
    // All the 3 arrays assignments are valid
    // Array looks like {{1,2,3},{4,5,6}}

සෑම අභ්‍යන්තර මූලද්‍රව්‍යයක්ම එකම ප්‍රමාණයෙන් තිබීම අනිවාර්ය නොවේ.

    int [][] intArray = new int[2][];
    intArray[0] = {1,2,3};
    intArray[1] = {4,5};
    //array looks like {{1,2,3},{4,5}}

    int[][] intArray = new int[][2] ; // This won't compile. Keep this in mind.

ඔබ ඉහත වාක්‍ය ඛණ්ඩය භාවිතා කරන්නේද යන්න තහවුරු කර ගත යුතුය, ඉදිරි දිශාවට කොටු වරහන් වල අගයන් නියම කළ යුතුය. නැතහොත් එය සම්පාදනය නොකරනු ඇත. උදාහරණ කිහිපයක්:

    int [][][] intArray = new int[1][][];
    int [][][] intArray = new int[1][2][];
    int [][][] intArray = new int[1][2][3];

තවත් වැදගත් ලක්ෂණයක් වන්නේ කෝවරියන්ට් ය

    Number[] numArray = {1,2,3,4};   // java.lang.Number
    numArray[0] = new Float(1.5f);   // java.lang.Float
    numArray[1] = new Integer(1);    // java.lang.Integer
   // You can store a subclass object in an array that is declared
   // to be of the type of its superclass.
   // Here 'Number' is the superclass for both Float and Integer.

   Number num[] = new Float[5]; // This is also valid

වැදගත්: යොමු කරන ලද වර්ග සඳහා, අරාවෙහි ගබඩා කර ඇති පෙරනිමි අගය ශුන්‍ය වේ.

ඔබට මෙය ද කළ හැකිය java.util.Arrays:

List<String> number = Arrays.asList("1", "2", "3");

Out: ["1", "2", "3"]

මෙය ඉතා සරල හා සරල ය.

අරේට මූලික වර්ග දෙකක් තිබේ.

ස්ථිතික අරාව: ස්ථාවර ප්‍රමාණයේ අරාව (එහි ප්‍රමාණය ආරම්භයේදීම ප්‍රකාශ කළ යුතු අතර පසුව වෙනස් කළ නොහැක)

ගතික අරාව: මේ සඳහා ප්‍රමාණයේ සීමාවක් නොසැලකේ. (පිරිසිදු ගතික අරා ජාවා හි නොපවතී. ඒ වෙනුවට, ලැයිස්තුව වඩාත් දිරිමත් කරනු ලැබේ)

පූර්ණ සංඛ්‍යා, නූල්, පාවෙන යනාදියෙහි ස්ථිතික පෙළක් ප්‍රකාශ කිරීමට ... සීනුව ප්‍රකාශනය සහ ආරම්භක ප්‍රකාශ භාවිතා කරන්න.

    int[] intArray = new int[10]; 
    String[] intArray = new int[10]; 
    float[] intArray = new int[10]; 
    
   // here you have 10 index starting from 0 to 9

ගතික ලක්ෂණ භාවිතා කිරීම සඳහා, ඔබ ලැයිස්තුව භාවිතා කළ යුතුය ... ලැයිස්තුව පිරිසිදු ගතික අරාව වන අතර ආරම්භයේ ප්‍රමාණය ප්‍රකාශ කිරීමට අවශ්‍ය නොවේ. JAVA> හි ලැයිස්තුවක් ප්‍රකාශ කිරීමට සුදුසුම ක්‍රමය බෙලෝ ය

        ArrayList<String> myArray = new ArrayList<String>();
        myArray.add("Value 1: something");
        myArray.add("Value 2: something more");

දේශීය විචල්‍ය වර්ග අනුමාන කිරීම් සමඟ ඔබට එක් වරක් පමණක් නියම කළ යුතුය:

var values = new int[] { 1, 2, 3 };

හෝ

int[] values = { 1, 2, 3 }

අරාව ප්‍රකාශ කරන්න: int[] arr;

අරාව ආරම්භ කරන්න: int[] arr = new int[10]; 10 නිරූපණය කරන්නේ අරාවෙහි ඉඩ දී ඇති මූලද්‍රව්‍ය ගණනයි

බහුවිධ අරා ප්‍රකාශ කරන්න: int[][] arr;

බහුමානීය අරාව ආරම්භ කරන්න: int[][] arr = new int[10][17];පේළි 10 ක් සහ තීරු 17 ක් සහ මූලද්‍රව්‍ය 170 ක් 10 ගුණයක් 17 ක් 170 ක් වන නිසා.

අරාව ආරම්භ කිරීම යනු එහි ප්‍රමාණය නියම කිරීමයි.

අරාව ප්‍රකාශ කිරීම සහ ආරම්භ කිරීම ඉතා පහසුය. උදාහරණයක් ලෙස, 1, 2, 3, 4, සහ 5 වන පූර්ණ සංඛ්‍යා මූලද්‍රව්‍ය 5 ක් අරාව තුළ සුරැකීමට ඔබට අවශ්‍යය. ඔබට එය පහත ආකාරයෙන් කළ හැකිය:

ඒ)

int[] a = new int[5];

හෝ

බී)

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

එබැවින් මූලික රටාව වන්නේ ක්‍රමවේදය අනුව ආරම්භ කිරීම සහ ප්‍රකාශ කිරීම ය.

datatype[] arrayname = new datatype[requiredarraysize];

datatype කුඩා අකුරින් විය යුතුය.

එබැවින් මූලික රටාව වන්නේ ක්‍රමවේදය අනුව ආරම්භ කිරීම සහ ප්‍රකාශ කිරීම ය:

එය නූල් අරාවක් නම්:

String[] a = {"as", "asd", "ssd"};

එය අක්ෂර මාලාවක් නම්:

char[] a = {'a', 's', 'w'};

පාවෙන ද්විත්ව සඳහා, අරාවෙහි ආකෘතිය පූර්ණ සංඛ්‍යාවට සමාන වේ.

උදාහරණයක් වශයෙන්:

double[] a = {1.2, 1.3, 12.3};

නමුත් ඔබ "ක්‍රමවේදය" මඟින් අරාව ප්‍රකාශ කර ආරම්භ කරන විට ඔබට අතින් හෝ ලූපයකින් හෝ වෙනත් දෙයකින් අගයන් ඇතුළත් කළ යුතුය.

නමුත් ඔබ එය "ක්‍රමය b" මඟින් කරන විට ඔබට අගයන් අතින් ඇතුලත් කිරීමට සිදු නොවේ.

අරාවෙහි ප්‍රාථමික දත්ත වර්ග මෙන්ම අරාවෙහි අර්ථ දැක්වීම අනුව පන්තියක වස්තු ද අඩංගු විය හැකිය. ප්‍රාථමික දත්ත වර්ග සම්බන්ධයෙන්, සත්‍ය අගයන් පරස්පර මතක ස්ථානවල ගබඩා කර ඇත. පංතියක වස්තූන් සම්බන්ධයෙන්, සත්‍ය වස්තූන් ගොඩවල් කොටසේ ගබඩා වේ.

ඒක මාන අරා:
ඒක මාන අරාව ප්‍රකාශනයේ සාමාන්‍ය ස්වරූපය

type var-name[];
OR
type[] var-name;

ජාවා හි අරා ස්ථාපනය කිරීම

var-name = new type [size];

උදාහරණයක් වශයෙන්

    int intArray[];    //declaring array
    intArray = new int[20];  // allocating memory to array
    // the below line is equals to line1 + line2
    int[] intArray = new int[20]; // combining both statements in one
     int[] intArray = new int[]{ 1,2,3,4,5,6,7,8,9,10 }; 
    // accessing the elements of the specified array
    for (int i = 0; i < intArray.length; i++)
    System.out.println("Element at index " + i + " : "+ intArray[i]);

Ref: https://www.geeksforgeeks.org/arrays-in-java/

int[] x=new int[enter the size of array here];

උදාහරණයක්:

int[] x=new int[10];

හෝ

int[] x={enter the elements of array here];

උදාහරණයක්:

int[] x={10,65,40,5,48,31};

චිත්‍රපට පන්තිය සමඟ එකිනෙකාට සම්පූර්ණ උදාහරණය

public class A {

        public static void main(String[] args) {

                class Movie{

                    String movieName;
                    String genre;
                    String movieType;
                    String year;
                    String ageRating;
                    String rating;

                    public Movie(String [] str)
                    {
                        this.movieName = str[0];
                        this.genre = str[1];
                        this.movieType = str[2];
                        this.year = str[3];
                        this.ageRating = str[4];
                        this.rating = str[5];    
                    }

                }

                String [] movieDetailArr = {"Inception", "Thriller", "MovieType", "2010", "13+", "10/10"};

                Movie mv = new Movie(movieDetailArr);

                System.out.println("Movie Name: "+ mv.movieName);
                System.out.println("Movie genre: "+ mv.genre);
                System.out.println("Movie type: "+ mv.movieType);
                System.out.println("Movie year: "+ mv.year);
                System.out.println("Movie age : "+ mv.ageRating);
                System.out.println("Movie  rating: "+ mv.rating);


            }

        } 

int[] SingleDimensionalArray = new int[2]

int[][] MultiDimensionalArray = new int[3][4]