Lägg till ett värde till en java-array. Att lära sig Java


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 rad 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 det här fallet 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 sätta i mas2-matrisen samma uppsättning värden som lagras 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 4 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, så i par * bearbetar hela fragmentet */ för (int j = 0; j a) ( int temp = a[j]; a[j] = a; a = temp. ; sorterad = falskt; ) ) /* Om arrayen är sorterad (dvs. det fanns inga permutationer * i den inre slingan, då kan 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 av vilken en länk till någon rad i matrisen kan vara en tredimensionell array 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 matris, 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

Uppgifter

    Skapa en tvådimensionell matris med 8 rader med 5 kolumner vardera med slumpmässiga heltal från segmentet. Visa arrayen på skärmen.

    Skapa en tvådimensionell matris 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.

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

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

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.

Vad är en array?

En array i Java är en samling element av samma typ som kan nås med index.

Array-element 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 ingen anledning 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 i 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 visa 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 in dess längd, den kan inte ändras senare. 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.

Java har arrayer. Dessa arrayer är maskinskrivna. Deklaration

Peka på mina poäng;

beskriver variabeln myPoints som en array av objekt av typen Point. Du kan skapa en array av en viss storlek med hjälp av instruktioner som

myPoints = ny punkt;

Värdena för arrayelementen sätts lika med specialvärdet null.

Storleken på arrayen kan erhållas under programkörning:

howMany = myPoints.length;

För att skapa en array kan du använda hakparenteser till höger om arraynamnet eller typen av objekt som utgör arrayen, till exempel:

int nAnotherNumbers;

Båda alternativen är giltiga, så du kan välja den du gillar bäst.

När du definierar arrayer i Java kan du inte ange deras storlek. Ovanstående två rader orsakar ingen minnesreservation för arrayen. Här skapas helt enkelt referenser till arrayer, som inte kan användas utan initialisering.

För att beställa minne för en array måste du skapa motsvarande objekt med det nya nyckelordet, till exempel:

int nAnotherNumbers;

nAnotherNumbers = ny int;

Hur initierar man tabellceller?

Denna initiering kan göras antingen statiskt eller dynamiskt. I det första fallet listar du helt enkelt värdena i hängslen, som visas nedan:

int nColorRed = (255, 255, 100, 0, 10);

Dynamisk initiering görs med hjälp av arrayindex, till exempel i en loop:

int nInitialValue = 7;

int nAnotherNumbers;

nAnotherNumbers = ny int;

for(int i = 0; i< 15; i++)

Det är möjligt att skapa arrayer inte bara från variabler av grundläggande typer, utan också från godtyckliga objekt. Varje element i en sådan array måste initieras med den nya operatören.

Arrayer kan vara flerdimensionella och, intressant nog, asymmetriska.

Nedan skapas en array av arrayer. En matris med fyra tal skapas i noll och första elementet, och en matris med åtta i det andra:

int nDim = ny int;

nDim = ny int;

nDim = ny int;

nDim = ny int;

Under applikationskörning kontrollerar Java Virtual Machine efter detektering av array out-of-bounds. Om applikationen försöker gå utanför gränserna för arrayen uppstår ett undantag.

Arrayer i Java är objekt av någon inbyggd klass. För den här klassen är det möjligt att bestämma storleken på arrayen genom att komma åt klassdatamedlemmen med namnet längd, till exempel:

int nAnotherNumbers;

nAnotherNumbers = ny int;

for(int i = 0; i< nAnotherNumbers.length; i++)

nAnotherNumbers[i] = nInitialValue;

För att bestämma storleken på en array behöver du inte en operator som sizeof från programmeringsspråket C eftersom det finns ett annat sätt att bestämma storleken.

Det finns inga andra strukturella typer (som inte är objekt) i Java-språket, det vill säga det finns inga strukturer, fackföreningar etc. Det finns inga pekare i Java heller.

Teckensträngar är objekt av typen String (textkonstanter) eller StringBuffer (föränderliga strängar). Exempel:

String hej = "Hej värld!";







2024 gtavrl.ru.