జావాలో శ్రేణిని ఎలా ప్రారంభించాలి



అర్రే జావా

జావాలో శ్రేణిని ఎలా ప్రారంభించాలి

జావాలోని శ్రేణులు ఒకే డేటా రకం యొక్క బహుళ విలువలను వరుస క్రమంలో నిల్వ చేసే విస్తృతంగా ఉపయోగించే డేటా నిర్మాణం. శ్రేణికి స్థిర పొడవు ఉంటుంది మరియు సూచిక 0 నుండి n-1 వరకు మొదలవుతుంది, ఇక్కడ n అనేది శ్రేణి యొక్క పొడవు. స్ట్రింగ్, పూర్ణాంకం, అక్షరం, బైట్ మరియు వినియోగదారు నిర్వచించిన వస్తువులు వంటి ఏ రకమైన విలువను నిల్వ చేయడానికి మేము జావాలో శ్రేణుల తరగతిని ఉపయోగించవచ్చు. జావాలో శ్రేణిని ఎలా ప్రారంభించాలో మేము నేర్చుకుంటాము?

11 మూలకాలను కలిగి ఉన్న పూర్ణాంకాల యొక్క ఒకే-డైమెన్షనల్ శ్రేణి యొక్క రేఖాచిత్ర ప్రాతినిధ్యం క్రింద ఉంది.

జావాలో శ్రేణులు

విషయ సూచిక

జావా శ్రేణుల లక్షణాలు

  • శ్రేణికి స్థిర పరిమాణం ఉంది మరియు మార్చబడదు
  • శ్రేణి సూచిక-ఆధారితమైనందున, యాదృచ్ఛిక అంశాలను ప్రాప్యత చేయడం సులభం
  • శ్రేణి మూలకాల కోసం నిరంతర మెమరీని కేటాయిస్తుంది.
  • రెండింటినీ నిల్వ చేయగలదు ఆదిమ మరియు ఆదిమ కాని డేటా విలువలు

జావాలో శ్రేణిని ఎలా ప్రకటించాలి?

జావా శ్రేణుల ప్రకటన

శ్రేణిని క్రింది మార్గాల్లో ప్రకటించవచ్చు. అర్రే డిక్లరేషన్ 2 భాగాలను కలిగి ఉంది, మొదట మనం శ్రేణిలో (పూర్ణాంకం, స్ట్రింగ్, మొదలైనవి) నిల్వ చేయాల్సిన మూలకాల యొక్క డేటాటైప్ మరియు తరువాత శ్రేణి పేరు. [] బ్రాకెట్‌లు ఇది శ్రేణి అని సూచిస్తాయి. మేము శ్రేణిని ప్రకటించినప్పుడు, ఇది కంపైలర్‌కు వేరియబుల్ ఒక శ్రేణి అని చెబుతుంది మరియు వాస్తవానికి శ్రేణిని సృష్టించదు.

డేటాటైప్ [] శ్రేణి పేరు; (లేదా)

డేటాటైప్ [] శ్రేణి పేరు; (లేదా)

డేటాటైప్ అర్రేనామ్ []; -> సాధారణంగా ఈ పద్ధతి చెల్లుబాటులో ఉన్నప్పటికీ దాన్ని ఉపయోగించడానికి మేము ఇష్టపడము.

శ్రేణి ప్రకటన యొక్క ఉదాహరణ

int[] arrNumbers;
String[] arrNames;
float[] arrValues;
boolean[] arrBoolean;
char[] arrLetters;
byte[] arrBytes;
double[] arrWeight;

జావాలో శ్రేణిని ఎలా సృష్టించాలి?

జావాలో స్ట్రింగ్ అర్రే

మేము ఉపయోగించి శ్రేణిని సృష్టిస్తాము కొత్త ఆపరేటర్. దీనిలో, శ్రేణి వేరియబుల్‌ను నిల్వ చేయడానికి అవసరమైన మెమరీ మొత్తాన్ని సూచించే [] లో శ్రేణి యొక్క పరిమాణాన్ని మేము పేర్కొంటాము.

arrname = క్రొత్త డేటాటైప్ [పరిమాణం];

మేము కూడా ప్రకటించవచ్చు మరియు సృష్టించవచ్చు అమరిక క్రింద ఉన్న ఒకే ప్రకటనలో. మొదటి స్టేట్మెంట్ పరిమాణం 5 సంఖ్యల పేరుతో పూర్ణాంక శ్రేణిని సృష్టిస్తుంది. రెండవది పరిమాణం 2 పేర్లతో స్ట్రింగ్ శ్రేణిని సృష్టిస్తుంది

int[] arrNumbers = new int[5];
String[] arrNames = new String[2];

జావాలో శ్రేణిని ఎలా ప్రారంభించాలి?

శ్రేణిని ఎలా తక్షణం చేయాలి?

అర్రే ప్రారంభించడం లేదా ఇన్‌స్టాంటియేషన్ అంటే శ్రేణి పరిమాణం ఆధారంగా శ్రేణికి విలువలను కేటాయించడం. మేము కలిసి శ్రేణిని సృష్టించవచ్చు మరియు ప్రారంభించవచ్చు (తక్షణం) (క్రింద ఉన్న పద్ధతి 1 ని చూడండి). ఈ సందర్భంలో, మూలకాల సంఖ్య శ్రేణి యొక్క పొడవు లేదా పరిమాణాన్ని సూచిస్తుంది. విధానం 2 లో, మేము ప్రతి మూలకాన్ని విడిగా t0 విలువలను కేటాయిస్తున్నాము. శ్రేణి సూచిక 0 తో మొదలవుతుంది మరియు ఇక్కడ శ్రేణి పరిమాణం 3, 3 వ మూలకం 2 వ స్థానాన్ని ఆక్రమించింది, ఇది n-1, ఇక్కడ n అనేది శ్రేణి యొక్క పరిమాణం.

//Method 1
int[] arrNumbers = {1,2,3};

//Method 2
int[] arrNumbers = new int[3];
arrNumbers[0] = 1;
arrNumbers[1] = 2;
arrNumbers[2] = 3;

జావాలో శ్రేణి మూలకాలను యాక్సెస్ చేస్తోంది

మేము దాని సూచిక విలువను ఉపయోగించి శ్రేణి మూలకాలను యాక్సెస్ చేస్తాము. సాధారణంగా, మేము ఉపయోగిస్తాము కోసం లూప్ లేదా ప్రతి అన్ని మూలకాలు ఒకే రకమైనవి మరియు స్థిర పరిమాణాన్ని కలిగి ఉన్నందున శ్రేణి మూలకాలను యాక్సెస్ చేయడానికి లూప్.

ఉదాహరణ: శ్రేణి మూలకాలను సృష్టించండి, ప్రారంభించండి మరియు యాక్సెస్ చేయండి

ఇక్కడ, మేము ఒకే స్టేట్‌మెంట్‌లో తీగల శ్రేణిని సృష్టిస్తున్నాము మరియు ప్రారంభిస్తున్నాము మరియు లూప్ కోసం ఉపయోగించి ప్రతి మూలకాన్ని యాక్సెస్ చేస్తున్నాము

public class ArrayDemo1 {

  public static void main(String[] args) {
    String[] arrMonths = {"May","June","July"};
    System.out.println("Length of array is: " + arrMonths.length);
    for(int i=0;i<arrMonths.length;i++)
    {
      System.out.println(arrMonths[i]); 
    }

  }

}
Output:
Length of array is: 3
May
June
July

ఉదాహరణ: శ్రేణిని ప్రారంభించడానికి మరియు శ్రేణి అంశాలను ప్రాప్తి చేయడానికి మరొక పద్ధతి

దిగువ ఉదాహరణలో, మేము మొదట పూర్ణాంకాల శ్రేణిని ప్రకటించి, సృష్టించి, ఆపై వ్యక్తిగత శ్రేణి మూలకాలకు విలువలను కేటాయిస్తాము. ఇక్కడ, శ్రేణి మూలకాలను యాక్సెస్ చేయడానికి మేము ప్రతి లూప్ కోసం ఉపయోగిస్తున్నాము.

public class ArrayDemo2 {

  public static void main(String[] args) {
    int[] numbers = new int[5];
    numbers[0] = 100;
    numbers[1] = 101;
    numbers[2] = 103;
    numbers[3] = 104;
    numbers[4] = 105;
    
    for(int i: numbers)
    {
      System.out.println(i);
    }

  }

}
Output:
100
101
103
104
105

జావాలో శ్రేణుల రకాలు

