बहुआयामी सरणी घोषित करने और उसे मान प्रदान करने का सही तरीका क्या है?
यह वही है जो मेरे पास है:
int x = 5;
int y = 5;
String[][] myStringArray = new String [x][y];
myStringArray[0][x] = "a string";
myStringArray[0][y] = "another string";
जवाबों:
उपयुक्त पंक्तियों को बदलने का प्रयास करें:
myStringArray[0][x-1] = "a string";
myStringArray[0][y-1] = "another string";
क्योंकि उप सरणियों की लंबाई है आपका कोड गलत है yके लिए सेटिंग तो 0. पर, और अनुक्रमण शुरू होता है myStringArray[0][y]या myStringArray[0][x]क्योंकि सूचकांक असफल हो जायेगी xऔर yसीमा से बाहर हैं।
String[][] myStringArray = new String [x][y];आयताकार बहुआयामी सरणी को इनिशियलाइज़ करने का सही तरीका है। यदि आप चाहते हैं कि यह दांतेदार हो (प्रत्येक उप-सरणी में संभावित रूप से एक अलग लंबाई है) तो आप इस उत्तर के समान कोड का उपयोग कर सकते हैं । हालांकि ध्यान दें कि जॉन का दावा है कि आपको उप-सरणियों को मैन्युअल रूप से बनाना होगा उस मामले में गलत है जहां आप एक बिल्कुल आयताकार बहुआयामी सरणी चाहते हैं।
जावा में "सच" बहुआयामी सरणियाँ नहीं हैं।
उदाहरण के लिए, arr[i][j][k]के बराबर है ((arr[i])[j])[k]। दूसरे शब्दों में, सरणियों का, सारणियोंarr का मात्र एक सरणी है ।
इसलिए, यदि आप जानते हैं कि सरणियाँ कैसे काम करती हैं, तो आप जानते हैं कि बहुआयामी सरणियाँ कैसे काम करती हैं!
घोषणा:
int[][][] threeDimArr = new int[4][5][6];
या, आरंभीकरण के साथ:
int[][][] threeDimArr = { { { 1, 2 }, { 3, 4 } }, { { 5, 6 }, { 7, 8 } } };
पहुंच:
int x = threeDimArr[1][0][1];
या
int[][] row = threeDimArr[1];
स्ट्रिंग प्रतिनिधित्व:
Arrays.deepToString(threeDimArr);
पैदावार
"[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]"
int[i][j][k]की लंबाई है i, इसलिए वास्तव में यह एक के बराबर है ((int[k])[j])[i]। घोषणा में आकार प्रकारों के संबंध में पीछे की ओर लिखे गए हैं, मुझे लगता है कि गणित में बहुआयामी सरणियों को अधिक निकटता से तैयार किया जाता है।
आप बहु आयामी सरणियों की घोषणा कर सकते हैं जैसे:
// 4 x 5 String arrays, all Strings are null
// [0] -> [null,null,null,null,null]
// [1] -> [null,null,null,null,null]
// [2] -> [null,null,null,null,null]
// [3] -> [null,null,null,null,null]
String[][] sa1 = new String[4][5];
for(int i = 0; i < sa1.length; i++) { // sa1.length == 4
for (int j = 0; j < sa1[i].length; j++) { //sa1[i].length == 5
sa1[i][j] = "new String value";
}
}
// 5 x 0 All String arrays are null
// [null]
// [null]
// [null]
// [null]
// [null]
String[][] sa2 = new String[5][];
for(int i = 0; i < sa2.length; i++) {
String[] anon = new String[ /* your number here */];
// or String[] anon = new String[]{"I'm", "a", "new", "array"};
sa2[i] = anon;
}
// [0] -> ["I'm","in","the", "0th", "array"]
// [1] -> ["I'm", "in", "another"]
String[][] sa3 = new String[][]{ {"I'm","in","the", "0th", "array"},{"I'm", "in", "another"}};
जावा नहीं करता है वास्तव में बहुआयामी सरणियों समर्थन करते हैं। जावा में, एक द्वि-आयामी सरणी केवल सरणियों का एक सरणी है, एक त्रि-आयामी सरणी सरणियों के सरणी का एक सरणी है, एक चार-आयामी सरणी सरणियों के सरणियों का एक सरणी है, और इसी तरह ...
हम दो आयामी सरणी को परिभाषित कर सकते हैं:
int[ ] num[ ] = {{1,2}, {1,2}, {1,2}, {1,2}}
int[ ][ ] num = new int[4][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[2][1]बताते हैं , यह आरंभिक नहीं है और फिर इसे स्वचालित रूप से 0 आवंटित किया जाता है, अर्थात् num[2][1] = 0;
नीचे, num1.lengthआप पंक्तियाँ देता है।
जबकि num1[0].lengthआपको संबंधित तत्वों की संख्या देता है num1[0]। यहाँ num1[0]संबंधित सरणियाँ num1[0][0]और num[0][1]केवल है।
यहां हमने एक forलूप का उपयोग किया जो हमें गणना करने में मदद करता है num1[i].length। यहाँ iएक लूप के माध्यम से वेतन वृद्धि की जाती है।
class array
{
static int[][] add(int[][] num1,int[][] num2)
{
int[][] temp = new int[num1.length][num1[0].length];
for(int i = 0; i<temp.length; i++)
{
for(int j = 0; j<temp[i].length; j++)
{
temp[i][j] = num1[i][j]+num2[i][j];
}
}
return temp;
}
public static void main(String args[])
{
/* We can define a two-dimensional array as
1. int[] num[] = {{1,2},{1,2},{1,2},{1,2}}
2. int[][] num = new int[4][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;
If you don't allocate let's say num[2][1] is
not initialized, and then it is automatically
allocated 0, that is, automatically num[2][1] = 0;
3. Below num1.length gives you rows
4. While num1[0].length gives you number of elements
related to num1[0]. Here num1[0] has related arrays
num1[0][0] and num[0][1] only.
5. Here we used a 'for' loop which helps us to calculate
num1[i].length, and here i is incremented through a loop.
*/
int num1[][] = {{1,2},{1,2},{1,2},{1,2}};
int num2[][] = {{1,2},{1,2},{1,2},{1,2}};
int num3[][] = add(num1,num2);
for(int i = 0; i<num1.length; i++)
{
for(int j = 0; j<num1[j].length; j++)
System.out.println("num3[" + i + "][" + j + "]=" + num3[i][j]);
}
}
}
मैं जोड़ता हूँ कि यदि आप आयाम पढ़ना चाहते हैं, तो आप यह कर सकते हैं:
int[][][] a = new int[4][3][2];
System.out.println(a.length); // 4
System.out.println(a[0].length); // 3
System.out.println(a[0][0].length); //2
आप दांतेदार ऐरे भी कर सकते हैं , जहां विभिन्न पंक्तियों में अलग-अलग लंबाई होती है, इसलिए a[0].length != a[1].length।
int[][] myNums = { {1, 2, 3, 4, 5, 6, 7}, {5, 6, 7, 8, 9, 10, 11} };
for (int x = 0; x < myNums.length; ++x) {
for(int y = 0; y < myNums[i].length; ++y) {
System.out.print(myNums[x][y]);
}
}
उत्पादन
1 2 3 4 5 6 7 5 6 7 8 9 10 11
आप इसे शुरू करने के लिए देख सकते हैं:
int [][][] i = { //third dimension curly brace
{ // second dimension curly brace
{ //first dimension curly brace
1,1,1 //elements
},
{3,3,3},
{2,2,2}
},
{
{
1,1,1
},
{3,3,3},
{2,2,2}
}
};