Struktury wielowymiarowe

0

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.

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

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0