Skip to content

A
alx_mszczonow_1
Commit ce58992e by Patryk Czarnik
Options

Przykłady dot. tablic

parent 6f3ec09d
Showing with 347 additions and 0 deletions
src/main/java/p21_tablice/A_Wprowadzenie.java 0 → 100644
package p21_tablice;
import java.util.Arrays;
public class A_Wprowadzenie {
public static void main(String[] args) {
// Gdy potrzebujemy zapamiętać wiele wartości tego samego typu to niby możemy utworzyć wiele zmiennych:
String miasto1, miasto2, miasto3;
miasto1 = "Warszawa";
miasto2 = "Kraków";
miasto3 = "Poznań";
System.out.println("Miasto nr 1: " + miasto1);
System.out.println("Miasto nr 2: " + miasto2);
System.out.println("Miasto nr 3: " + miasto3);
System.out.println();
// Takie podejście ma jednak co najmniej 2 wady:
// 1) nie skaluje się - to jest dobre dla kilku wartości, ale nie tysięcy lub więcej
// 2) do każdej zmiennej trzeba odwoływać się niezależnie i nie ma jak napisać operacji "dla wszystkich elementów na raz"
// W takich sytuacjach używa się tablic lub kolekcji.
// Tablice są rozwiązaniem bardziej podstawowym, są elementem języka;
// kolekcje (np. listy) to są klasy, których się używa pisząc odp. operacje
// Deklarujemy zmienną typu "tablica Stringów" i wpisujemy do niej tablicę rozmiaru 10.
String[] miasta = new String[10];
// Do pojedynczych elementów tablicy można odwoływać się za pomocą tablica[numer] i korzystać podobnie jak ze zwykłych zmiennych:
miasta[1] = "Warszawa";
miasta[2] = "Kraków";
miasta[3] = "Poznań";
System.out.println("Drugim miastem jest " + miasta[2]);
// Numer pozycji można przekazać w zmiennej:
int pozycja = 3;
System.out.println("Miasto nr " + pozycja + " to " + miasta[pozycja]);
System.out.println();
// Ale dla tablic możliwe jest też wykonywanie operacji "dla wszystkich elementów"
// albo za pomocą pętli, albo dedykowanych metod.
// Jak wypisać cała tablicę?
// Próba użycia zwykłego print:
System.out.println(miasta);
// Ale można użyć operacji Arrays.toString
System.out.println(Arrays.toString(miasta));
System.out.println();
// Przy okazji widzimy, że:
// * pozycje w tablicy są numerowane od 0 do rozmiar-1
// * w miejscach, gdzie nie wpisaliśmy żadnej wartości, mamy null
// Próba dostępu do elementu poza zakresem (czyli tu poza zakresem od 0 do 9) kończy się wyjątkiem:
//EXN System.out.println(miasta[20]);
//EXN miasta[10] = "Żyrardów";
}
}
src/main/java/p21_tablice/B_Tworzenie.java 0 → 100644
package p21_tablice;
import java.util.Arrays;
public class B_Tworzenie {
public static void main(String[] args) {
int[] a;
// tylko deklaracja zmiennej, zmienna jest niezainicjowana
// Poniższe linie się nie kompilują:
// System.out.println(a);
// System.out.println(a[1]);
// a[1] = 10; // to jest tak naprawdę ODCZYT zmiennej a (bo a jest referencją)
// System.out.println(a[1]);
a = null;
System.out.println(a);
int rozmiar = 10;
// utworzenie tablicy i wpisanie do zmiennej a
// Tak tworzona tablica ma określony rozmiar i jest inicjalizaowana wartościami null, 0 lub false
a = new int[rozmiar];
a[1] = 133;
a[3] = 150;
System.out.println(Arrays.toString(a));
// Istniejącej tablicy nie da się rozszerzać, można najwyżej utworzyć nową tablicę i wpisać na dotychczasową zmienną - ale to będzie utrata danych.
// do zmiennej a można wpisać inną (np. nową) tablicę - dotychczasowa jest zapominana
a = new int[2*rozmiar];
System.out.println(Arrays.toString(a));
System.out.println();
// można deklaracje i inicjalizacje zapisać w jednej linii:
double[] wspolrzedne = new double[3];
System.out.println(Arrays.toString(wspolrzedne));
// takiej składni nie ma w Javie
//NK int[20] c;
//NK int c[20];
// to jest poprawna składnia:
int d[] = new int[13];
int d1[], d2[], d3;
d1 = new int[1];
d3 = 15;
// Tablic, ani innych obiektów, się w Javie nie usuwa z pamięci - Java robi to automatycznie.
// long[] duza = new long[1000000000]; // OutOfMemory
// Można też tworzyć tablice od razu podając ich zawartość:
int piecdziesiat = 50;
// deklaracje nowych zmiennych:
// mogę użyć najkrótszej składni: nawiasy klamrowe i wartości w środku,
int[] e = {10, 20, 30, 40, piecdziesiat};
int[] f = {10, 20, 30, 40, piecdziesiat, 60, };
// mogę też użyć składni new int[] {elementy}
int[] g = new int[] {10, 20, 30, 40, 50};
// Jeśli to już nie jest deklaracja nowej zmiennej, tylko przypisanie do starej zmiennej lub inne sytuacje
// to nie mogę już używać najkrótszej składni
// f = {44, 55, 66, 77, 88};
// tylko muszę pisać new
f = new int[] {44, 55, 66, 77};
int wynik = suma(e);
System.out.println(wynik);
// tej składni można też użyć, gdy tablica jest parametrem funkcji
wynik = suma(new int[] {1,3,5,7});
System.out.println(wynik);
// wynik = suma({1,3,5,7});
// System.out.println(wynik);
// Tablice utworzone za pomocą {} też można modyfikować.
// Zarówno zawartość, jak i same zmienne
System.out.println(e); // [I@6d06d69c
System.out.println(Arrays.toString(e)); // zawartość
e[1] = 24;
e[2]++;
System.out.println(Arrays.toString(e));
e = new int[5]; // zmienna e wskazuje na inną tablicę
System.out.println(Arrays.toString(e));
// Tablic się nie usuwa - zajmuje się tym tzw. "garbage collector" (GC), który działa automatycznie w maszynie wirtualnej Javy (JVM)
}
static int suma(int[] a) {
int suma =0;
for (int x : a) {
suma += x;
}
return suma;
}
}
src/main/java/p21_tablice/C_Petle.java 0 → 100644
package p21_tablice;
import java.util.Arrays;
public class C_Petle {
public static void main(String[] args) {
String[] miasta = {"Warszawa", "Kraków", "Łódź", "Wrocław", "Poznań"};
int[] liczby = {0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
System.out.println(Arrays.toString(miasta));
System.out.println(Arrays.toString(liczby));
System.out.println();
// Są dwa sposoby wykonywania czynności dla wszystkich elementów tablicy:
// 1) Tradycyjna pętla for / for z licznikiem
for(int i = 0; i < miasta.length; i++) {
System.out.println("! " + miasta[i]);
}
System.out.println();
for(int i = 0; i < liczby.length; i++) {
System.out.print(liczby[i] + "; ");
}
System.out.println();
System.out.println();
// 2) Pętla "for-each" / "enhanced for loop"
// Bezpośrednio przeglądamy elementy tablicy/kolekcji. Są one po kolei wpisywane na nową zmienną.
for(String miasto : miasta) {
System.out.println("* " + miasto);
}
System.out.println();
// zwróćmy uwagę, że to są elementy tablicy, a nie indeksy (pozycje)
for(int liczba : liczby) {
System.out.print(liczba + ", ");
}
System.out.println();
System.out.println();
System.out.println();
// Pętla for-each nie nadaje się do modyfikowania zawartości tablicy.
System.out.println(Arrays.toString(liczby));
System.out.println();
System.out.println("w pętli for-each próbuję zmieniać wartości...");
for (int x : liczby) {
x++;
// modyfikowanie zmiennej w for-each nie wpływa na zawartość tablicy
// w x mamy kopię wartości, a nie "referencję do miejsca w tablicy"
}
System.out.println();
System.out.println(Arrays.toString(liczby)); // liczby się nie zmieniły
System.out.println();
// Jeśli chcemy modyfikować elementy tablicy, to w praktyce uzywamy tradycyjnej pętli for
System.out.println("w zwykłym for zmieniam wartości");
for (int i = 0; i < liczby.length; i++) {
System.out.println(liczby[i] + " -> " + (liczby[i]+1));
liczby[i]++;
}
System.out.println(Arrays.toString(liczby));
// Zwykłe pętli for używamy też wtedy, gdy algorytm wymaga jednoczesnego dostępu do różnych elementów.
}
}
src/main/java/p21_tablice/D_Dwuwymiarowe.java 0 → 100644
package p21_tablice;
import java.util.Arrays;
public class D_Dwuwymiarowe {
public static void main(String[] args) {
// Tablice wielowymiarowe... To tak naprawdę tablice tablic.
// Tutaj powstanie 3-elementowa tablica, której elementami są tablice typu int[]
// z których każda ma 5 elementów int.
int[][] a = new int[3][5];
//NK int[][] a2 = new int[3,5];
System.out.println(a.length); // 3
System.out.println(a[0].length); // 5
System.out.println();
// regularna macierz
a[0][4] = 44;
a[1][2] = 22;
System.out.println(a[0][4]);
System.out.println("a: " + a + " , zawartość: " + Arrays.toString(a));
System.out.println("a[0]: " + a[0]+ " , zawartość: " + Arrays.toString(a[0]));
System.out.println();
System.out.println(Arrays.toString(a));
System.out.println(Arrays.deepToString(a));
System.out.println();
// Można nie wypełniać od razu wierszy jednakowymi tablicami,
// ale początkowo zostawić null-e i dopiero potem wpisać poszczególne wiersz.
// Wtedy mogą być one nawet różnej długości.
int[][] b = new int[4][];
System.out.println(Arrays.toString(b));
// inicjujemy poszczególne wiersze
b[0] = new int[7];
Arrays.fill(b[0], 9);
b[1] = new int[] {3, 4, 5};
b[2] = null;
b[3] = new int[0]; // pusta tablica i null to są różne rzeczy
System.out.println(Arrays.deepToString(b));
// Można użyć notacji {} także do wypełniania tablic wielowymiarowych.
String[][] c = {
{"Ala", "Ola", "Ela"},
{"Jacek", "Placek"},
null,
{},
};
System.out.println(Arrays.deepToString(c));
}
}
src/main/java/p21_tablice/E_Kopiowanie.java 0 → 100644
package p21_tablice;
import java.util.Arrays;
public class E_Kopiowanie {
public static void main(String[] args) {
int[] a = {1,2,3,4,5,6,7,8,9};
// clone(), copyOf(), copyOfRange() - tworzą nową tablicę wypełnioną takimi samymi danymi (lub fragment)
int[] b = a.clone();
int[] c = Arrays.copyOf(a, 5);
int[] d = Arrays.copyOf(a, 12);
int[] e = Arrays.copyOfRange(a, 4, 8);
int[] f = Arrays.copyOfRange(a, 4, 12);
// arraycopy: Docelowa tablica musi istnieć
int[] g = new int[8];
System.arraycopy(a, 2, g, 1, 5);
// Referencja do tej samej tablicy (do tego samego obiektu)
// Zmiany w tablicy a będą widziane przez zmienną r i vice versa
int[] r = a;
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("c: " + Arrays.toString(c));
System.out.println("d: " + Arrays.toString(d));
System.out.println("e: " + Arrays.toString(e));
System.out.println("f: " + Arrays.toString(f));
System.out.println("g: " + Arrays.toString(g));
System.out.println("r: " + Arrays.toString(r));
System.out.println();
System.out.println("Zmieniam a w środku");
a[0]=13;
a[1]++;
a[2]+=10;
a[3]*=5;
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("c: " + Arrays.toString(c));
System.out.println("d: " + Arrays.toString(d));
System.out.println("e: " + Arrays.toString(e));
System.out.println("f: " + Arrays.toString(f));
System.out.println("g: " + Arrays.toString(g));
System.out.println("r: " + Arrays.toString(r));
System.out.println();
System.out.println("Na a wpisuję nową tablicę");
a = new int[] {77,88,99};
System.out.println("a: " + Arrays.toString(a));
System.out.println("b: " + Arrays.toString(b));
System.out.println("r: " + Arrays.toString(r));
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment