Java'da bir diziyi nasıl bildirir ve başlatırım?

Dizi bildirimini veya dizi değişmezini kullanabilirsiniz (ancak yalnızca değişkeni hemen bildirip etkilediğinizde dizi değişmezleri bir dizinin yeniden atanması için kullanılamaz).

İlkel tipler için:

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 

Örneğin sınıflar Stringiçin aynıdır:

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

Başlatma işleminin üçüncü yolu, önce diziyi bildirip sonra başlattığınızda kullanışlıdır. Oyuncular burada gerekli.

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

İki tür dizi vardır.

Bir Boyutlu Dizi

Varsayılan değerler için sözdizimi:

int[] num = new int[5];

Veya (daha az tercih edilir)

int num[] = new int[5];

Verilen değerlerle sözdizimi (değişken / alan başlatma):

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

Veya (daha az tercih edilir)

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

Not: Kolaylık sağlamak için int [] num tercih edilir, çünkü burada dizi hakkında konuştuğunuzu açıkça belirtir. Aksi takdirde fark yok. Bir şey değil.

Çok boyutlu dizi

deklarasyon

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

Veya

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

Veya

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

Başlatma

 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;

Veya

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

Düzensiz Dizi (veya dikdörtgen Olmayan Dizi)

 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];

Burada sütunları açıkça tanımlıyoruz.
Diğer yol:

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

Erişim için:

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

Alternatif:

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

Düzensiz diziler çok boyutlu dizilerdir.
Açıklama için resmi java eğiticilerindeki çok boyutlu dizi ayrıntılarına bakın

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

aynı zamanda geçerlidir, ancak değişkenin türünün aslında bir dizi olduğunu görmek daha kolay olduğundan, yazımdan sonra köşeli parantezleri tercih ederim.

Java'da bir dizi bildirmenin çeşitli yolları vardır:

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

Sun eğitim sitesinde ve JavaDoc'da daha fazla bilgi bulabilirsiniz .

Her parçayı anlamanızın yararlı olduğunu düşünüyorum:

Type[] name = new Type[5];

Type[]olan tip bir değişken ( "isim" denir denilen isim tanımlayıcı ). Değişmez "Tür" temel türdür ve köşeli ayraçlar, bu tabanın dizi türü olduğu anlamına gelir. Dizi türleri sırayla kendi türleridir, bu da sizin gibi çok boyutlu diziler yapmanıza izin verir Type[][](Type [] dizi türü). Anahtar kelime newyeni dizi için bellek ayırmayı söylüyor. Köşeli ayraç arasındaki sayı, yeni dizinin ne kadar büyük olacağını ve ne kadar bellek ayrılacağını belirtir. Örneğin, Java temel türün Type32 bayt aldığını biliyorsa ve 5 boyutlu bir dizi istiyorsanız, dahili olarak 32 * 5 = 160 bayt ayırması gerekir.

Ayrıca, önceden var olan değerlerle diziler de oluşturabilirsiniz.

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

ki bu sadece boş alan yaratmakla kalmaz, aynı zamanda bu değerlerle de doldurur. Java, ilkellerin tamsayı olduğunu ve 5 tane olduğunu söyleyebilir, böylece dizinin boyutu dolaylı olarak belirlenebilir.

Aşağıda bir dizinin bildirimi gösterilir, ancak dizi başlatılmaz:

 int[] myIntArray = new int[3];

Aşağıda, dizinin bildirimi ve başlatılması gösterilmektedir:

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

Şimdi, aşağıda dizinin bildirimi ve başlatılması da gösterilmektedir:

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

Ancak bu üçüncüsü, "myIntArray" referans değişkeni tarafından işaret edilen anonim dizi nesnesi oluşturma özelliğini gösterir. Bu nedenle, yalnızca "new int [] {1,2,3};" anonim dizi nesnesi bu şekilde oluşturulabilir.

Sadece yazarsak:

int[] myIntArray;

bu dizi bildirimi değildir, ancak aşağıdaki ifade yukarıdaki bildirimi tamamlar:

myIntArray=new int[3];

Alternatif olarak,

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

Bu, arrayName10 boyut adlı bir dizi bildirir (kullanılacak 0 ila 9 öğeleriniz vardır).

Ayrıca, daha dinamik bir şey istemeniz durumunda Liste arayüzü vardır. Bu da işe yaramaz, ancak daha esnektir:

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

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

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

