আমি জাভাতে কোনও অ্যারে কীভাবে ঘোষণা এবং শুরু করব?
উত্তর:
আপনি হয় অ্যারে ডিক্লেয়ারেশন বা অ্যারে আক্ষরিক ব্যবহার করতে পারেন (তবে কেবলমাত্র আপনি যখন ভেরিয়েবলটি ঘোষণা এবং প্রভাবিত করবেন কেবল তখনই অ্যারে লিটারালগুলি অ্যারে পুনরায় বরাদ্দকরণের জন্য ব্যবহার করা যাবে না)।
আদিম ধরণের জন্য:
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"};
আপনি প্রথমে অ্যারে ঘোষণা করার পরে এটি আরম্ভ করার সময় তৃতীয় উপায়টি আরম্ভ করার উপযোগী। Theালাই এখানে প্রয়োজনীয়।
String[] myStringArray;
myStringArray = new String[]{"a", "b", "c"};
return {1,2,3}সময় একটি ত্রুটি দেয় return new int[]{1,2,3}(অবশ্যই ধরে নেওয়া যে আপনার ফাংশনটি একটি পূর্ণসংখ্যার অ্যারে প্রদান করে)।
অ্যারে দুই ধরণের হয়।
ডিফল্ট মানগুলির জন্য সিনট্যাক্স:
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 [] সংখ্যাটি পছন্দনীয় কারণ এটি স্পষ্টভাবে জানিয়েছে যে আপনি এখানে অ্যারে সম্পর্কে কথা বলছেন। অন্যথায় কোন পার্থক্য। একদমই না.
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};
এছাড়াও বৈধ, তবে আমি টাইপটির পরে বন্ধনীগুলি পছন্দ করি কারণ ভেরিয়েবলের ধরণটি আসলে একটি অ্যারে হয় তা দেখতে আরও সহজ।
int[] a, b;হবে না int a[], b;, আপনি যদি পরবর্তী ফর্মটি ব্যবহার করেন তবে ভুল করা সহজ।
বিভিন্ন জাভাতে আপনি জাভাতে একটি অ্যারে ঘোষণা করতে পারেন:
float floatArray[]; // Initialize later
int[] integerArray = new int[10];
String[] array = new String[] {"a", "b"};
আপনি সান টিউটোরিয়াল সাইট এবং জাভাডক আরও তথ্য পেতে পারেন ।
আপনি প্রতিটি অংশ বুঝতে পারলে আমি এটি সহায়ক বলে মনে করি:
Type[] name = new Type[5];Type[]হয় টাইপ এর ভেরিয়েবল নাম ( "নাম" বলা হয় আইডেন্টিফায়ার )। আক্ষরিক "প্রকার" হ'ল বেস প্রকার, এবং বন্ধনী মানেই এটি সেই বেসের অ্যারে প্রকার। অ্যারে প্রকারগুলি তাদের নিজস্ব পালা টাইপ হয়, যা আপনাকে বহুমাত্রিক অ্যারেগুলি Type[][](অ্যারের প্রকারের প্রকার []) তৈরি করতে দেয়। শব্দ newনতুন অ্যারে জন্য মেমরি বরাদ্দ করা বলছেন। বন্ধনীটির মধ্যে সংখ্যাটি বলে যে নতুন অ্যারে কত বড় হবে এবং কত মেমরি বরাদ্দ করতে হবে। উদাহরণস্বরূপ, জাভা যদি জানেন যে বেস টাইপটি Type32 বাইট নেয় এবং আপনি 5 আকারের অ্যারে চান তবে এটি অভ্যন্তরীণভাবে 32 * 5 = 160 বাইট বরাদ্দ করতে হবে।
আপনি ইতিমধ্যে সেখানে মানগুলি সহ অ্যারে তৈরি করতে পারেন
int[] name = {1, 2, 3, 4, 5};যা কেবল খালি স্থান তৈরি করে না তবে এটি সেই মানগুলি পূরণ করে। জাভা বলতে পারে যে আদিমগুলি পূর্ণসংখ্যা এবং এর মধ্যে 5 টি রয়েছে, সুতরাং অ্যারের আকারটি অন্তর্নিহিতভাবে নির্ধারণ করা যেতে পারে।
int[] name = new int[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" );Listএকটি জেনেরিক ক্লাস, এটি প্যারামিটার হিসাবে একধরনের সাথে আবদ্ধ <>। এটি আপনাকে সাহায্য করে কারণ আপনার কেবল একবার জেনেরিক ধরণের সংজ্ঞা দেওয়া দরকার এবং এরপরে আপনি এটি একাধিক বিভিন্ন ধরণের মাধ্যমে ব্যবহার করতে পারেন। এ সম্বন্ধে বিশদ বিবরণের টি দেখতে docs.oracle.com/javase/tutorial/java/generics/types.html
অ্যারে করার দুটি প্রধান উপায় রয়েছে:
এটি একটি, খালি অ্যারের জন্য:
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[]। তবে এটি কারণ আপনি একটি পরিবর্তনশীল ঘোষণা করছেন are যখন একটি পদ্ধতি একটি অ্যারের ক্ষণস্থায়ী, ঘোষণা পারেন হওয়া আবশ্যক new Type[capacity]বা new Type[] {...}।
বহুমাত্রিক অ্যারেগুলি মোকাবেলা করা বেশ শক্ত। মূলত, একটি 2D অ্যারে অ্যারের অ্যারে। 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]বিভিন্ন 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]লোকাল ভেরিয়েবল টাইপ ইনফারেন্স ব্যবহার করে :
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, যেহেতু প্রতিটি অ্যারের একটি রেফারেন্স থাকে এবং এম-ডাইমেনশনে একটি (এম -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 [] 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]]অ্যারেলিস্ট ঘোষণা এবং আরম্ভ করার আরেকটি উপায়:
private List<String> list = new ArrayList<String>(){{
add("e1");
add("e2");
}};এখানে অনেক উত্তর আছে। আমি অ্যারে তৈরির জন্য কয়েকটি কৌশলগত উপায় যুক্ত করছি ( পরীক্ষার দৃষ্টিকোণ থেকে এটি জেনে রাখা ভাল)
অ্যারে ঘোষণা এবং সংজ্ঞা দিন
int intArray[] = new int[3];এটি দৈর্ঘ্যের একটি অ্যারে তৈরি করবে 3 এটি একটি আদিম ধরণের ধারণ হিসাবে, int হিসাবে সমস্ত মানগুলি ডিফল্টরূপে 0 তে সেট করা থাকে। উদাহরণ স্বরূপ,
intArray[2]; // Will return 0ভেরিয়েবল নামের আগে বক্স বন্ধনীগুলি [] ব্যবহার করা
int[] intArray = new int[3];
intArray[0] = 1; // Array content is now {1, 0, 0}আরে শুরু করে ডেটা সরবরাহ করুন
int[] intArray = new int[]{1, 2, 3};এবার বক্স ব্র্যাকেটে আকারটি উল্লেখ করার দরকার নেই। এমনকি এর একটি সহজ রূপটি হ'ল:
int[] intArray = {1, 2, 3, 4};দৈর্ঘ্যের একটি অ্যারে
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"]এই এক বেশ সহজ এবং সোজা।
স্থানীয় পরিবর্তনশীল প্রকারের অনুক্রমের সাথে আপনাকে কেবল একবার টাইপ নির্দিষ্ট করতে হবে:
var values = new int[] { 1, 2, 3 };অথবা
int[] values = { 1, 2, 3 }var।
var ওপেনজেডকে.জাভা.এন.এ.
অ্যারের দুটি প্রাথমিক ধরণ রয়েছে।
স্ট্যাটিক অ্যারে: স্থির আকারের অ্যারে (এর আকার শুরুতে ঘোষণা করা উচিত এবং পরে পরিবর্তন করা যাবে না)
গতিশীল অ্যারে: এর জন্য কোনও আকারের সীমা বিবেচনা করা হয় না। (জাভাতে খাঁটি গতিশীল অ্যারেগুলির অস্তিত্ব নেই Instead পরিবর্তে, তালিকাটি সর্বাধিক উত্সাহিত)
পূর্ণসংখ্যার স্ট্যাটিক অ্যারে, স্ট্রিং, ফ্লোট ইত্যাদি ঘোষণা করতে ... বেলো ডিক্লেয়ারেশন এবং ইনিশিয়ালাইজেশন স্টেটমেন্ট ব্যবহার করুন।
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গতিশীল বৈশিষ্ট্যগুলি ব্যবহার করতে, আপনাকে তালিকা ব্যবহার করতে হবে ... তালিকাটি খাঁটি গতিশীল অ্যারে এবং শুরুতে আকারটি ঘোষণা করার দরকার নেই। জেওএ> এ তালিকা ঘোষণা করার উপযুক্ত উপায় হ'ল বেলো
ArrayList<String> myArray = new ArrayList<String>();
myArray.add("Value 1: something");
myArray.add("Value 2: something more");অ্যারে ঘোষণা করুন: int[] arr;
অ্যারে শুরু করুন: int[] arr = new int[10];10 অ্যারেটিতে অনুমোদিত উপাদানগুলির সংখ্যা উপস্থাপন করে
বহুমাত্রিক অ্যারে ঘোষণা করুন: int[][] arr;
বহুমাত্রিক অ্যারে শুরু করুন: int[][] arr = new int[10][17];10 টি সারি এবং 17 কলাম এবং 170 উপাদান কারণ 10 বার 17 হয় 170।
অ্যারে শুরু করার অর্থ এর আকার নির্দিষ্ট করা ifying
এটি অ্যারে ঘোষণা করা এবং শুরু করা খুব সহজ। উদাহরণস্বরূপ, আপনি পাঁচটি পূর্ণসংখ্যার উপাদানগুলি সংরক্ষণ করতে চান যা অ্যারেতে 1, 2, 3, 4, এবং 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};কিন্তু আপনি যখন "পদ্ধতি একটি" দ্বারা অ্যারে ঘোষণা এবং আরম্ভ করবেন তখন আপনাকে ম্যানুয়ালি বা লুপ বা কোনও কিছু দিয়ে মানগুলি প্রবেশ করতে হবে।
আপনি যখন "পদ্ধতি বি" দ্বারা এটি করেন তখন আপনাকে মানগুলি ম্যানুয়ালি প্রবেশ করতে হবে না।
অ্যারেতে অ্যারের সংজ্ঞা অনুসারে প্রাথমিক শ্রেণির ডেটা পাশাপাশি কোনও শ্রেণীর অবজেক্ট থাকতে পারে। আদিম উপাত্তের ধরণের ক্ষেত্রে, আসল মানগুলি সামঞ্জস্যপূর্ণ মেমরির স্থানে সংরক্ষণ করা হয়। কোনও শ্রেণীর অবজেক্টের ক্ষেত্রে আসল বস্তুগুলি হিপ সেগমেন্টে সঞ্চিত থাকে।
এক-মাত্রিক অ্যারে:
এক-মাত্রিক অ্যারে ঘোষণার সাধারণ রূপ
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]);মুভি ক্লাস with সহ একে অপরের পুরো উদাহরণ 😋
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[] array1= new int[3];
int[] array2= {1, 2, 3};
int[] array3= new int[]{1, 2, 3};int[] SingleDimensionalArray = new int[2]
int[][] MultiDimensionalArray = new int[3][4]