Jak zadeklarować i zainicjować tablicę w Javie?

Możesz użyć deklaracji tablicowej lub literału tablicowego (ale tylko wtedy, gdy deklarujesz i wpływasz na zmienną od razu, literałów tablicowych nie można użyć do ponownego przypisania tablicy).

Dla typów pierwotnych:

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 

Na przykład dla klas Stringjest to samo:

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

Trzeci sposób inicjowania jest przydatny, gdy najpierw zadeklarujesz tablicę, a następnie ją zainicjujesz. Obsada jest tutaj niezbędna.

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

Istnieją dwa rodzaje tablic.

Tablica jednowymiarowa

Składnia wartości domyślnych:

int[] num = new int[5];

Lub (mniej preferowane)

int num[] = new int[5];

Składnia z podanymi wartościami (inicjalizacja zmiennej / pola):

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

Lub (mniej preferowane)

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

Uwaga: Dla wygody preferowane jest int [] num, ponieważ wyraźnie mówi, że mówisz tutaj o tablicy. W przeciwnym razie nie ma różnicy. Ani trochę.

Tablica wielowymiarowa

Deklaracja

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

Lub

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

Lub

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

Inicjalizacja

 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;

Lub

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

Poszarpana tablica (lub tablica nieprostokątna)

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

Więc tutaj jawnie definiujemy kolumny.
Inny sposób:

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

Aby uzyskać dostęp:

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

Alternatywnie:

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

Poszarpane tablice to tablice wielowymiarowe.
Aby uzyskać wyjaśnienie, zobacz wielowymiarowe szczegóły tablicy w oficjalnych samouczkach Java

Type[] variableName = new Type[capacity];

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



Type variableName[] = new Type[capacity]; 

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

jest również poprawny, ale wolę nawiasy po typie, ponieważ łatwiej jest zauważyć, że typ zmiennej jest w rzeczywistości tablicą.

Istnieją różne sposoby deklarowania tablicy w Javie:

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

Więcej informacji można znaleźć na stronie z samouczkami firmy Sun i JavaDoc .

Uważam, że pomocne jest zrozumienie każdej części:

Type[] name = new Type[5];

Type[]Jest to typ o zmiennej o nazwie nazwie ( „nazwa” jest nazywany identyfikatorem ). Dosłowny „Typ” jest typem podstawowym, a nawiasy oznaczają, że jest to typ tablicowy tej podstawy. Typy tablic są z kolei własnymi typami, co pozwala na tworzenie tablic wielowymiarowych, takich jak Type[][](typ tablicowy Type []). Słowo kluczowe newmówi, aby przydzielić pamięć dla nowej tablicy. Liczba między nawiasami określa, jak duża będzie nowa tablica i ile pamięci do przydzielenia. Na przykład, jeśli Java wie, że typ podstawowy Typezajmuje 32 bajty, a chcesz tablicę o rozmiarze 5, musi wewnętrznie przydzielić 32 * 5 = 160 bajtów.

Możesz także tworzyć tablice z już tam zawartymi wartościami, takimi jak

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

co nie tylko tworzy puste miejsce, ale wypełnia je tymi wartościami. Java może stwierdzić, że prymitywy są liczbami całkowitymi i że jest ich 5, więc rozmiar tablicy można określić niejawnie.

Poniżej przedstawiono deklarację tablicy, ale tablica nie została zainicjowana:

 int[] myIntArray = new int[3];

Poniżej przedstawiono deklarację oraz inicjalizację tablicy:

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

Teraz poniżej pokazano również deklarację oraz inicjalizację tablicy:

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

Ale ten trzeci pokazuje właściwość anonimowego tworzenia obiektów tablicowych, na którą wskazuje zmienna referencyjna „myIntArray”, więc jeśli napiszemy tylko „new int [] {1,2,3};” w ten sposób można stworzyć anonimowy obiekt tablicowy.

Jeśli po prostu napiszemy:

int[] myIntArray;

nie jest to deklaracja tablicy, ale następująca instrukcja uzupełnia powyższą deklarację:

myIntArray=new int[3];

Alternatywnie,

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

To deklaruje tablicę o nazwie arrayNameo rozmiarze 10 (masz do użycia elementy od 0 do 9).

Ponadto, jeśli chcesz czegoś bardziej dynamicznego, znajdziesz interfejs listy. To nie będzie działać tak dobrze, ale jest bardziej elastyczne:

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

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

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

