Java-exempel på att arbeta med arrayer. Java Array
En array är en ändlig sekvens av ordnade element av samma typ, där varje element nås av sitt index.
Storleken eller längden på en array är det totala antalet element i arrayen. Storleken på arrayen ställs in när arrayen skapas och kan inte ändras senare, det vill säga du kan inte ta bort element från arrayen eller lägga till dem där, men du kan tilldela nya värden till befintliga element.
Indexet för startelementet är 0, nästa är 1, etc. Indexet för det sista elementet i arrayen är en mindre än arrayens storlek.
I Java-arrayerär föremål. Detta betyder att namnet som ges till varje array endast indikerar adressen till någon del av data i minnet. Ingenting lagras i denna variabel förutom adressen. Arrayindexet indikerar faktiskt hur mycket du behöver flytta bort från startelementet i arrayen i minnet för att komma till önskat element.
För att skapa en array måste du deklarera ett lämpligt namn för den och sedan associera den med detta namn erforderligt fragment minne, där värdena för arrayelementen kommer att lagras efter varandra. Följande alternativ för att deklarera en array är möjliga: typnamn; typnamn;
Var typär typen av arrayelement, och namn- en unik (inte upptagen av andra variabler eller objekt i denna del av programmet) identifierare som börjar med en bokstav.
Exempel: int a; dubbel ar1; dubbel ar2;
I exemplet deklarerade vi namn för tre arrayer. Med förnamn a en uppsättning element kan associeras ytterligare typ int, och med namn ar1 Och ar2 ytterligare uppsättningar av riktiga nummer(dubbel typ). Hittills har vi inte skapat arrayer, utan bara förberett namn för dem.
Nu kan du skapa (eller, som de säger, initiera) arrayer enligt följande: a = new int; // matris med 10 element av typen int int n = 5; ar1 = ny dubbel[n]; // Array med 5 element dubbel ar2 = (3,14, 2,71, 0, -2,5, 99,123); // En array med 6 element av typen dubbel Det vill säga när vi skapar en array kan vi specificera dess storlek, eller omedelbart lista alla önskade element separerade med kommatecken i hängslen (i detta fall kommer storleken att beräknas automatiskt baserat på sekvensen av element som kommer att specificeras). Observera att i I detta fall efter stängningen lockigt hängslen ett semikolon sätts in, vilket inte händer när parentesen stänger ett block.
Om arrayen skapades med operatorn ny, då får vart och ett av dess element ett standardvärde. Vad det blir bestäms utifrån datatypen (0 för int, 0,0 för dubbel, etc.).
Det var möjligt att deklarera ett namn för en array och skapa själva arrayen på en rad med följande schema: typ namn = ny typ[storlek]; typnamn = (el0, el1, ..., elN); Exempel: int mas1 = (10,20,30); int mas2 = ny int;
För att komma åt ett av elementen i arrayen för att läsa eller ändra dess värde måste du ange namnet på arrayen följt av indexet för elementet i hakparentes. Ett matriselement med ett specifikt index beter sig på samma sätt som en variabel. Till exempel, för att visa det sista elementet i mas1-matrisen, måste vi skriva i programmet:
System.out.println("Sista arrayelement" + mas1);
Och så här kan vi lägga in samma uppsättning värden i mas2-matrisen som är lagrad i mas1:
Mas2 = 10; mas2 = 20; mas2 = 30;Redan från detta exempel är det tydligt att för att komma åt alla element i arrayen måste vi upprepa samma typ av åtgärder. Som du kommer ihåg används loopar för att upprepa operationer många gånger. Följaktligen skulle vi kunna fylla arrayen med de nödvändiga elementen med hjälp av en loop: for(int i=0; iDet är klart att om vi hade en array inte på 3, utan på 100 element, skulle vi helt enkelt inte ha kunnat göra det utan slinga.
Längden på en array som skapas behöver inte komma ihåg, eftersom det finns en egenskap som lagrar den. Du kan komma åt den här egenskapen genom att lägga till .length till arraynamnet. Till exempel:
Int razmer = mas1.längd; Den här egenskapen kan inte ändras (det vill säga den kan inte tilldelas någonting), den kan bara läsas. Med den här egenskapen kan du skriva programkod att bearbeta en array utan att ens veta dess specifika storlek.
Så här kan du till exempel visa elementen i valfri array som heter ar2:
For(int i = 0; i<= ar2.length - 1; i++) { System.out.print(ar2[i] + " "); } Для краткости удобнее менять нестрогое неравенство на строгое, тогда не нужно будет вычитать единицу из размера массива. Давайте заполним массив целыми числами от 0 до 9 и выведем его на экран: for(int i = 0; i < ar1.length; i++) {ar1[i] = Math.floor(Math.random() * 10); System.out.print(ar1[i] + " "); }
Observera att vi vid varje steg i slingan först skickade ett slumpmässigt värde till arrayelementet med det i:te indexet och visade sedan samma element på skärmen. Men de två processerna (påfyllning och uttag) kan göras i olika cykler. Till exempel:
For(int i = 0; i< ar1.length; i++) { ar1[i] = Math.floor(Math.random() * 9); } for(int i = 0; i < ar1.length; i++) { System.out.print(ar1[i] + " "); } В данном случае более рационален первый способ (один проход по массиву вместо двух), но не всегда возможно выполнить требуемые действия в одном цикле.
För att bearbeta matriser används alltid loopar av typen "n gånger" (för) eftersom vi i förväg vet hur många gånger loopen ska upprepas (samma antal gånger som det finns element i matrisen).
Uppgifter
Skapa en matris med alla jämna tal från 2 till 20 och visa elementen i matrisen först på en rad, separera ett element från ett annat med ett mellanslag och sedan i en kolumn (separera ett element från ett annat genom att starta en ny rad). Innan du skapar en array, tänk på hur stor den kommer att bli.
2 4 6 … 18 20
2
4
6
…
20
Skapa en array med alla udda nummer från 1 till 99, visa den på skärmen som en linje och visa sedan samma array på skärmen som en linje, men i omvänd ordning (99 97 95 93 ... 7 5 3 1 ).
Skapa en matris med 15 slumpmässiga heltal från segmentet. Visa arrayen på skärmen. Räkna hur många jämna element som finns i arrayen och visa detta nummer på skärmen på en separat rad.
Skapa en matris med 8 slumpmässiga heltal från segmentet. Skriv ut arrayen på skärmen som en sträng. Ersätt varje element med ett udda index med noll. Återigen, visa arrayen på en separat rad.
Skapa 2 arrayer med 5 slumpmässiga heltal från segmentet vardera, visa arrayerna på skärmen på två separata rader. Beräkna det aritmetiska medelvärdet för elementen i varje array och rapportera för vilken av arrayerna detta värde var högre (eller rapportera att deras aritmetiska medelvärden är lika).
Skapa en array med fyra slumpmässiga heltal från segmentet, skriv ut det på skärmen som en sträng. Bestäm och visa ett meddelande som anger om arrayen är en strikt ökande sekvens.
Skapa en uppsättning av de 20 bästa Fibonacci-numren och visa den på skärmen. Vi påminner dig om att den första och andra termen i sekvensen är lika med ettor, och varje nästa är summan av de två föregående.
Skapa en matris med 12 slumpmässiga heltal från segmentet [-15;15]. Bestäm vilket element som är maximum i denna array och rapportera indexet för dess senaste förekomst i arrayen.
Skapa två arrayer med 10 slumpmässiga heltal från segmentet och en tredje array med 10 reella tal. Varje element med det i:te indexet för den tredje matrisen måste vara lika med förhållandet mellan elementet från den första matrisen med det i:te indexet och elementet från den andra matrisen med det i:te indexet. Skriv ut alla tre arrayer till skärmen (var och en på en separat rad), skriv sedan ut antalet heltalselement i den tredje arrayen.
Skapa en array med 11 slumpmässiga heltal från segmentet [-1;1], visa arrayen som en linje. Bestäm vilket element som förekommer oftast i arrayen och visa ett meddelande om det på skärmen. Om två element förekommer lika många gånger, mata inte ut något.
Användaren måste ange ett jämnt positivt tal från tangentbordet, och programmet måste skapa en array med angiven storlek från slumpmässiga heltal från [-5;5] och visa den på skärmen som en linje. Efter detta måste programmet fastställa och informera användaren om summan av modulerna varav hälften av arrayen är större: vänster eller höger, eller informera om att dessa summor av modulerna är lika. Om användaren anger ett felaktigt nummer, bör programmet kräva upprepad inmatning tills rätt värde anges.
Programmet måste skapa en matris med 12 slumpmässiga heltal från segmentet [-10;10] så att det finns lika många negativa och positiva element och inga nollor. I det här fallet måste ordningen på elementen vara slumpmässig (dvs alternativet är inte lämpligt när arrayen ständigt innehåller först 6 positiva och sedan 6 negativa siffror, eller när elementen ständigt växlar genom ett, etc.). Visa den resulterande arrayen på skärmen.
Användaren matar in ett naturligt tal större än 3 från tangentbordet, som lagras i variabeln n. Om användaren angav ett felaktigt nummer bör programmet be användaren att upprepa inmatningen. Skapa en matris med n slumpmässiga heltal från ett segment och visa det på skärmen. Skapa en andra array endast från de jämna elementen i den första arrayen, om någon, och visa den på skärmen.
Sortera en array
Sortering är processen att omarrangera elementen i en array, när alla dess element är ordnade i stigande eller fallande ordning. Du kan sortera inte bara numeriska arrayer, utan även, till exempel, strängarrayer (enligt samma princip som böcker är ordnade på. bibliotekshyllor). I allmänhet kan du sortera elementen i vilken uppsättning som helst där ordningsrelationen är specificerad. Det finns universella algoritmer som utför sortering oavsett vilket initialtillstånd för arrayen var. Men förutom dem finns det speciella algoritmer som till exempel mycket snabbt kan sortera en nästan ordnad array, men som inte klarar sig bra med en kraftigt blandad array (eller inte klarar alls). Särskilda algoritmer behövs där hastigheten är viktig och ett specifikt problem håller på att lösas.Sortering efter urval
Låt oss titta på ett exempel på sortering i stigande ordning. Det vill säga, den initiala positionen i arrayen ska ha det minsta elementet, nästa bör ha ett större eller lika element, etc., och den sista positionen ska ha det största elementet. Kärnan i algoritmen är som följer. Vi letar efter det minimala elementet i allt och byter ut det med det första. Sedan, i den återstående delen av arrayen (dvs bland alla element utom det initiala), letar vi igen efter minimielementet och byter ut det med det andra elementet i arrayen. Och så vidare.Illustration:
För (int i = 0; i
Bubblesort
Kärnan i algoritmen är detta. Om vi går igenom någon array och fastställer den korrekta ordningen i varje par av intilliggande element, kommer det önskade elementet att garanteras efter det att vara på den sista platsen i arrayen (den största för sortering i stigande ordning eller den minsta för sortering i fallande ordning). Om du går igenom arrayen igen med samma transformationer, kommer det önskade elementet garanterat att vara på näst sista plats. Och så vidare.2 9 1 4 3 5 2 → ordningen är korrekt, det kommer inte att ske någon omarrangering
2 9 1 4 3 5 2 → 2 1 9 4 3 5 2
2 1 9 4 3 5 2 → 2 1 4 9 3 5 2
2 1 4 9 3 5 2 → 2 1 4 3 9 5 2
2 1 4 3 9 5 2 → 2 1 4 3 5 9 2
2 1 4 3 5 9 2 → 2 1 4 3 5 2 9
Kod: /* Den yttre slingan minskar hela tiden fragmentet av arrayen * som kommer att beaktas, eftersom efter varje pass * av den inre slingan kommer det önskade elementet att vara * på den sista platsen i fragmentet (det behöver inte övervägas igen). */ for (int i = a.length - 1; i >= 2; i--) ( /* I den sorterade variabeln lagrar vi ett tecken på om arrayen * är sorterad. Före varje pass av den interna *-slingan vi antar att den är sorterad , men om vi gör * minst en permutation, är den ännu inte helt sorterad inre slingan går vi igenom arrayfragmentet, som * bestäms av den yttre slingan. I detta fragment sätter vi * den korrekta ordningen mellan intilliggande element och bearbetar hela fragmentet i par */ för (int j = 0; j a). ( int temp = a[j]; a[j] = a; a = temp. ; sorted = false; ) ) /* Om arrayen är sorterad (dvs. det fanns inga permutationer * i den inre slingan, då kan du stoppa den yttre * slingan */ if(sorted) ( break; ) )
Flerdimensionella arrayer
En array kan inte bara bestå av element av någon inbyggd typ (int, double, etc.), utan också bland annat av objekt av någon befintlig klass och till och med av andra arrayer.
En array som innehåller andra arrayer som dess element kallas en flerdimensionell array. Tvådimensionella arrayer används oftast. Sådana arrayer kan lätt representeras som en matris. Varje rad är en vanlig endimensionell array, och föreningen av alla rader är en tvådimensionell array, i varje element som en länk till någon rad i matrisen kan finnas föreställas som en uppsättning matriser som vi skrev ner var och en på ett lånekort. Sedan, för att komma till ett specifikt nummer, måste du först ange kortnumret (det första indexet i den tredimensionella arrayen), ange därför radnumret (det andra arrayindexet) och först därefter numret på elementet i rad (det tredje indexet).
Följaktligen, för att komma åt ett element i en n-dimensionell array, måste du ange n index.
Matriser deklareras så här: int d1; //Vanlig, endimensionell int d2; //Tvådimensionell dubbel d3; //Tredimensionell int d5; //Femdimensionell När du skapar en array kan du uttryckligen ange storleken på varje nivå: d2 = int; // Matris med 3 rader och 4 kolumner Men du kan bara ange storleken på den första nivån: int dd2 = int; /* Matris med 5 rader. Det är ännu inte känt hur många element som kommer att finnas i varje rad. */ I det senare fallet kan du skapa tvådimensionell array, som inte kommer att vara en matris på grund av att varje rad kommer att ha olika antal element. Till exempel: for(int i=0; i<5; i++) { dd2[i] = new int; } В результате получим такой вот массив: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 Мы могли создать массив явно указав его элементы. Например так: int ddd2 = {{1,2}, {1,2,3,4,5}, {1,2,3}};
I det här fallet kan du komma åt elementet med index 4 i den andra raden ddd2, men om vi kommer åt elementet ddd2 eller ddd2- ett fel kommer att uppstå, eftersom det helt enkelt inte finns några sådana element. Dessutom kommer detta fel att uppstå under programkörning (det vill säga kompilatorn kommer inte att se det).
Vanligtvis används tvådimensionella arrayer med lika många element i varje rad För att bearbeta tvådimensionella arrayer, används två kapslade slingor med olika räknare (vi fyller en tvådimensionell array med slumpmässiga tal från 0 till 9 och visa det på skärmen i form av en matris): int da = new int; for(int i=0; i Skapa en tvådimensionell matris med 8 rader med 5 kolumner var och en av slumpmässiga heltal från segmentet. Visa arrayen på skärmen. Skapa en tvådimensionell array med 5 rader med 8 kolumner vardera med slumpmässiga heltal från segmentet [-99;99]. Visa arrayen på skärmen. Visa sedan värdet för det maximala elementet i denna array på en separat rad (dess index spelar ingen roll). Skapa en tvådimensionell array med 7 rader med 4 kolumner vardera med slumpmässiga heltal från segmentet [-5;5]. Visa arrayen på skärmen. Bestäm och visa indexet för raden med den största absoluta produkten av element. Om det finns flera sådana rader, skriv ut indexet för den första som påträffades. Skapa en tvådimensionell matris med 6 rader med 7 kolumner vardera med slumpmässiga heltal från segmentet. Visa arrayen på skärmen. Förvandla arrayen så att det största elementet i varje rad kommer först. I det här fallet kan arrayens sammansättning inte ändras, utan endast elementen kan omarrangeras inom en rad. Ordningen på de återstående elementen i raden är inte viktig (dvs. du kan bara göra en permutation, eller så kan du sortera varje rad i fallande ordning). Visa den konverterade arrayen på skärmen. För att testa elevernas restkunskaper efter sommarlovet beslutade grundskolläraren att börja varje lektion med att fråga varje elev ett exempel från multiplikationstabellen, men det är 15 personer i klassen, och exemplen bland dem ska inte upprepas. . För att hjälpa läraren, skriv ett program som visar 15 slumpmässiga exempel från multiplikationstabellen (från 2*2 till 9*9, eftersom multiplikationsuppgifterna med 1 och 10 är för enkla). Dessutom, bland de 15 exemplen bör det inte finnas några upprepade exemplen (exempel 2*3 och 3*2 och liknande par bör anses upprepas). 2010, Alexey Nikolaevich Kostin. Institutionen för TIDM, Matematiska fakulteten, Moscow State Pedagogical University. 19 svar Du kan använda en arraydeklaration eller en arrayliteral (men bara när du omedelbart deklarerar och påverkar en variabel; arrayliterals kan inte användas för att omtilldela en array). För primitiva typer: Int myIntArray = ny int; int myIntArray = (1,2,3); int myIntArray = new int(1,2,3); För klasser som String är det samma sak: String myStringArray = ny String; String myStringArray = ("a","b","c"); String myStringArray = new String("a","b","c"); Den tredje initieringsmetoden är användbar när du först deklarerar en array och sedan initierar den. Här behövs en cast. String myStringArray; myStringArray = new String("a","b","c"); Det finns två typer av array. Syntax för standardvärde: Int num = ny int; Eller (mindre föredraget) Int num = ny int; Syntax med specificerade värden (variabel/fältinitiering): Int num = (1,2,3,4,5); Eller (mindre föredraget) Int num = (1, 2, 3, 4, 5); Notera. För enkelhetens skull är int num att föredra eftersom det tydligt anger att du talar om en array här. Annars är det ingen skillnad. Inte alls. Int num = ny int; Int num = ny int; Int num=((1,2), (1,2), (1,2), (1,2), (1,2) ); Så här definierar vi explicit kolumnerna. Int num=((1), (1,2), (1,2,3,4,5), (1,2), (1,2,3) );Uppgifter
Endimensionell array
Flerdimensionell array
Deklaration
int num = ny int; Initialisering
num=1; num=2; num=1; num=2; num=1; num=2; num=1; num=2; num=1; num=2; Ragged Array (eller icke-rektangulär array)
int num = ny int; num = ny int; num = ny int; num = ny int; num = ny int;
En annan väg:Få tillgång till:
för (int i=0; i<(num.length); i++) {
for (int j=0;j
For (int a: num) ( för (int i: a) ( System.out.println(i); ) )
Typ variabelnamn = ny typ; Typ variableName = (kommaavgränsade värden); Typ variabelnamn = ny typ; Typ variableName = (kommaavgränsade värden);
är också giltigt, men jag föredrar parenteser efter typen eftersom det är lättare att se att variabelns typ faktiskt är en array.
Följande visar en matrisdeklaration, men matrisen är inte initierad:
Int myIntArray = ny int;
Nedan är deklarationen samt initieringen av arrayen:
Int myIntArray = (1,2,3);
Nu visar följande också deklarationen samt initieringen av arrayen:
Int myIntArray = new int(1,2,3);
Men denna tredje visar egenskapen anonym skapande för ett array-objekt, vilket indikeras av referensvariabeln "myIntArray", så om vi bara skriver "new int(1,2,3);" då kan det vara ett anonymt arrayobjekt.
Om vi bara skriver:
Int myIntArray;
Detta är inte en matrisdeklaration, men följande uttalande gör följande uttryck komplett:
MyIntArray=ny int;
Jag tycker att det är användbart om du förstår varje del:
Typnamn = ny typ;
Typ är typen av en variabel som heter namn ("namn" kallas en identifierare). Den bokstavliga "Typ" är bastypen, och parenteserna betyder att det är matristypen för den basen. Arraytyper är i sin tur sina egna, vilket gör att du kan skapa flerdimensionella arrayer av typen Type ( array typ Type ). Det nya nyckelordet hänvisar till allokeringen av minne för en ny array. Siffran mellan parentesen talar om hur stor den nya arrayen kommer att bli och hur mycket minne som kommer att tilldelas. Till exempel, om Java vet att den underliggande typen är 32 byte och du vill ha en array av storlek 5, måste den internt allokera 32 * 5 = 160 byte.
Du kan också skapa arrayer med redan befintliga värden, som t.ex
Int namn = (1, 2, 3, 4, 5);
som inte bara skapar tomrum, utan också fyller det med dessa värden. Java kan berätta att primitiva är heltal och att det finns 5 av dem, så storleken på arrayen kan bestämmas implicit.
Dessutom, om du vill ha något mer dynamiskt, finns det List-gränssnittet. Detta fungerar inte, men är mer flexibelt:
Lista
Det finns två huvudsakliga sätt att skapa en array:
Den här, för en tom array:
Int array = ny int[n]; // "n" är antalet utrymmen som ska allokeras i arrayen
Och den här, för en initierad array:
Int array = (1,2,3,4 ...);
Du kan också skapa flerdimensionella arrayer, till exempel:
Int array2d = new int[x][y]; // "x" och "y" anger dimensionerna int array2d = ((1,2,3 ...), (4,5,6 ...) ...);
Ta den primitiva typen int till exempel. Det finns flera sätt att deklarera en int-array:
Int i = ny int; int i = ny int (värde1, värde2, värde3, etc); int i = (värde1, värde2, värde3, etc);
där du i alla dessa fall kan använda int i istället för int i .
Med reflektion kan du använda (Type) Array.newInstance(Type.class, capacity);
Observera att metodparametrarna... visar variabelargument . I grund och botten är valfritt antal parametrar bra. Det är lättare att förklara med kod:
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);
Inuti metoden behandlas varargs som en vanlig int. Typ... kan bara användas i metodparametrar, så int... i = new int() kompileras inte.
Observera att när du skickar en int till en metod (eller någon annan typ), kan du inte använda den tredje vägen. I satsen int i = *(a, b, c, d, etc)* antar kompilatorn att (...) betyder int . Men det är för att du deklarerar en variabel. När en array skickas till en metod måste deklarationen vara antingen ny typ eller ny typ (...) .
Flerdimensionella arrayer
Flerdimensionella arrayer är mycket svårare att hantera. I grund och botten är en 2D-array en uppsättning av arrayer. int betyder array av int s. Nyckeln är att om en int deklareras som int[x][y] är det maximala indexet i . I huvudsak är en rektangel int lika med:
Deklarera en uppsättning objektreferenser:
Class Animal () class Horse extends Animal ( public static void main(String args) ( /* * Array of Animal kan innehålla djur och häst (alla undertyper av djur tillåtna) */ Animal a1 = new Animal; a1 = new Animal() ; a1 = new Horse(); /* * Array of Animal and all subtype of Horse */ Animal a2 = new Animal( of Horse kan endast innehålla häst och dess undertyp (om någon) och inte tillåten supertyp av häst eller annan undertyp av Djur */ Häst h1 = ny Häst;
En array är en sekventiell lista med element
Int artikel = värde; int one_dimensional_array = (värde, värde, värde, .., värde ); int two_dimensional_array = ( ( värde, värde, värde, .. värde ), ( värde, värde, värde, .. värde ), .. .. .. .. ( värde, värde, värde, .. värde ) );
Om detta är ett objekt så är detta samma koncept
Objektobjekt = nytt Objekt(); Objekt one_dimensional_array = (nytt Objekt(), nytt Objekt(), .. nytt Objekt() ); Object two_dimensional_array = ( ( new Object(), new Object(), .. new Object() ), ( new Object(), new Object(), .. new Object() ), .. .. .. ( new Object() Object(), new Object(), .. new Object() ) );
När det gäller objekt måste du antingen tilldela det till null för initiering med ny Type(..) , klasser som String och Integer är specialfall som kommer att behandlas enligt följande
String a = ("hej", "värld" ); // är ekvivalent med String a = (new String(("h","e","l","l","o")), new String(("w","o","r" "l", "d"))); Heltal b = (1234, 5678); // är ekvivalent med heltal b = (nytt heltal(1234), nytt heltal(5678) );
I allmänhet kan du skapa arrayer som är M-dimensionella
Int .. array = // ^ M gånger parentes ((..( // ^ M gånger ( parentes // detta är array.. // ^ M gånger ))..) // ^ M gånger ) parentes ;
Det är värt att notera att det är dyrt att skapa en dimensionell array M ur ett rymdperspektiv. För när du skapar en array M med N i alla dimensioner, är den totala storleken på arrayen större än N^M , eftersom varje array har en länk, och i M-dimensionen finns det en (M -1)-dimensionell array av länkar. Den totala storleken är som följer
Vad är en array?
En array i Java är en samling element av samma typ som kan nås med index.
Arrayelement i Java finns efter varandra i datorns minne. Nedan är ett exempel på en array i Java.
Deklarera en Array i Java
Låt oss deklarera en array för att lagra element av typen int:
Här deklareras variabeln arr, vilket är en matris. För att använda denna variabel måste du definiera den.
Array Definition i Java
För att definiera en array i Java måste du ange dess längd, dvs. antal element som kan lagras i den:
Vår array kommer att lagra 5 element.
En array är en samling element. Varje element i arrayen kan refereras till med sitt nummer. Numret brukar kallas index. Numreringen av arrayelement i Java börjar från noll.
Hur laddar man in element i en array?
Låt oss tilldela ett värde till det första elementet i arrayen, och det första elementet har index noll:
Låt oss tilldela ett värde till det andra elementet i arrayen, och det andra elementet har index ett:
for(int inn = 0; inn< 5; inn++)
{
arr = värdshus;
}
När du deklarerar en array kan du omedelbart ladda in värden i den:
int arr = (0, 1, 2, 3, 4);
antalet element här är 5, dvs. Det finns inget behov av att ange antalet element, det bestäms automatiskt.
Hur får man element från en array?
Varje element i arrayen kan refereras till med sitt nummer. För att få ett element av en array måste du ange namnet på arrayen och indexet för elementet:
Detta är det första elementet i arrayen, eftersom det första elementet har index noll.
Låt oss tilldela värdet av det tredje elementet i arrayen till variabeln int a:
Låt oss mata ut alla element i arrayen i en loop (vi itererar över arrayen):
For(int inn = 0; inn< 5; inn++) { System.out.println("arr[" + inn + "] = " + arr); }
En förenklad version av slingan för att mata ut en array är som följer:
For(int inn: arr) ( System.out.println("arr[" + inn + "] = " + arr); )
Hur tar man bort en array i Java?
Du kan ta bort en array i Java så här:
Hur får man längden på en array i Java?
Vi får längden på en array i Java så här:
int arrLength = arr.length;
Hur får man det första elementet i en array i Java?
int firstElem = arr;
Hur får man det halvsista elementet i en array i Java?
int lastElem = arr;
Hur definierar man en array med variabel längd i Java?
Hur definierar man en array med variabel längd i Java? Aldrig. När du definierar en array ställer du sedan in dess längd. I sådana fall används samlingar, till exempel: Vector, ArrayList, etc.
Så arraylängden kan inte vara variabel. Men du kan använda en variabel när du definierar en array. Om så är fallet:
int cd;
int ab = ny int;//Fel.
då får vi ett fel: längden på arrayen kan inte vara en variabel.
Du måste ställa in cd-värdet:
int cd = 10;
int ab = ny int;
Det är okej nu. Om du ändrar cd-variabeln efter att ha definierat arrayen kommer detta inte att påverka arrayen, d.v.s. dess längd kommer inte att ändras. Exempel:
Int cd = 10; int ab = ny int; cd = 12;// Detta är möjligt arrLength = ab.length; System.out.println("ab array length = " + arrLength); //Utgångar: ab arraylängd = 10 ab=4;// Och här är felet
Vi får ett felmeddelande:
Undantag i tråden "main" java.lang.ArrayIndexOutOfBoundsException: 11
Det maximala indexet för vår array är 9. Att ändra värdet på cd-variabeln påverkar inte arrayen, eftersom den redan är definierad och dess längd är konstant.
Variabler kan användas för att komma åt arrayelement:
Int var = 1;
int elem = arr;
var = 2;
elem = arr;
En rad tecken i Java
Ett exempel på en teckenuppsättning i Java och dess utdata:
Char charArr = ("S", "B", "P"); for(int inn = 0; inn< charArr.length; inn++) { System.out.println("charArr[" + inn + "] = " + charArr); }
Hur fyller man en array i Java?
Du kan fylla en array med den statiska fyllningsmetoden.
Studera för att bli "Spelutvecklare" + anställning
Java-arrayer
En array är en datastruktur som lagrar värden av samma typ. Ett individuellt arrayelement nås med hjälp av ett heltalsindex. Till exempel, om a är en matris med heltal, då är värdet på uttrycket a[i] lika med det i:te heltal i matrisen.
En array deklareras enligt följande: först indikeras typen av array, det vill säga typen av element som finns i arrayen, följt av ett par tomma hakparenteser och sedan variabelns namn. Så här deklarerar du till exempel en array som består av heltal:
int a;
Men denna sats deklarerar endast variabeln a, utan att initialisera den med en faktisk array. För att skapa en array måste du använda den nya operatorn.
Denna operator skapar en array med 100 heltal. Elementen i denna array är numrerade från 0 till 99 (inte från 1 till 100). När den väl har skapats kan arrayen fyllas, till exempel med hjälp av en loop.
int a = ny int;
för (int i = 0; i< 100; i++)
a[i] = i; // Fyller matrisen med siffror från 0 till 99.
Om du försöker komma åt element a (eller något annat element vars index ligger utanför intervallet 0 till 99) genom att skapa en array med 100 element, kommer programmet att avslutas eftersom ett arrayindex utanför gränserna kommer att inträffa.
För att räkna antalet element i en array, använd metoden nameArray-
va.längd.
Till exempel,
för (int i = 0; i< a. length; i++ System.out.println (a[i]);
När en array väl har skapats är det omöjligt att ändra dess storlek (även om du naturligtvis kan ändra dess individuella element). Om du behöver ändra storleken på en array ofta under programkörning, är det bättre att använda en annan datastruktur som kallas en arraylista.
En matris kan deklareras på två sätt:
int a;
eller
int a;
De flesta Java-programmerare föredrar den första stilen eftersom den tydligare skiljer int-arraytypen från variabelnamnet.
Arrayinitierare och namnlösa arrayer
Java har en funktion för att samtidigt skapa en array och initiera den. Här är ett exempel på en sådan syntaktisk struktur:
int smallPrimes = (2, 3, 5, 7, 11, 13);
Observera att det i detta fall inte finns något behov av att använda den nya operatören. Dessutom kan du till och med initiera en namnlös array:
ny int ( 16, 19, 23, 29, 31, 37)
Detta uttryck allokerar minne för en ny array och fyller den med siffrorna som anges med klammerparenteser. I det här fallet beräknas deras antal och följaktligen bestäms storleken på arrayen. Denna syntaktiska konstruktion är bekväm att använda för att återinitiera en array utan att skapa en ny variabel. Till exempel uttrycket
smallPrimes = new int( 17, 19, 23, 29, 31, 37 );
är ett förkortat uttryck
int anonym = (17, 19, 23, 29, 31, 37);
smailPrimes = anonym;
Du kan skapa en array med noll storlek. En sådan array kan vara användbar när man skriver en metod som utvärderar en array som visar sig vara tom. En nolllängdsmatris deklareras enligt följande:
ny elementtyp
Observera att en sådan array inte är ekvivalent med ett nollobjekt.
Kopiera arrayer
En array kan kopieras till en annan, men båda variablerna kommer att referera till samma array.
int luckyNumbers = smailPrimes;
luckyNimbers = 12; // Nu är elementet smailPrimes också 12.
Resultatet visas i fig. 3.14. Om du behöver kopiera alla element i en array till en annan bör du använda arraycopy-metoden från klassen System. Dess anrop ser ut så här:
System.arraycopy(from, fromlndex, to, tolndex, count);
Till-matrisen måste vara tillräckligt stor för att innehålla alla element som ska kopieras.
Ris. 3.14. Kopiera en array
Till exempel, operatörerna som visas nedan, vars resultat visas i fig. 3.15, skapa två arrayer och kopiera sedan de fyra sista elementen i den första arrayen till den andra. Kopiering startar från den andra positionen i källmatrisen, och de kopierade elementen placeras i målmatrisen med start från den tredje positionen.
int smailPrimes = (2, 3, 5, 7, 11, 13);
int luckyNumbers = (1001, 1002, 1003, 1004, 1005, 1006, 1007);
System.aggausor(smailPrimes, 2, luckyNumbers, 3, 4);
för (int i = 0; i< luckyNumbers.length; i++)
System.println(i +.": " + luckyNumbersfi]);
Att utföra dessa uttalanden ger följande resultat.
0: 1001
1: 1002
2: 1003
3: 5
4: 7
5: 11
6: 13
Ris. 3.15. Kopiera arrayelement
En array i Java skiljer sig markant från en array i C++. Det är dock praktiskt taget samma sak som en pekare till en dynamisk array. Detta innebär att operatören
int a = ny int; //Java
är likvärdig med operatören
i n t * = ny i n t [ 1 0 0 ] ; // C++,
men inte
int a; // C++
I Java kontrollerar standardoperatören ingen indexintervallet. Dessutom har Java inte pekaritmetik – du kan inte öka en pekare för att komma åt nästa element i en array.
Senast uppdaterad: 2018-11-09
En array representerar en uppsättning värden av samma typ. Att deklarera en array liknar att deklarera en vanlig variabel som lagrar ett enda värde, och det finns två sätt att deklarera en array:
datatyp matrisnamn; // antingen datatyp matrisnamn;
Låt oss till exempel definiera en array av tal:
Int nums; int nums2;
Efter att ha deklarerat arrayen kan vi initiera den:
Int nums; nums = ny int; // matris med 4 nummer
En array skapas med följande konstruktion: new data_type[antal element] , där new är ett nyckelord som allokerar minne för det antal element som anges inom parentes. Till exempel, nums = new int; - detta uttryck skapar en array med fyra int-element, och varje element kommer att ha ett standardvärde på 0.
Du kan också omedelbart initiera en array när du deklarerar den:
Int nums = ny int; // matris med 4 nummer int nums2 = ny int; // matris med 5 nummer
Med sådan initiering har alla arrayelement ett standardvärde. För numeriska typer (inklusive char-typen) är detta siffran 0, för den booleska typen är detta false , och för andra objekt är detta null . Till exempel, för int-typen är standardvärdet 0, så nums-matrisen som definieras ovan kommer att bestå av fyra nollor.
Men du kan också ställa in specifika värden för elementen i en array när du skapar den:
// dessa två metoder är ekvivalenta int nums = new int ( 1, 2, 3, 5 ); int nums2 = (1, 2, 3, 5);
Det är värt att notera att i det här fallet anger de fyrkantiga parenteserna inte storleken på arrayen, eftersom den beräknas av antalet element i de lockiga hängslarna.
Efter att ha skapat en array kan vi komma åt alla dess element genom index, som skickas inom hakparenteser efter namnet på arrayvariabeln:
Int nums = ny int; // ställ in värdena för arrayelementen nums = 1; nums = 2; nums = 4; nums = 100; // få värdet av det tredje elementet i arrayen System.out.println(nums); // 4
Indexering av arrayelement börjar vid 0, så i det här fallet, för att komma åt det fjärde elementet i arrayen, måste vi använda uttrycket nums.
Och eftersom vår array är definierad för endast 4 element, kan vi inte komma åt till exempel det sjätte elementet: nums = 5; . Om vi försöker göra detta får vi ett felmeddelande.
Array längd
Den viktigaste egenskapen som arrayer har är length-egenskapen, som returnerar längden på arrayen, det vill säga antalet av dess element:
Int nums = (1, 2, 3, 4, 5); int längd = nums.length; // 5
Det är inte ovanligt att det sista indexet är okänt, och för att få det sista elementet i en array kan vi använda den här egenskapen:
Int sista = nums;
Flerdimensionella arrayer
Tidigare tittade vi på endimensionella arrayer, som kan representeras som en kedja eller sträng av värden av samma typ. Men förutom endimensionella arrayer finns det även flerdimensionella. Den mest kända flerdimensionella arrayen är en tabell som representerar en tvådimensionell array:
Int nums1 = new int ( 0, 1, 2, 3, 4, 5 ); int nums2 = ( ( 0, 1, 2 ), ( 3, 4, 5 ) );
Visuellt kan båda arrayerna representeras enligt följande:
Endimensionell array nums1
Tvådimensionell array nums2
Eftersom nums2-matrisen är tvådimensionell är det en enkel tabell. Det kan också skapas så här: int nums2 = new int; . Antalet hakparenteser anger storleken på arrayen. Och siffrorna inom parentes indikerar antalet rader och kolumner. Och även, med hjälp av index, kan vi använda arrayelement i ett program:
// ställ in elementet i den första kolumnen i den andra raden nums2=44; System.out.println(nums2);
En tredimensionell matrisdeklaration kan se ut så här:
Int nums3 = ny int;
Jagged array
Flerdimensionella arrayer kan också representeras som "jagged arrays". I exemplet ovan hade den tvådimensionella arrayen 3 rader och tre kolumner, så vi hade en platt tabell. Men vi kan tilldela varje element i en tvådimensionell array en separat array med ett annat antal element:
Int nums = ny int; nums = ny int; nums = ny int; nums = ny int;
för varje
En speciell version av for-loopen är utformad för att iterera över element i uppsättningar av element, såsom arrayer och samlingar. Det liknar foreach loop som finns i andra programmeringsspråk. Dess formella tillkännagivande:
För (data_typ variabelnamn: behållare)( // åtgärder)
Till exempel:
Int array = new int ( 1, 2, 3, 4, 5 ); for (int i: array)( System.out.println(i); )
I det här fallet är behållaren en datamatris av typen int . Sedan deklareras en variabel av typen int
Samma sak kan göras med den vanliga versionen av för:
Int array = new int ( 1, 2, 3, 4, 5 ); för (int i = 0; i< array.length; i++){ System.out.println(array[i]); }
Samtidigt är den här versionen av for-loopen mer flexibel än för (int i: array) . I synnerhet i den här versionen kan vi ändra elementen:
Int array = new int ( 1, 2, 3, 4, 5 ); för (int i=0; i Först skapas en loop för att iterera över raderna, och sedan inom den första loopen skapas en inre loop för att iterera över kolumnerna i en viss rad. På liknande sätt kan du iterera över tredimensionella arrayer och uppsättningar med ett stort antal dimensioner.Slingor genom flerdimensionella arrayer
int nums = new int ( (1, 2, 3), (4, 5, 6), (7, 8, 9) ); för (int i = 0; i< nums.length; i++){
for(int j=0; j < nums[i].length; j++){
System.out.printf("%d ", nums[i][j]);
}
System.out.println();
}