జావాలో 2 రకాల శ్రేణులు ఉన్నాయి:

  • సింగిల్ డైమెన్షనల్ అర్రే - ఇందులో 1 అడ్డు వరుస మరియు 1 కాలమ్ మాత్రమే ఉన్నాయి. పై ఉదాహరణలన్నీ ఒకే డైమెన్షనల్ శ్రేణికి చెందినవి
  • మల్టీ డైమెన్షనల్ అర్రే - ఇది బహుళ వరుసలు మరియు బహుళ నిలువు వరుసలను కలిగి ఉంటుంది. మరో మాటలో చెప్పాలంటే, ఇది అన్ని వరుసలలో ఒకే సంఖ్యలో నిలువు వరుసలను కలిగి ఉన్న శ్రేణుల శ్రేణి. ఉదా: 2 * 2 మాతృక
  • బెల్లం శ్రేణి - ప్రతి వరుసలో వేర్వేరు సంఖ్యల నిలువు వరుసలు ఉంటాయి

జావాలో బహుమితీయ శ్రేణులు

బహుమితీయ శ్రేణులు బహుళ వరుసలు మరియు నిలువు వరుసలను కలిగి ఉంటాయి. మొదటి [] లోని సూచిక వరుసలను సూచిస్తుంది మరియు రెండవది [] నిలువు వరుసలను సూచిస్తుంది.

ఉదా: int [] [] a = new int [2] [3]

దీని అర్థం శ్రేణిలో 2 వరుసలు మరియు 3 నిలువు వరుసలు ఉంటాయి. మల్టీ డైమెన్షనల్ అర్రే యొక్క రేఖాచిత్ర ప్రాతినిధ్యం క్రింద ఉంది

జావాలో శ్రేణులు

స్ట్రింగ్స్ యొక్క బహుమితీయ శ్రేణులను సృష్టించే ఉదాహరణ

దిగువ ఉదాహరణ మల్టీ డైమెన్షనల్ అర్రే ఎలిమెంట్లను ఎలా సృష్టించాలో, డిక్లేర్ చేసి, యాక్సెస్ చేయాలో చూపిస్తుంది. ఇక్కడ, మేము వరుస మరియు కాలమ్ సూచికను ఉపయోగించి శ్రేణి మూలకాలను నేరుగా యాక్సెస్ చేస్తాము.

public class ArrayMulti {

  public static void main(String[] args) {
    String[][] arrNames = {{"John","Jacob"},{"Thomas","Martin"}};
    System.out.println(arrNames[0][0] + " " + arrNames[0][1]);
    System.out.println(arrNames[1][0] + " " + arrNames[1][1]);

  }

}
Output:
John Jacob 
Thomas Martin

పూర్ణాంకాల 2D శ్రేణి యొక్క ఉదాహరణ

ఇక్కడ, మేము 2 వరుసలు మరియు 2 నిలువు వరుసలను కలిగి ఉన్న పూర్ణాంకాల యొక్క 3-డైమెన్షనల్ శ్రేణిని సృష్టిస్తున్నాము. మేము ఈ శ్రేణి మూలకాలకు విలువలను లూప్ కోసం కేటాయిస్తాము. లూప్ కోసం 1 వ వరుసలను సూచిస్తుంది మరియు లూప్ కోసం 2 వ నిలువు వరుసలను సూచిస్తుంది.

public class ArrayMulti {

  public static void main(String[] args) {
    //Declare and create multidimensional array
    int[][] arrnum = new int[2][3];
    for(int i=0;i<2;i++) {
      for(int j=0;j<3;j++) {
        //Assign values to array elements
        arrnum[i][j] = i+1;
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }

  }

}
Output:
1 1 1 
2 2 2 

జావాలో బెల్లం శ్రేణులు

బెల్లం శ్రేణి వేరే-నిలువు వరుసలను కలిగి ఉన్న 2 డైమెన్షనల్ అర్రే. మరో మాటలో చెప్పాలంటే, ప్రతి అడ్డు వరుసకు వేర్వేరు సంఖ్యల నిలువు వరుసలు ఉంటాయి. బెల్లం శ్రేణిని ప్రారంభించడం సాధారణ 2D శ్రేణికి భిన్నంగా ఉంటుంది.

జాగ్డ్ అర్రే ప్రారంభించడం

శ్రేణి సృష్టి సమయంలో, మేము వరుసల సంఖ్యను తెలుపుతాము. ఈ ఉదాహరణలో, ఇది 2. తదుపరి 2 స్టేట్మెంట్లలో, ప్రతి అడ్డు వరుసకు, మేము నిలువు వరుసల సంఖ్యను తెలుపుతాము. ఇక్కడ, 1 వ వరుసలో 3 నిలువు వరుసలు మరియు 2 వ వరుసలో 4 నిలువు వరుసలు ఉన్నాయి.

int[][] arrnum = new int[2][];
arrnum[0] = new int[3];
arrnum[1] = new int[4];

లూప్ కోసం విలువలను కేటాయించడం ద్వారా బెల్లం శ్రేణి యొక్క ఉదాహరణ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arrnum = new int[2][];
    arrnum[0] = new int[3];
    arrnum[1] = new int[4];

