Hej igen! :) I dagens lektion kommer vi att prata om Arrays-klassen i Java. På förra lektionen lärde vi känna en sådan datastruktur som kallas en array. Vi lärde oss hur man skapar dem och fyller dem med data. Och vi tittade på hur de lagras i minnet. Idag ska vi titta på några uppgifter och exempel på att arbeta med arrayer som du ofta kommer att se i verkligt arbete. Föreställ dig till exempel den här situationen: Vi har en matris med 10 slumptal.
Vår uppgift är att sortera denna matris i stigande ordning: från minsta till största. I slutändan ska det se ut så här: [-234, -2, 16, 26, 35, 43, 92, 99, 167] Hur gör vi det? Den här uppgiften är inte trivial. Vi har aldrig gjort det här förut :/ Några idéer? Försöka gissa. Här är en lösning:
Gå igenom alla element i arrayen. Jämför varje element med nästa ([0] med [1], [1] med [2], [2] med [3], etc.). Om det aktuella elementet är större än nästa, byter vi dem och går sedan vidare till nästa element. Om inte, lämna dem som de är och gå vidare
Således, efter den första passagen genom elementen, är det största värdet (167) garanterat i den sista cellen.
Nu ska vi gå igenom alla element igen, men den här gången börjar vi med indexet [0] till det näst sista elementet (det största antalet finns redan på sin plats) och gör samma jämförelser och byten. Efter detta pass, i den näst sista cellen, kommer vi att ha det näst största värdet (99).
Upprepa denna process så många gånger som vi har arrayelement.
Vi har idén. Nu behöver vi bara skriva koden. Det ser ut så här:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
for (int i = numbers.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
/* Compare the elements in pairs.
If they are not in the right order,
then swap them */
if (numbers[j] > numbers[j + 1]) {
int tmp = numbers[j];
numbers[j] = numbers[j + 1];
numbers[j + 1] = tmp;
}
}
}
}
}
Eh ... Det ser lite komplicerat ut -_- Även om den allmänna principen är förståelig måste vi fortfarande skriva ganska mycket kod för att lösa en så enkel uppgift. Okej, vi kanske bara har överskattat oss själva? Uppgiften vi har tagit oss an är förmodligen fortfarande för komplicerad för oss. Låt oss prova något enklare. Ta till exempel samma nummermatris.
Vår uppgift är att kopiera dess innehåll till en annan array.
int [] numbersCopy = new int[10];
Fundera på hur du skulle göra det med det du redan vet om arrayer? Du kan till exempel gå igenom nummermatrisen i en slinga och sekventiellt skriva dess element i numbersCopy :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = new int[10];
for (int i = 0; i < numbers.length; i++) {
numbersCopy[i] = numbers[i];
}
}
}
Nåväl, här har vi i princip gjort det! Det verkar som att vi har löst problemet. Men om du behöver göra detta ofta kommer din kod att ha ett gäng identiska loopar. Faktum är att dessa (och andra) uppgifter länge har lösts av Javas skapare. Vi behöver inte "uppfinna hjulet på nytt" och koda vår egen lösning. Det finns en speciell statisk klass ( Arrays ) som hjälper dig att utföra vanliga uppgifter när du arbetar med arrayer. Metoder för att utföra de vanligaste uppgifterna för Java-programmerare har lagts till i denna klass. Till exempel, uppgiften att sortera en array, som vi försökte hantera, löses på en enda rad:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));
}
}
Metoden Arrays.sort () sorterar arrayen. Och dess algoritm är mycket effektivare än koden vi skrev. Konsolutgång: [-234, -2, 16, 26, 35, 43, 80, 92, 99, 167] Obs: För att konvertera arrayen till en sträng använde vi en annan metod i klassen Arrays : Arrays.toString() . Arrayer i Java åsidosätter inte metoden toString() på egen hand. Så om du bara skriver
System.out.println(numbers.toString());
objektklassens toString() kommer att anropas. För en array kommer utgången att vara ungefär så här: [I@4554617c Vi kommer inte att gå in i detalj nu om varför just detta är utgången. Huvudsaken är att det helt klart inte är vad vi behöver. Men Arrays.toString() gör precis vad vi vill. Förresten, kopiering är också lätt att utföra med klassen Arrays :
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(numbersCopy));
}
}
Vi överför till metoden Arrays.copyOf() vår ursprungliga array (från vilken vi vill kopiera värden) och längden på den nya array som vi kopierar data till. I det här fallet angav vi numbers.length som längden, eftersom vi vill kopiera hela arrayen. Om vi bara ville kopiera de första elementen, kan vi ange längden på en ny mindre array:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOf(numbers, 4);
System.out.println(Arrays.toString(numbersCopy));
}
}
Här angav vi 4 som längden på den nya arrayen. Följaktligen kommer endast de fyra första elementen av siffror att kopieras till den nya arrayen. Konsolutgång: [167, -2, 16, 99] Förresten låter Arrays dig också kopiera en del av en array från mitten snarare än från början av arrayen:
public class Main {
public static void main(String[] args) {
int[] numbers = {167, -2, 16, 99, 26, 92, 43, -234, 35, 80};
int [] numbersCopy = Arrays.copyOfRange(numbers, 2,6);
System.out.println(Arrays.toString(numbersCopy));
}
}
Utdata: [16, 99, 26, 92] Siffror kopierades till den nya matrisen från den andra matrisen från det andra (inklusive) till det sjätte (ej inkluderande) elementet. Vi kan också behöva jämföra två arrayer. Precis som med metoden toString() åsidosätter inte arrayerna själva metoden equals() . Så om vi försöker jämföra dem så här
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(numbers.equals(numbers2));
}
}
då blir vi falska. Detta beror på att Object.equals() , som jämför referenser, kommer att anropas. Och uppenbarligen är de olika! Men vad vi behöver är att jämföra arrayinnehåll, inte referenser. Klassen Arrays åsidosätter metoden equals() för att få den att göra exakt vad vi vill:
public class Main {
public static void main(String[] args) {
int[] numbers = {1, 2, 3};
int[] numbers2 = {1, 2, 3};
System.out.println(Arrays.equals(numbers, numbers2));
}
}
Utdata: sant Förresten, klassen Arrays fungerar inte bara med vanliga arrayer utan även med tvådimensionella:
public class Main {
public static void main(String[] args) {
int[][] numbers = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int[][] numbersCopy = Arrays.copyOf(numbers, numbers.length);
System.out.println("Are these two-dimensional arrays equal?");
System.out.println(Arrays.deepEquals(numbers, numbersCopy));
System.out.println(Arrays.deepToString(numbersCopy));
}
}
Utdata: Är dessa tvådimensionella arrayer lika? true [[1, 2, 3], [4, 5, 6], [7, 8, 9]] Som du kan se kunde Arrays.copyOf() -metoden kopiera en tvådimensionell array. Och klassen har speciella metoder för att jämföra och visa tvådimensionella arrayer: deepEquals och deepToString() . I framtiden kommer du upprepade gånger att se (och glädja dig över det) att Javas skapare förutsåg många situationer som ofta möttes av programmerare och implementerade färdiga lösningar för dem i språket. Att använda dessa lösningar är mycket enklare och bekvämare än att återuppfinna hjulet, eller hur? :) Se till att läsa dokumentationen för Arrays-klassen på Oracles webbplats. Lycka till i dina studier!
GO TO FULL VERSION