Istnieją dwa główne sposoby tworzenia tablicy:

Ten dla pustej tablicy:

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

I ten, dla zainicjowanej tablicy:

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

Możesz także tworzyć tablice wielowymiarowe, takie jak to:

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

Weźmy intna przykład typ pierwotny . Istnieje kilka sposobów deklarowania i inttablicowania:

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

gdzie we wszystkich tych można użyć int i[]zamiast int[] i.

Dzięki refleksji możesz użyć (Type[]) Array.newInstance(Type.class, capacity);

Zauważ, że w parametrach metody ...wskazuje variable arguments. Zasadniczo dowolna liczba parametrów jest w porządku. Łatwiej jest to wyjaśnić za pomocą kodu:

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

Wewnątrz metody varargsjest traktowany jak normalny int[]. Type...może być użyte tylko w parametrach metody, więc int... i = new int[] {}nie będzie się kompilować.

Pamiętaj, że podczas przekazywania int[]do metody (lub dowolnej innej Type[]) nie można użyć trzeciego sposobu. W oświadczeniu int[] i = *{a, b, c, d, etc}*, kompilator zakłada, że {...}oznacza int[]. Ale to dlatego, że deklarujesz zmienną. Podczas przekazywania tablicy do metody deklaracją musi być new Type[capacity]albo new Type[] {...}.

Tablice wielowymiarowe

Z macierzami wielowymiarowymi trudniej sobie poradzić. Zasadniczo tablica 2D jest tablicą tablic. int[][]oznacza tablicę int[]s. Kluczem jest to, że jeśli an int[][]jest zadeklarowany jako int[x][y], maksymalny indeks to i[x-1][y-1]. Zasadniczo prostokąt int[3][5]to:

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

W Javie 9

Używanie różnych IntStream.iteratei IntStream.takeWhilemetod:

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]

W Javie 10

Korzystanie z wnioskowania o typ zmiennej lokalnej :

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

Jeśli chcesz tworzyć tablice przy użyciu odbić, możesz to zrobić w następujący sposób:

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

Deklarowanie tablicy odwołań do obiektów:

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

Tablica to sekwencyjna lista elementów

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

Jeśli jest to obiekt, to jest to ta sama koncepcja

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

W przypadku obiektów należy albo przypisać je, aby nullje zainicjować new Type(..), klasy takie jak Stringi Integersą przypadkami specjalnymi, które będą obsługiwane w następujący sposób

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

Ogólnie możesz tworzyć tablice, które są Mwymiarowe

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

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

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

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

Warto zauważyć, że tworzenie Mtablicy wymiarowej jest kosztowne pod względem przestrzeni. Ponieważ kiedy tworzysz Mtablicę wymiarową Ndla wszystkich wymiarów, całkowity rozmiar tablicy jest większy niż N^M, ponieważ każda tablica ma odniesienie, a na wymiarze M znajduje się tablica wymiarowa (M-1). Całkowity rozmiar jest następujący

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

W Javie 8 możesz używać tego w ten sposób.

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

Do tworzenia tablic obiektów klasy możesz użyć java.util.ArrayList. aby zdefiniować tablicę:

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

Przypisz wartości do tablicy:

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

Czytaj z tablicy:

ClassName variableName = arrayName.get(index);

Uwaga:

variableNamejest odniesieniem do tablicy, co oznacza, że ​​manipulowanie variableNamebędzie manipulowaćarrayName

dla pętli:

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

dla pętli, która pozwala na edycję arrayName(konwencjonalna dla pętli):

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

Zadeklaruj i zainicjuj dla Java 8 i nowszych. Utwórz prostą tablicę liczb całkowitych:

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]

Utwórz losową tablicę dla liczb całkowitych między [-50, 50] i dla liczb podwójnych [0, 1E17]:

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

Sekwencja potęgi dwóch:

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]

Dla String [] musisz podać konstruktor:

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

Tablice wielowymiarowe:

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

Innym sposobem zadeklarowania i zainicjowania ArrayList:

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

Tutaj jest wiele odpowiedzi. Dodaję kilka trudnych sposobów tworzenia tablic (z punktu widzenia egzaminu dobrze jest o tym wiedzieć)

1. Zadeklaruj i zdefiniuj tablicę

   int intArray[] = new int[3];

   Spowoduje to utworzenie tablicy o długości 3. Ponieważ zawiera ona prymitywny typ, int, wszystkie wartości są domyślnie ustawione na 0. Na przykład,

   intArray[2]; // Will return 0

2. Używanie nawiasów kwadratowych [] przed nazwą zmiennej

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

3. Zainicjuj i podaj dane do tablicy

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

   Tym razem nie trzeba wspominać o wielkości w nawiasie pudełkowym. Nawet prosty wariant tego to:

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

4. Tablica o długości 0

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

   Podobne dla tablic wielowymiarowych

   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

Używanie nawiasów kwadratowych przed zmienną:

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

Jest absolutnie w porządku, jeśli umieścisz jeden wspornik pudełka na końcu:

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

Kilka przykładów

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

Nie jest obowiązkowe, aby każdy element wewnętrzny był tego samego rozmiaru.

    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.

Musisz upewnić się, że jeśli używasz powyższej składni, że w kierunku do przodu musisz określić wartości w nawiasach kwadratowych. W przeciwnym razie się nie skompiluje. Kilka przykładów:

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

Kolejną ważną cechą jest kowariant

    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

WAŻNE: W przypadku typów referencyjnych domyślna wartość przechowywana w tablicy ma wartość NULL.

Możesz to również zrobić za pomocą java.util.Arrays:

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

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

Ten jest dość prosty i bezpośredni.

W przypadku wnioskowania o typach zmiennych lokalnych musisz podać typ tylko raz:

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

Lub

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

Tablica ma dwa podstawowe typy.

Tablica statyczna: Stała tablica rozmiarów (jej rozmiar powinien być zadeklarowany na początku i nie można go później zmienić)

Tablica dynamiczna: nie bierze się pod uwagę limitu rozmiaru. (Czyste tablice dynamiczne nie istnieją w Javie. Zamiast tego najbardziej zachęca się List)

Aby zadeklarować statyczną tablicę liczb całkowitych, łańcuchów, liczb zmiennoprzecinkowych itp., Użyj poniższej deklaracji i instrukcji inicjalizacji.

    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

Aby użyć funkcji dynamicznych, musisz użyć Listy ... Lista jest czystą dynamiczną tablicą i nie ma potrzeby deklarowania rozmiaru na początku. Poniżej znajduje się właściwy sposób na zadeklarowanie listy w JAVA>

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

Deklaracja tablicy: int[] arr;

Initialize Array: int[] arr = new int[10];10 reprezentuje liczbę elementów dozwolonych w tablicy

Zadeklaruj tablicę wielowymiarową: int[][] arr;

Zainicjuj tablicę wielowymiarową: int[][] arr = new int[10][17];10 wierszy i 17 kolumn i 170 elementów, ponieważ 10 razy 17 to 170.

Inicjowanie tablicy oznacza określenie jej rozmiaru.

Bardzo łatwo jest zadeklarować i zainicjować tablicę. Na przykład chcesz zapisać pięć elementów całkowitych, które są 1, 2, 3, 4 i 5 w tablicy. Możesz to zrobić w następujący sposób:

za)

int[] a = new int[5];

lub

b)

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

więc podstawowym wzorem dla inicjalizacji i deklaracji metodą a) jest:

datatype[] arrayname = new datatype[requiredarraysize];

datatype powinno być pisane małymi literami.

Podstawowym wzorcem dla inicjalizacji i deklaracji metodą a jest:

Jeśli jest to tablica ciągów:

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

Jeśli jest to tablica znaków:

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

Dla float double format tablicy będzie taki sam jak liczba całkowita.

Na przykład:

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

ale kiedy zadeklarujesz i zainicjujesz tablicę za pomocą „metody a”, będziesz musiał wprowadzić wartości ręcznie, za pomocą pętli lub czegoś innego.

Ale kiedy zrobisz to „metodą b”, nie będziesz musiał ręcznie wprowadzać wartości.

Tablica może zawierać prymitywne typy danych, a także obiekty klasy w zależności od definicji tablicy. W przypadku typów danych pierwotnych wartości rzeczywiste są przechowywane w ciągłych lokalizacjach pamięci. W przypadku obiektów klasy rzeczywiste obiekty są przechowywane w segmencie sterty.

Tablice jednowymiarowe:
Ogólna forma jednowymiarowej deklaracji tablicowej to

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

Tworzenie instancji tablicy w Javie

var-name = new type [size];

Na przykład

    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/

jeden inny pełny przykład z klasą filmów 😋

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

przykład:

int[] x=new int[10];

lub

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

przykład:

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

int[] SingleDimensionalArray = new int[2]

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