Jak zadeklarować i zainicjować tablicę w Javie?


2052

Jak zadeklarować i zainicjować tablicę w Javie?


4
Zanim opublikujesz nową odpowiedź, zastanów się, że istnieje już ponad 25 odpowiedzi na to pytanie. Upewnij się, że twoja odpowiedź zawiera informacje, których nie ma wśród odpowiedzi istniejących.
janniks

Odpowiedzi:


2682

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

33
Jaki jest cel posiadania drugiego i trzeciego sposobu na zrobienie tego?
Quazi Irfan

123
@iamcreasy Wygląda na to, że drugi sposób nie działa z instrukcjami zwrotnymi. return {1,2,3}daje błąd, podczas gdy return new int[]{1,2,3}działa dobrze (zakładając oczywiście, że twoja funkcja zwraca tablicę liczb całkowitych).
Skylar Ittner

1
@ SkylarMT Ale nadal możemy użyć pierwszego sposobu użycia z instrukcją return.
Quazi Irfan

6
@iamcreasy Niedawno napisałem funkcję, która zwróciła tablicę ints. Jeśli wystąpił błąd wewnątrz funkcji, chciałem, aby zwróciła określoną wartość, ale funkcja potrzebowała zwrócić tablicę. Który sposób działa w przypadku instrukcji zwrotnej jednowierszowej? Tylko trzeci.
Skylar Ittner,

5
@apadana W drugim przypadku tworzysz anonimowy obiekt, który jest zdefiniowany tylko w zakresie obejmującym (funkcja lub cokolwiek). Po zwróceniu go dzwoniącemu nie jest już ważny. Za pomocą nowego słowa kluczowego przydzielasz nowy obiekt ze sterty i jest on ważny poza zakresem definiującym.
teukkam

280

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


Czy pierwszy nie prowadzi do pustej / pustej tablicy zamiast tablicy z wartościami domyślnymi?
vipin8169

Zgadzam się w tej kwestii i możemy dodać jeszcze jedną funkcję, możemy dynamicznie zmieniać rozmiar.
AdamIJK

Mógłbym się z tobą spierać o to, że tablica wielowymiarowa to inny „typ” tablicy. Jest to po prostu termin używany do opisania tablicy, która zawiera inne tablice. Zarówno tablice zewnętrzne, jak i wewnętrzne (i te pośrednie, jeśli istnieją) są tylko zwykłymi tablicami.
Tim M.

127
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ą.


22
Zgadzam się w tej kwestii. Typem zmiennej nie jest „TYPE”, ale w rzeczywistości TYPE [], więc warto dla mnie napisać w ten sposób.
Chet

3
Styl Google też to sugeruje.
wener

11
Pamiętaj, że int[] a, b;nie będzie to to samo int a[], b;, co błąd łatwy do popełnienia, jeśli użyjesz tego ostatniego formularza.
Jeroen Vannevel

39

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 .


31

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.


Więc nie jest konieczne dołączanie int[] name = new int[5]?
Cookie Monster

31

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

2
Nie ma absolutnie żadnej różnicy między drugim i trzecim podejściem, poza tym, że drugie podejście działa tylko wtedy, gdy deklarujesz zmienną. Nie jest jasne, co rozumiesz przez „pokazuje właściwość anonimowego tworzenia obiektów tablicowych”, ale tak naprawdę są to równoważne fragmenty kodu.
Jon Skeet

4
Również pierwszy fragment ma zainicjować tablicę - jest ona gwarantowana mieć wartość 0 dla każdego elementu tablicy.
Jon Skeet

Czy tak naprawdę nie ma różnicy między podejściem drugim a trzecim?
typelogiczny

27

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).


7
Jakiego standardu używać? Właśnie odkryłem ten pierwszy i uważam go za przerażająco mylący: |
Anti Earth

2
Z tego powodu, co warte mojego profu, powiedział, że drugi sposób jest bardziej typowy dla Javy i że lepiej przekazuje to, co się dzieje; jako tablica związana z typem zmienna została rzutowana jako.
Celeritas,

2
Na marginesie: język mający więcej niż jedną semantykę do deklarowania jednej rzeczy oznaczającej zły projekt języka.
Muhammad Suleman

26

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

2
Jak nazywa się „<>” na utworzonej liście?
CyprUS

@CyprUS Listjest klasą ogólną, ma typ jako parametr zamknięty w <>. Pomaga to, ponieważ wystarczy zdefiniować typ ogólny tylko raz, a następnie można go używać z wieloma różnymi typami. Bardziej szczegółowe wyjaśnienie znajduje się na docs.oracle.com/javase/tutorial/java/generics/types.html
Heimdall

15

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

11

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]


9

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

Dlaczego miałbyś chcieć stworzyć tablicę w ten sposób?
Dorian Gray

9

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

7

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

7

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

6

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
}

5

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

Czy faktycznie uwzględniono -50 i / lub +50? To znaczy, czy wewnętrzny jest otwarty na jednym, czy na obu końcach?
Peter Mortensen

1
-50 jest uwzględnione, a +50 jest wykluczone. Te informacje z interfejsu API Java „podane pochodzenie (włącznie) i powiązane (wyłączne)”. Używam deklaracji interwałowej z wiki . Myślę więc, że będzie to bardziej poprawne [-50, 50)
Kirill Podlivaev

3

Innym sposobem zadeklarowania i zainicjowania ArrayList:

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

2

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.


2

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.


Nie widziałem tego w innych odpowiedziach, więc pomyślałem, że mogę to dodać.
Sylhare,

1
Lista nie jest tablicą
Tirno

Czasami ludzie mają na myśli tablice, kiedy chcą listy.
Sylhare


1

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


1
Dziękuję @ Matheus za poprawę moich odpowiedzi. Poprosiłbym cię o poparcie tego, aby mogło dotrzeć do większej liczby użytkowników.
Zia Muhammad

0

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.


0

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.


0

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/


0

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


            }

        } 

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

-7
int[] SingleDimensionalArray = new int[2]

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

6
Chociaż ten kod może odpowiedzieć na pytanie, lepiej wyjaśnić, w jaki sposób rozwiązuje problem bez przedstawiania innych i dlaczego go używać. Odpowiedzi zawierające tylko kod nie są przydatne na dłuższą metę.
Bono,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.