Dizi oluşturmanın iki ana yolu vardır:

Bu, boş bir dizi için:

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

Ve bu, başlatılmış bir dizi için:

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

Bunun gibi çok boyutlu diziler de yapabilirsiniz:

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

Örneğin ilkel türü ele intalalım. Bildirmek ve intsıralamak için birkaç yol vardır :

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

bunların hepsinde int i[]bunun yerine kullanabilirsiniz int[] i.

Yansıma ile kullanabilirsiniz (Type[]) Array.newInstance(Type.class, capacity);

Yöntem parametrelerinde şunu ...belirtir variable arguments. Esasen, herhangi bir sayıda parametre iyidir. Kod ile açıklamak daha kolaydır:

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};

Yöntemin içinde varargsnormal kabul edilir int[]. Type...yalnızca yöntem parametrelerinde kullanılabilir, bu nedenle int... i = new int[] {}derlenmez.

Bir geçerken unutmayın int[]bir yöntemle (veya başka Type[]), üçüncü bir yol kullanamaz. Açıklamada int[] i = *{a, b, c, d, etc}*, derleyici, {...}a int[]. Fakat bunun nedeni bir değişken bildirmenizdir. Bir yöntemle bir dizi geçerken, beyan ya olmalıdır new Type[capacity]ya da new Type[] {...}.

Çok Boyutlu Diziler

Çok boyutlu dizilerle baş etmek çok daha zordur. Temel olarak, bir 2D dizi bir dizi dizisidir. s int[][]dizisi anlamına gelir int[]. Anahtar şudur: an int[][]olarak bildirilirse int[x][y], maksimum dizin i[x-1][y-1]. Temel olarak, bir dikdörtgen 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]

Java 9'da

Farklı IntStream.iterateve IntStream.takeWhileyöntemler kullanarak :

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]

Java 10'da

Yerel Değişken Türü Çıkarımını Kullanma :

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

Yansımaları kullanarak diziler oluşturmak istiyorsanız bunu yapabilirsiniz:

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

Bir dizi nesne başvurusu bildirme:

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
    }
}

Dizi, sıralı bir öğe listesidir

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 }
};

Eğer bir nesne ise, o zaman aynı kavram

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() }
};

Nesnelerin durumunda, bunu ya ata gerekir nullkullanarak bunları başlatmak için new Type(..), gibi sınıflar Stringve Integeraşağıdaki şekilde ele alınacaktır özel durumlardır

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) };

Genel olarak Mboyutsal diziler oluşturabilirsiniz

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

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

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

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

MBoyutsal bir dizi oluşturmanın Uzay açısından pahalı olduğunu belirtmek gerekir . Tüm Mboyutlarda bir boyutlu dizi oluşturduğunuzda , her dizinin bir referansı olduğundan ve M boyutunda bir (M-1) boyutlu referans dizisi Nolduğundan N^M, dizinin toplam boyutu bundan daha büyüktür . Toplam boyutu aşağıdaki gibidir

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

Java 8'de böyle kullanabilirsiniz.

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

Nesne sınıfı dizileri oluşturmak için java.util.ArrayList. bir dizi tanımlamak için:

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

Diziye değerler atayın:

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

Diziden okuyun:

ClassName variableName = arrayName.get(index);

Not:

variableName, manipülasyonun manipüle variableNameedeceği anlamına gelen diziye bir referanstırarrayName

döngüler için:

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

düzenlemenize izin veren döngü için (döngü için arrayNamegeleneksel):

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

Java 8 ve sonraki sürümler için bildirme ve başlatma. Basit bir tamsayı dizisi oluşturun:

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] arasındaki tam sayılar ve [0, 1E17] çiftleri için rastgele bir dizi oluşturun:

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

İki dizinin gücü:

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 [] için bir kurucu belirtmelisiniz:

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

Çok boyutlu diziler:

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'i bildirmenin ve başlatmanın başka bir yolu:

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

Burada birçok cevap var. Diziler oluşturmak için birkaç zor yol ekliyorum ( sınav açısından bunu bilmek güzel)

1. Dizi tanımlayın ve tanımlayın

   int intArray[] = new int[3];

   Bu, uzunluk 3 dizisi oluşturur. İlkel bir tür olan int'i barındırdığından, tüm değerler varsayılan olarak 0'a ayarlanır. Örneğin,

   intArray[2]; // Will return 0

