Tasks studies - laboratory
Tablice to ciągi obiektów tego samego typu. Tablice mają określony podczas ich tworzenia rozmiar, który nie może ulec zmianie. Tablice to pierwszy rodzaj kolekcji. Kolekcje to zbiór powiązanych ze sobą elementów. Kolekcje są bardzo często wykorzystywane w programowaniu, ponieważ często mamy potrzebę przechowywać w programach tablice (bądź listy, zbiory itp.) wielu elementów, a nie pojedyncze wartości.
Wybrane metody używane w tablicach
length – rozmiar tablicy
charAt – pobranie znaku w tablicy
public class Main {
public static void main(String[] args) {
/*definicja tablicy
deklaracja tablicy dataType[] arrayName;
dataType - int, char, double, byte, etc. or Java objects
arrayName - nazwa tablicy*/
// I sposob
double[] data;
//alokacja pamieci
data = new double[10];
// II sposob
double[] data1 = new double[10];
//III sposób
String[] slowa;
slowa = new String[] {"Ala","ma","kota"};
//inicjalizacja tablicy
int[] LiczbyCalkowite = {12,4,45,32,24};
int[] Liczby = new int[5];
Liczby[0]=12;
Liczby[1]=21;
Liczby[2]=5;
Liczby[3]=6;
Liczby[4]=46;
}
}
public static void Dostep(){
//dostęp do elementow tablicy
int[] Liczby = {12,4,45,32,24};
// access each array elements
System.out.println("Accessing Elements of Array:");
System.out.println("First Element: " + Liczby[0]);
System.out.println("Second Element: " + Liczby[1]);
System.out.println("Third Element: " + Liczby[2]);
System.out.println("Fourth Element: " + Liczby[3]);
System.out.println("Fifth Element: " + Liczby[4]);
String[] slowa;
slowa = new String[] {"Ala","ma","kota"};
System.out.println(slowa[0]+ " "+slowa[1]+" "+slowa[2]);
}
public static void Dlugosc(){
int[] calkowite = new int[5];
double[] rzeczywiste = { 3.14, 5, -20.5 };
System.out.println(
"Liczba elementow w tablicy calkowite: " +
calkowite.length);
System.out.println(
"Liczba elementow w tablicy rzeczywiste: " +
rzeczywiste.length);
}
public static void RozmiarArrayString(){
String tekst = "Witajcie!";
String[] slowa = { "Ania", "ma", "kota" };
System.out.println("Liczba slow w zmiennej tekst: " + tekst.length());
System.out.println("Liczba elementow w tablicy: " + slowa.length);
System.out.println("Liczba znakow w pierwszym slowie z tablicy: " +
slowa[0].length());
}
public static void PetlaFor(){
int[] Liczby = {12, 4, 5};
System.out.println("Using for Loop:");
for(int i = 0; i < Liczby.length; i++) {
System.out.println(Liczby[i]);
}
}
//wypisywanie elemetów tablicy od ostatniego indeksu
public static void PetlaFor1(){
int[] Liczby = {12, 4, 5};
for (int i = Liczby.length - 1; i >= 0 ; i--) {
System.out.print(Liczby[i] + " ");
}
}
public static void PetlaForEach(){
int[] Liczby = {12, 4, 5};
System.out.println("Using for Loop:");
for(int i : Liczby) {
System.out.println(i);
}
}
public class ArrayExample {
public static void main(String[] args) {
3
//deklaracja
int[][] matrixA = new int[3][4];
String[][][] data = new String[3][4][2];
//inicjalizacja tablicy wielowymiarowej
int[][] a = {
{1, 2, 3},
{4, 5, 6, 9},
{7},
};
double[][] matrix = {
{1.2, 4.3, 4.0},
{4.1, -1.1}
};
//wyświetlenie elementow tablicy
System.out.println("Elementy tablicy:");
for (int i = 0; i < a.length; ++i) {
for(int j = 0; j < a[i].length; ++j) {
System.out.print(a[i][j] + "\t");
}
System.out.println();
}
}
}
Jak widać, każdy element tablicy wielowymiarowej sam w sobie jest tablicą. Ponadto, w przeciwieństwie do C/C++, każdy wiersz tablicy wielowymiarowej w Javie może mieć różną długość.
public class ArrayExample {
public static void main(String[] args) {
// create a 2d array
int[][] a = {
{1, -2, 3},
{-4, -5, 6, 9},
{7},
};
// first for...each loop access the individual array
// inside the 2d array
for (int[] innerArray: a) {
// second for...each loop access each element inside the row
for (int data : innerArray) {
System.out.print(data + "\t");
}
System.out.println();
}
}
}
public class ArrayExample {
public static void main(String[] args) {
// test is a 3d array
int[][][] test = {
{
4
{1, -2, 3},
{2, 3, 4}
},
{
{-4, -5, 6, 9},
{1},
{2, 3}
}
};
// for..each loop to iterate through elements of 3d array
for (int[][] array2D: test) {
for (int[] array1D: array2D) {
for(int item: array1D) {
System.out.print(item +"\t");
}
System.out.println();
}
}
}
}
public class ArrayExample {
public static void main(String[] args) {
int [] numbers = {1, 2, 3, 4, 5, 6};
int [] positiveNumbers = numbers; // copying arrays
System.out.println("Tablica: ");
for (int number: positiveNumbers) {
System.out.print(number + ", ");
}
System.out.println("\nKopia tablicy: ");
for (int number: positiveNumbers) {
System.out.print(number + ", ");
}
}
}
public class ArrayExample {
public static void main(String[] args) {
int [] source = {1, 2, 3, 4, 5, 6};
int [] destination = new int[6];
// iterate and copy elements from source to destination
for (int i = 0; i < source.length; ++i) {
destination[i] = source[i];
}
// converting array to string
System.out.println(Arrays.toString(destination));
}
}
W powyższym przykładzie użyliśmy pętli for do iteracji przez każdy element tablicy źródłowej. W
każdej iteracji kopiujemy elementy z tablicy źródłowej do tablicy docelowej. W tym przypadku tablica
źródłowa i docelowa odnoszą się do różnych obiektów (głęboka kopia). W związku z tym, jeśli elementy
jednej tablicy zostaną zmienione, odpowiednie elementy innej tablicy pozostaną niezmienione. Metoda
toString() służy do konwersji tablicy na ciąg.
arraycopy(Object src, int srcPos,Object dest, int destPos, int length)
//src – tablica źródłowa, którą chcemy skopiować
//scrPoc – pozycja początkowa (indeks) w tablicy źródłowej
//dest – tablica docelowa, do której elementy zostaną skopiowane ze źródła
//destPOs – pozycja początkowa (indeks) w tablicy docelowaej
//length – liczba elementow do skopiowanie
public class ArrayExample {
public static void main(String[] args) {
int[] tab1 = {2, 3, 12, 4, 12, -2};
int[] tab3 = new int[5];
// tworzenie tablicy tab2 o długości tab1
int[] tab2 = new int[tab1.length];
// kopiowanie tablic1 do tab2
System.arraycopy(tab1, 0, tab2, 0, tab1.length);
System.out.println("tab2 = " + Arrays.toString(tab2));
// kopiowanie lementow indeksu 2 do tab1
// kopiowanie elementow indeksu 1 do tab3
// 2 elementy zostaną skopiowane
System.arraycopy(tab1, 2, tab3, 1, 2);
System.out.println("tab3 = " + Arrays.toString(tab3));
}
}
public class ArrayExample {
public static void main(String[] args) {
int[] source = {2, 3, 12, 4, 12, -2};
// copying entire source array to destination
int[] destination1 = Arrays.copyOfRange(source, 0, source.length);
System.out.println("destination1 = " +
Arrays.toString(destination1));
// copying from index 2 to 5 (5 is not included)
int[] destination2 = Arrays.copyOfRange(source, 2, 5);
System.out.println("destination2 = " +
Arrays.toString(destination2));
}
}
//metoda do zmiany rozmiaru tablicy
public static void ChangeLength() {
int[] liczby = {10, 100, -5};
System.out.println("Elementy tablicy liczby:");
for (int x : liczby) {
System.out.print(x + ", ");
}
System.out.println();
// tworzymy druga tablice o wiekszym rozmiarze
int[] tymczasowaTabela = new int[5];
// przepisujemy elementy z pierwszej tablicy
for (int i = 0; i < liczby.length; i++) {
tymczasowaTabela[i] = liczby[i];
}
// ustawiamy dodatkowe elementy
tymczasowaTabela[3] = 20;
tymczasowaTabela[4] = 1;
// przypisujemy druga tablice do pierwszej
liczby = tymczasowaTabela;
System.out.println("Elementy tablicy liczby:");
for (int x : liczby) {
System.out.print(x + ", ");
}
}
int[] tablica = { 1, 2, 3 };
System.out.println(tablica[3]);
public static void main(String[] args) {
boolean znaleziona = false;
int[] tablica = { -20, 105, 0, 26, -99, 7, 1026 };
int szukanaLiczba = ?; // pewna wartosc
for (int i = 0; i <= tablica.length; i++) {
if (tablica[i] == szukanaLiczba) {
znaleziona = true;
break; // znalezlismy liczbe - mozemy wiec przerwac petle
}
}
if (znaleziona) {
System.out.println("Liczba " + szukanaLiczba + " zostala
znaleziona!");
} else {
System.out.println("Liczba " + szukanaLiczba + " nie zostala
znaleziona.");
}
}
public static void main(String[] args) {
int liczby = { 1, 2, 3 };
String[] litery = { 'a', 'b', 'c' };
String[] slowa = new String[];
slowa = { "Ala", "ma", "kota" };
double[] rzeczywiste = new double[] { 3.14, 2.44, 20 };
double[] innaTablica = new int[3];
int[] tablica = new int[5] { 1, 10, 100 };
double[] kolejnaTablica = new double[3];
kolejnaTablica = { 5, 10, 15 };
String[] tab = { "Ala ma kota" };
}
Write a program that calculates the sum and average of array elements using the for and for each loops.
The elements for the array are to be drawn from any range. A separate method for drawing numbers should be proposed.
Write a program that prints every second element of the arrays you define. The first array should have an even number of elements, and the second an odd number.
Write a program in which you define an array of String values and initialize it
with sample values. Use the for-each loop to print all values
of the array with all letters converted to uppercase. Use the toUpperCase functionality
of the String value.
Write a program that takes five words from the user and stores them in an array. Then,
the program should print all the words, from last to first, with the letters
written from the end to the beginning. For example, for the words "Ala", "ma", "kota", "i",
"psa" the program should print: "asp", "i", "atok", "am", "alA".
Write a program that takes eight numbers from the user, stores them in an array, and then
sorts the array in ascending order and prints the result to the screen. For example, for the numbers 10,
-2, 1, 100, 20, -15, 0, 10, the program will print -15, -2, 0, 1, 10, 10, 20, 100. Think about how you can
sort a sequence of numbers and try to implement your solution. Test it on different
data sets. You can also use one of the popular sorting algorithms, e.g.
insertion sort. The operation of the algorithm was discussed in detail in the
algorithms and data structures classes.
Write a program that will get five numbers from the user, store them in an array, and then count and print the factorial of each of the numbers.
Write a program in which you define two arrays storing values of type String.
Initialize both arrays with the same values, in the same order. Write code that will compare both arrays and answer the question whether they are the same.