Cześć.
Czy w javie są jakieś struktury wielowymiarowe, dla niewiadomej ilości danych? Dajmy na to - pierwszy wiersz n liczb, drugi k liczb, a trzeci m liczb. Najodpowiedniejsze byłoby coś w rodzaju dwuwymiarowego ArrayList.
0
1
Lista list list list list ..... list? List<List<List<Integer>>> listaListList = new ArrayList<List<List<Integer>>>(); Potem oczywiście wypełnianie kolejnych poziomów zagnieżdżeń.
Nota bene: Java udostępnia wielowymiarowe tablice i mogą one być "poszarpane" tzn wiersze mogą mieć różne długości. Tak więc do wyboru, do koloru.
0
Mógłbyś zademonstrować w jaki sposób umieszczać elementy oraz odczytywać dane z takiej Listy?
Już sobie poradziłem:
import java.util.ArrayList;
public class md{
public static void main(String args[]){
ArrayList matrix = new ArrayList();
matrix.add(new ArrayList());
((ArrayList)matrix.get(0)).add("row 0 col 0");
((ArrayList)matrix.get(0)).add("row 0 col 1");
matrix.add(new ArrayList());
((ArrayList)matrix.get(1)).add("row 1 col 0");
((ArrayList)matrix.get(1)).add("row 1 col 1");
int i = 0;
int j = 0;
// display contents of matrix
for(i = 0; i < matrix.size();i++){
for(j = 0; j < ((ArrayList)matrix.get(i)).size(); j++){
System.out.print( (String)((ArrayList)matrix.get(i)).get(j) +" ");
}
System.out.println();
}
}
}
1
Normalnie powinienem skasować się cię (puff) na kasę, no ale cóż. Masz gotowca w trzech rodzajach:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
new Main().run();
}
void run() {
int[][][] tablica = {{{1}, {2}, {3}}, {{1, 2}, {2, 3}}, {{1, 2, 3}}};
System.out.println("Wersja for-each:");
System.out.print("[");
for (int[][] t2 : tablica) {
System.out.print("[");
for (int[] t1 : t2) {
System.out.print(Arrays.toString(t1) + ", ");
}
System.out.print("], ");
}
System.out.println("]");
System.out.println("Wersja standard:");
System.out.print("[");
for (int i = 0; i < tablica.length; i++) {
System.out.print("[");
for (int j = 0; j < tablica[i].length; j++) {
System.out.print(Arrays.toString(tablica[i][j]));
System.out.print(j + 1 == tablica[i].length ? "" : ", ");
}
System.out.print(i + 1 == tablica.length ? "]" : "], ");
}
System.out.println("]");
System.out.println("Wersja na kolekcjach:");
List<List<List<Integer>>> lista = new ArrayList<List<List<Integer>>>();
lista.add(new ArrayList<List<Integer>>());
lista.get(0).add(Arrays.asList(1));
lista.get(0).add(Arrays.asList(2));
lista.get(0).add(Arrays.asList(3));
lista.add(new ArrayList<List<Integer>>());
lista.get(1).add(Arrays.asList(1, 2));
lista.get(1).add(Arrays.asList(2, 3));
lista.add(new ArrayList<List<Integer>>());
lista.get(2).add(Arrays.asList(1, 2, 3));
System.out.println(lista);
}
}
0
Dziękuję. Bardzo mi pomogłeś Wibowit. Pozdrawiam.
0
Tak ładniej w foreach:
System.out.print(Arrays.toString(t1));
System.out.print(t1[0] == t2.length? "" : ", ");
... i szczerze mówiąc nie wiem czego to działa :]
0
Posiadam taką strukturę:
List<List<Integer>> lista = new ArrayList<List<Integer>>();
lista.add(Arrays.asList(1,2,3,4,5));
w jaki sposób do istniejącej listy (1,2,3,4,5) dodać szósty element? Logicznym byłoby:
lista.get(0).add(6);
niestety, pojawia się wyjątek.
1
Implementacja List zwracana przez Arrays.asList ma sztywny rozmiar (tak jest opisane w javadoc, owa kolekcja to tylko nakładka na zwykłą tablicę, zmiany w tablicy są widoczne w liście i vice versa). Istnieje konstruktor dla ArrayList (i chyba wszystkich innych kolekcji standardowych), który przyjmuje kolekcję i kopiuje do siebie jej elementy (ale płytko, tzn nie robi kopii elementów, tylko kopiuje referencje). Pełny kod obrazujący zagadnienie:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
new Main().run();
}
void run() {
List<Integer> listaNierozszerzalna = Arrays.asList(1, 2, 3);
try {
listaNierozszerzalna.add(4);
} catch (UnsupportedOperationException ex) {
System.out.println("Nieprawidłowa operacja.");
}
System.out.println(listaNierozszerzalna);
List<Integer> listaRozszerzalna =
new ArrayList<Integer>(listaNierozszerzalna);
listaRozszerzalna.add(4);
System.out.println(listaRozszerzalna);
}
}
import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
new Main().run();
}
void run() {
Integer[] tablica = {1, 2, 3};
List<Integer> lista = Arrays.asList(tablica);
System.out.println(Arrays.toString(tablica));
System.out.println(lista);
tablica[0] = 4;
System.out.println(Arrays.toString(tablica));
System.out.println(lista);
lista.set(0, 5);
System.out.println(Arrays.toString(tablica));
System.out.println(lista);
}
}
0
Dzięki za odpowiedzi Wibowit, sporo z nich wyniosłem.
Po przemyśleniu zagadnienia i przeanalizowaniu potrzeb otrzymałem satysfakcjonującą mnie strukturę. Pozdrawiam.
// Wielowymiarowa Lista
import java.util.ArrayList;
import java.util.List;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
new Main().run();
}
void run()
{
List<List<Integer>> lista = new ArrayList<List<Integer>>();
List<Integer> listaRozszerzalna = new ArrayList<Integer>();
List<Integer> listaRozszerzalna2 = new ArrayList<Integer>();
List<Integer> listaRozszerzalna3 = new ArrayList<Integer>();
lista.add(listaRozszerzalna);
lista.add(listaRozszerzalna2);
lista.add(listaRozszerzalna3);
System.out.println("Dodawanie do zagniezdzonych list przy uzyciu odwolania bezposrednio do nich");
listaRozszerzalna.add(1);
listaRozszerzalna.add(2);
listaRozszerzalna3.add(3);
System.out.println(lista);
System.out.println(listaRozszerzalna);
System.out.println(listaRozszerzalna.get(0));
System.out.println("rozmiar listy pierwszej: " + listaRozszerzalna.size());
System.out.println("Dodawanie do zagniezdzonych list przy uzyciu listy nadrzednej");
lista.get(1).add(4);
lista.get(0).add(5);
System.out.println(lista);
System.out.println(lista.get(0));
System.out.println(lista.get(0).get(0));
System.out.println("rozmiar calej listy: " + lista.size());
}
}