    int val=1;
    //Assign values
    for(int i=0;i<arrnum.length;i++) {
      for(int j=0;j<arrnum[i].length;j++) {
        arrnum[i][j] = val;
      }
    }
    
    //Print the values
    for(int i=0;i<arrnum.length;i++)
    {
      for(int j=0;j<arrnum[i].length;j++)
      {
        System.out.print(arrnum[i][j] + " ");
      }
      System.out.println();
    }
  }

}
Output:
1 1 1 
1 1 1 1 

శ్రేణి సృష్టి సమయంలో విలువలను ప్రారంభించడం ద్వారా జాగ్డ్ అర్రే ఉదాహరణ

public class JaggedArray {

  public static void main(String[] args) {
    int[][] arr = {{4,5,6},{1,2},{7,9,8}};
    for(int i=0;i<3;i++)
    {
      for(int j=0;j<arr[i].length;j++) {
        System.out.print(arr[i][j] + " ");
      }
      System.out.println();
    }
  }
}
Output:
4 5 6 
1 2 
7 9 8 

జావా అర్రే పద్ధతులు

జావాలో అర్రేస్ మద్దతు ఇచ్చే ప్రత్యక్ష పద్ధతులు క్రింద ఉన్నాయి

విధానం<span style="font-family: Mandali; "> టెండర్‌ వివరణ</span>
శూన్య క్లోన్ ()సూచనలు కాపీ చేయబడని ప్రస్తుత శ్రేణి విలువలను క్లోన్ చేస్తుంది
బూలియన్ సమానం (ఆబ్జెక్ట్ 0)వేరే వస్తువు ప్రస్తుత వస్తువుతో సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది
తరగతి getClass ()తరగతి పేరును అందిస్తుంది
స్ట్రింగ్ toString ()వస్తువు యొక్క స్ట్రింగ్ ప్రాతినిధ్యాన్ని అందిస్తుంది
పూర్ణాంక పొడవు ()శ్రేణి యొక్క పొడవును అందిస్తుంది

జావా అర్రే మినహాయింపులు

లో శ్రేణులు జావా విసురుతాడు దిగువ మినహాయింపు:

  • ArrayIndexOutOfBoundsException: మేము పేర్కొన్న సూచిక విలువ శ్రేణి యొక్క పొడవు కంటే ఎక్కువగా ఉన్నప్పుడు లేదా ప్రతికూలంగా ఉన్నప్పుడు ఇది సంభవిస్తుంది. విలువను కేటాయించేటప్పుడు లేదా శ్రేణి మూలకాలను యాక్సెస్ చేసేటప్పుడు ఇది ప్రధానంగా జరుగుతుంది.

శ్రేణిని కాపీ చేయండి

క్లాస్ సిస్టమ్ యొక్క పద్ధతి అర్రేకోపీని ఉపయోగించి మనం ఒక శ్రేణి నుండి మరొక శ్రేణికి మూలకాలను కాపీ చేయవచ్చు.

శ్రేణి వాక్యనిర్మాణాన్ని కాపీ చేయండి

పబ్లిక్ శూన్యమైన అర్రేకోపీ (ఆబ్జెక్ట్ src, int srcPos, ఆబ్జెక్ట్ డెస్ట్, int destPos, int పొడవు);

నుండి కాపీ చేయడానికి src- సోర్స్ అర్రే ఆబ్జెక్ట్

srcPos - మూల శ్రేణిలో ప్రారంభ స్థానం

dest - గమ్యస్థాన శ్రేణి వస్తువు కాపీ చేయడానికి

destPos - గమ్యం శ్రేణిలో ప్రారంభ స్థానం

పొడవు - కాపీ చేయడానికి శ్రేణి మూలకాల సంఖ్య

శ్రేణిని కాపీ చేయడానికి ఉదాహరణ

దిగువ ఉదాహరణలో, మేము మూల శ్రేణి నుండి గమ్యం శ్రేణికి 4 అంశాలను కాపీ చేస్తున్నాము. అందువల్ల అవుట్పుట్ "జావా" ను ప్రింట్ చేస్తుంది

public class ArrayCopy {

