జావాలో మ్యాట్రిక్స్ / 2డి అర్రే అంటే ఏమిటి?
"మాతృక అనేది వరుసలు మరియు నిలువు వరుసల స్థిర సంఖ్యలో అమర్చబడిన సంఖ్యల సమాహారం." సాధారణంగా ఇవి వాస్తవ సంఖ్యలు. సాధారణంగా, మాత్రికలు సంక్లిష్ట సంఖ్యలను కలిగి ఉండవచ్చు కానీ సరళత కొరకు మేము ఇక్కడ పూర్ణ సంఖ్యలను మాత్రమే ఉపయోగిస్తాము. మ్యాట్రిక్స్ ఎలా ఉంటుందో చూద్దాం. 4 అడ్డు వరుసలు మరియు 4 నిలువు వరుసలతో కూడిన మాతృక యొక్క ఉదాహరణ ఇక్కడ ఉంది.
2D శ్రేణిని ప్రకటించండి & ప్రారంభించండి
శ్రేణి యొక్క పరిమాణాన్ని మాత్రమే ప్రకటించడానికి లేదా పరిమాణాన్ని పేర్కొనకుండా దాన్ని ప్రారంభించేందుకు ఇక్కడ కొన్ని విభిన్న మార్గాలు ఉన్నాయి.
public class Matrices {
public static void main(String[] args) {
// declare & initialize 2D arrays for int and string
int[][] matrix1 = new int[2][2];
int matrix2[][] = new int[2][3];
//the size of matrix3 will be 4x4
int[][] matrix3 = { { 3, 2, 1, 7 },
{ 9, 11, 5, 4 },
{ 6, 0, 13, 17 },
{ 7, 21, 14, 15 } };
String[][] matrix4 = new String[2][2];
//the size of matrix5 will be 2x3
// 3 cols because at max there are 3 columns
String[][] matrix5 = { { "a", "lion", "meo" },
{ "jaguar", "hunt" } };
}
}
2D అర్రే ట్రావర్సల్
జావాలో సాధారణ శ్రేణులను ఎలా ప్రయాణించాలో మనందరికీ తెలుసు. 2D శ్రేణుల కోసం ఇది కూడా కష్టం కాదు. దీని కోసం మనం సాధారణంగా నెస్టెడ్ 'ఫర్' లూప్‌లను ఉపయోగిస్తాము. కొంతమంది ప్రారంభకులు దీనిని గ్రహాంతర భావనగా భావించవచ్చు, కానీ మీరు దానిని లోతుగా త్రవ్విన వెంటనే మీరు దీన్ని కొంత అభ్యాసంతో అమలు చేయగలుగుతారు. కింది స్నిప్పెట్‌ని చూడండి. ఇది మీ సంపూర్ణ అవగాహన కోసం ప్రతి అడ్డు వరుసకు సంబంధించిన నిలువు వరుసల సంఖ్యను మాత్రమే ప్రదర్శిస్తుంది.
public class MatrixTraversal {
public static void main(String[] args) {
int[][] matrix = new int[4][4];
for (int i = 0; i < matrix.length; i++)
{
// length returns number of rows
System.out.print("row " + i + " : ");
for (int j = 0; j < matrix[i].length; j++)
{
// here length returns # of columns corresponding to current row
System.out.print("col " + j + " ");
}
System.out.println();
}
}
}
వరుస 0 : col 0 col 1 col 2 col 3 row 1 : col 0 col 1 col 2 col 3 row 2 : col 0 col 1 col 2 col 3 row 3 : col 0 col 1 col 2 col 3
జావాలో 2డి అర్రేని ఎలా ప్రింట్ చేయాలి?
మీకు 2D అర్రే ట్రావర్సల్ గురించి బాగా తెలిసిన తర్వాత, జావాలో 2D శ్రేణులను ముద్రించడానికి కొన్ని మార్గాలను చూద్దాం.నెస్టెడ్ “ఫర్” లూప్‌ని ఉపయోగించడం
జావాలో మాతృకను ముద్రించడానికి ఇది అత్యంత ప్రాథమిక మార్గం.
public class MatrixTraversal {
public static void printMatrix(int matrix[][])
{
for (int i = 0; i < matrix.length; i++)
{
// length returns number of rows
for (int j = 0; j < matrix[i].length; j++)
{
// here length returns number of columns corresponding to current row
// using tabs for equal spaces, looks better aligned
// matrix[i][j] will return each element placed at row ‘i',column 'j'
System.out.print( matrix[i][j] + "\t");
}
System.out.println();
}
}
public static void main(String[] args) {
int[][] matrix = { { 3, 2, 1, 7 },
{ 9, 11, 5, 4 },
{ 6, 0, 13, 17 },
{ 7, 21, 14, 15 } };
printMatrix(matrix);
}
}
3 2 1 7 9 11 5 4 6 0 13 17 7 21 14 15
"ప్రతి కోసం" లూప్ ఉపయోగించి
“ ఫోరీచ్ లూప్ ” ఉపయోగించి జావాలో 2D శ్రేణులను ప్రింట్ చేయడానికి ఇక్కడ మరొక మార్గం ఉంది . ఇది జావా అందించిన ప్రత్యేక రకం లూప్, ఇక్కడ మాతృకలోని ప్రతి అడ్డు వరుస ద్వారా పూర్ణ[]వరుస లూప్ అవుతుంది. అయితే, వేరియబుల్ “మూలకం” అడ్డు వరుస ద్వారా నిలువు వరుస సూచిక వద్ద ఉంచబడిన ప్రతి మూలకాన్ని కలిగి ఉంటుంది.
public class MatrixTraversal {
public static void printMatrix(int matrix[][]){
for (int [] row : matrix)
{
// traverses through number of rows
for (int element : row)
{
// 'element' has current element of row index
System.out.print( element + "\t");
}
System.out.println();
}
}
public static void main(String[] args) {
int[][] matrix = { { 3, 2, 1, 7 },
{ 9, 11, 5, 4 },
{ 6, 0, 13, 17 },
{ 7, 21, 14, 15 } };
printMatrix(matrix);
}
}
3 2 1 7 9 11 5 4 6 0 13 17 7 21 14 15
“Arays.toString()” పద్ధతిని ఉపయోగించడం
జావాలో Arrays.toString() పద్ధతి, దానికి పంపబడిన ప్రతి పరామితిని ఒకే శ్రేణిగా మారుస్తుంది మరియు దానిని ప్రింట్ చేయడానికి దాని బిల్ట్ ఇన్ పద్ధతిని ఉపయోగిస్తుంది. మేము చుట్టూ ప్లే చేయడానికి డమ్మీ స్ట్రింగ్ 2D శ్రేణిని సృష్టించాము. పూర్ణాంక శ్రేణుల కోసం కూడా ఇదే పద్ధతి పనిచేస్తుంది. మీ వ్యాయామం కోసం దీన్ని సాధన చేయమని మేము మిమ్మల్ని ప్రోత్సహిస్తున్నాము.
import java.util.Arrays;
public class MatrixTraversal {
public static void printMatrix(String matrix[][]){
for (String[] row : matrix) {
// convert each row to a String before printing
System.out.println(Arrays.toString(row));
}
}
public static void main(String[] args) {
String [][] matrix = { { "Hi, I am Karen" },
{ "I'm new to Java"},
{ "I love swimming" },
{ "sometimes I play keyboard"} };
printMatrix(matrix);
}
}
[హాయ్, నేను కరెన్] [నేను జావాకు కొత్త] [నాకు స్విమ్మింగ్ అంటే ఇష్టం] [కొన్నిసార్లు నేను కీబోర్డ్ ప్లే చేస్తాను]
GO TO FULL VERSION