2. Değişken adından önce [] kutu desteklerini kullanma

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

3. Diziyi başlat ve veri ver

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

   Bu kez kutu braketindeki boyuttan bahsetmeye gerek yok. Bunun basit bir varyantı bile:

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

4. 0 uzunluk dizisi

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

   Çok boyutlu diziler için benzer

   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

Değişkenten önce kutu parantez kullanma:

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

Sonuna bir kutu braketi koyarsanız kesinlikle iyi olur:

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

Bazı örnekler

    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}}

Her bir iç elemanın aynı boyutta olması zorunlu değildir.

    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.

Yukarıdaki sözdizimini kullanıyorsanız, ileri yönün kutu parantezindeki değerleri belirtmeniz gerektiğinden emin olmalısınız. Yoksa derlemez. Bazı örnekler:

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

Bir diğer önemli özellik kovaryant

    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

ÖNEMLİ: Referans verilen türler için, dizide saklanan varsayılan değer null şeklindedir.

Ayrıca aşağıdakilerle de yapabilirsiniz java.util.Arrays:

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

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

Bu oldukça basit ve anlaşılır.

Yerel değişken türü çıkarımı ile, türü yalnızca bir kez belirtmeniz gerekir:

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

Veya

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

Dizinin iki temel türü vardır.

Statik Dizi: Sabit boyutlu dizi (Boyutu başlangıçta bildirilmelidir ve daha sonra değiştirilemez)

Dinamik Dizi: Bunun için boyut sınırı dikkate alınmaz. (Saf dinamik diziler Java'da mevcut değildir. Bunun yerine Liste en çok teşvik edilir)

Statik bir Tamsayı, dize, kayan nokta vb. Dizisi bildirmek için aşağıdaki bildirimi ve başlatma deyimlerini kullanın.

    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

Dinamik özellikleri kullanmak için, Liste ... öğesini kullanmanız gerekir. Liste saf dinamik Dizidir ve başlangıçta boyut bildirmeye gerek yoktur. Körük JAVA'da bir liste ilan etmenin doğru yoludur>

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

Dizi Bildir: int[] arr;

int[] arr = new int[10];Diziyi Başlat: 10, dizide izin verilen öğe sayısını temsil eder

Çok Boyutlu Dizi Bildirin: int[][] arr;

Çok Boyutlu Diziyi Başlatın: int[][] arr = new int[10][17];10 satır 17, 170 olduğu için 10 satır ve 17 sütun ve 170 öğe.

Bir diziyi başlatmak, dizinin boyutunu belirtmek anlamına gelir.

Bir dizi bildirmek ve başlatmak çok kolaydır. Örneğin, bir dizide 1, 2, 3, 4 ve 5 olan beş tamsayı öğesini kaydetmek istersiniz. Bunu aşağıdaki şekilde yapabilirsiniz:

a)

int[] a = new int[5];

veya

b)

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

bu nedenle temel örüntü a) yöntemiyle başlatma ve bildirim içindir:

datatype[] arrayname = new datatype[requiredarraysize];

datatype küçük harf olmalıdır.

Yani temel örüntü a yöntemi ile başlatma ve bildirim içindir:

Bir dize dizisi ise:

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

Bir karakter dizisi ise:

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

Float double için dizi formatı tamsayı ile aynı olacaktır.

Örneğin:

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

ancak diziyi "yöntem a" ile bildirip başlattığınızda, değerleri manuel olarak veya döngü veya başka bir şeyle girmeniz gerekir.

Ancak bunu "yöntem b" ile yaptığınızda değerleri manuel olarak girmeniz gerekmez.

Dizi, dizinin tanımına bağlı olarak ilkel veri türlerinin yanı sıra sınıftaki nesneleri de içerebilir. İlkel veri türleri durumunda, gerçek değerler bitişik bellek konumlarında saklanır. Bir sınıfın nesnelerinde, gerçek nesneler yığın segmentinde saklanır.

Tek Boyutlu Diziler:
Tek boyutlu dizi bildiriminin genel biçimi

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

Java'da Dizi Dizisi Oluşturma

var-name = new type [size];

Örneğin

    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/

film sınıfı ile tam bir örnek 😋

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[] x=new int[enter the size of array here];

misal:

int[] x=new int[10];

veya

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

misal:

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

int[] SingleDimensionalArray = new int[2]

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