  public static void main(String[] args) {
    char[] a = {'d','l','h','y','j','a','v','a','g','r','t'};
    char[] b = new char[4];
    
    System.arraycopy(a, 4, b, 0, 4);
    System.out.println(String.valueOf(b));

  }

}
Output:
java

శ్రేణిని ఒక పద్ధతికి పాస్ చేయండి

జావాలో, మేము మరింత తారుమారు లేదా ఇతర కార్యకలాపాల కోసం ఒక పద్ధతికి శ్రేణి వస్తువును పంపవచ్చు. దిగువ ఉదాహరణ మనం పూర్ణాంకాల శ్రేణి వస్తువును ఒక పద్ధతికి ఎలా పంపించాలో మరియు అన్ని శ్రేణి మూలకాల యొక్క చేరికను ఎలా చేయగలదో చూపిస్తుంది.

public class ArrayDemo3 {

  public static void main(String[] args) {
    int[] num = {5,7,3,2,8};
    add(num);

  }
  
  public static void add(int[] num) {
    int sum = 0;
    for(int i=0;i<num.length;i++) {
      sum = sum + num[i];
    }
    System.out.println("Sum of array elements is : " + sum);
  }

}
Output:
Sum of array elements is : 25

ఒక పద్ధతి నుండి శ్రేణిని తిరిగి ఇవ్వండి

మేము కూడా చేయవచ్చు శ్రేణిని తిరిగి ఇవ్వండి అవసరమైన ఆపరేషన్ చేసిన తర్వాత పద్ధతి నుండి ప్రధాన పద్ధతికి వస్తువు.

public class ArrayDemo4 {

  public static void main(String[] args) {
    String[] arr = getArrayValues();
    for(String cities:arr) {
      System.out.println(cities);
    }
      

  }
  
  public static String[] getArrayValues() {
    String[] arrCities = {"Chennai","Bangalore","Delhi"};
    return arrCities;
  }

}
Output:
Chennai
Bangalore
Delhi

శ్రేణి అవకతవకలు

లో శ్రేణులు జావా java.util ప్యాకేజీకి చెందినది. క్రింద పేర్కొన్న విధంగా java.util.Array క్లాస్ చేత అనేక ఆపరేషన్లు ఉన్నాయి:

  • ఒక శ్రేణి నుండి మరొక శ్రేణికి మూలకాల పరిధిని కాపీ చేయడానికి మేము అర్రే క్లాస్ యొక్క కాపీఆఫ్ రేంజ్ పద్ధతిని ఉపయోగించవచ్చు
  • సూచిక (బైనరీ శోధన) ఆధారంగా నిర్దిష్ట విలువ కోసం శ్రేణిని శోధించండి
  • సమాన పద్ధతిని ఉపయోగించి సమానత్వాన్ని తనిఖీ చేయడానికి శ్రేణులతో పోల్చండి
  • సూచిక వద్ద నిర్దిష్ట విలువను ఉంచడానికి శ్రేణిని పూరించడానికి పూరక పద్ధతిని ఉపయోగించండి
  • క్రమబద్ధీకరణ పద్ధతిని ఉపయోగించి శ్రేణిని క్రమబద్ధీకరించడం

వినియోగదారు నిర్వచించిన వస్తువును ఉపయోగించి శ్రేణిని సృష్టిస్తోంది

జావాలో, మనం తీగలు, పూర్ణాంకం మొదలైన వాటి శ్రేణిని ఎలా సృష్టించాలో మాదిరిగానే వినియోగదారు నిర్వచించిన వస్తువును కూడా సృష్టించవచ్చు. ఇది మేము విద్యార్థి శ్రేణి వస్తువును ఎలా సృష్టించగలము మరియు శ్రేణి వస్తువును ఎలా ప్రారంభించగలమో ఒక ఉదాహరణ.

public class ArrayDemo5 {

  public static void main(String[] args) {
    Student[] s = new Student[2];
    s[0] = new Student(111,"Ajit");
    s[1] = new Student(112,"Biju");
  }

}
 class Student{
  public int rollno;
  public String name;
  public Student(int rno,String n) {
    rollno = rno;
    name = n;
  }
}

ముగింపు

ఈ ట్యుటోరియల్ జావాలోని అర్రేస్ క్లాస్, జావాలోని శ్రేణుల రకాలు, వివిధ దృష్టాంతాలతో శ్రేణులను ప్రకటించడం, సృష్టించడం మరియు ప్రారంభించడం గురించి వివరణాత్మక వర్ణనను అందిస్తుంది.

సూచన