ArrayListe in Arraylist Problem

[b1zarRe]

Hi,

ich habe die Aufgabe mithilfe von PCAP einen Wireshark Datenmittschitt einzulesen und zu verarbeiten.

Nun habe ich folgendes Problem:
Ich hatte überlegt bei jedem Durchlauf eine neue Arraylist zu erstellen, welche im Index 0-7 jeweils:
Header, Ethernetprotokoll, IP-Protokoll, .... speichert. Diese Arrayliste möchte ich nun einer "zusammenfassenden" Liste übergeben, welche alle Pakete aufsammelt.

Oder anders ausgedrückt anhang eines Beispiels:
Ich möchte von dem Mitschnitt 10 Pakete einlesen. Also erzeuge ich eine 'paketbereich' Arraylist welche beim ersten durchlauf jeweils Header,Ethernet,Ip,etc.-Protkoll einsammelt und übergebe diese liste dann der Arraylist 'eingelesenePakete' an Index 0. Beim nächsten Durchlauf erzeuge ich eine neue Arraylist 'paketbereich', sammle die Daten und übergebe diese (an Index 1) der 'eingelesenenPakete' Arraylist.

Schön und gut... dies hatte bis dato auch geklappt(aber auch nur, ohne jedes mal hinzuschreiben

paketbereich = new ArrayList<String>();

):
Ich habe mir alle Pakete sowie Daten ausgeben lassen und es klappt.

JEDOCH: Habe ich nun die Aufgabe mir zb. das 10 Paket und deren Inhalt anzuzeigen...
Also gehe ich einfach die die eingelesenenPakete Liste und hole mir mithilfe von get den Index 9,
speicher den Inhalt ebenfalls als Arrayliste 'a' und gebe 'a' mit einem Iterator oder Forschleife aus.

Nun habe ich das Problem das dieses Vorhaben NUR dann klappt, wenn ich bei jedem mal wirklich hinschreibe:

paketbereich = new ArrayList<String>();

Wenn ich das aber stehen lasse, und mir ALLE Pakete ausgeben lasse, dann gibt er mir zwar die gewünschte Anzahl Pakete zurück, aber es ist immer das gleiche Paket?!?! Ich finde den Fehler einfach nicht...


Schon einmal danke fürs lesen... und hier der relevante Teilcode:

 public void testeVerarbeiter() {
        
        /* Handler Instanz mit Generics vom Typ String wird erzeugt. */
        PcapPacketHandler<String> jpacketHandler = new PcapPacketHandler<String>() {
            
            /**
             * Diese Methode dient dazu, dass naechste Paket ausgeben
             * zu lassen.
             */
            public void nextPacket(PcapPacket packet, String user) {
                
                /* Gibt alles aus; Darf nicht benutzt werden; NUR VERGLEICH!!! */
                //System.out.println(packet); 
                
                /* Daten pro Paket */
                String data = "";
                String data2 = "";

/* Mit dieser Zeile klappt eine einzelne Ausgabe... aber wenn man alle ausgeben lassen will, kommt x-mal die gleiche Ausgabe... ohne diese Zeile klappt es mit der mehrfachen Ausgabe, aber nichtmehr mit der einzelnen */
                paketbereich = new ArrayList<String>(); 

                
                /*
                **********************
                *** CAPTURE HEADER ***
                **********************
                */
                /*
                * Mithilfe von Soutf und einer Date Instanz lassen sich
                * die Pakete aufzeichnen die zu einer (bestimmten) Zeit
                * enthalten sind. Ebenso enthaelt dieses Soutf
                * die Laenge von den gecaptureten Paketen sowie deren
                * Originallaenge.
                */
                data2 = "Capture-Header: " + "\n" + "%n%nPacket-Nr: " + paketnummer++ + 
                        ", aufgezeichnet am " 
                        + new Date(packet.getCaptureHeader().timestampInMillis())
                        + "caplen=" + packet.getCaptureHeader().caplen()
                        +  "len=" + packet.getCaptureHeader().wirelen()
                        + user; 

                data = data + data2;
                paketbereich.add(data);
                data = "";
//                    System.out.print("Capture-Header: ");
//                    System.out.printf("%n%nPacket-Nr: "
//                            + "aufgezeichnet am %s caplen=%-4d len=%-4d %s\n",
//                            new Date(packet.getCaptureHeader().timestampInMillis()), // Zeitpunkt
//                            packet.getCaptureHeader().caplen(), // Laenge Captured
//                            packet.getCaptureHeader().wirelen(), // Laenge Original
//                            user // User
//                    );

                    /*
                    ***********************
                    *** ETHERNET HEADER ***
                    ***********************
                    */
                    final Ethernet eth = new Ethernet();
                    if (packet.hasHeader(eth)) {
                        data = "\n" + eth.toString();
                        paketbereich.add(data);
                        data = "";
                    } else {
                        paketbereich.add("");
                        data = "";
                    }

                    /*
                    ********************
                    *** IP HEADER ******
                    ********************
                    */
                    final Ip4 ip = new Ip4();
                    if (packet.hasHeader(ip)) {
                        data = data + "\n" + ip.toString();
                        paketbereich.add(data);
                        data = "";
                    } else {
                        paketbereich.add("");
                        data = "";
                    }

                    /*
                    ********************
                    *** UDP HEADER  ****
                    ********************
                    */
                    final Udp udp = new Udp();
                    if (packet.hasHeader(udp)) {
                        data = data + "\n" + udp.toString();
                        paketbereich.add(data);
                        data = "";
                    } else {
                        paketbereich.add("");
                        data = "";
                    }

                    /*
                    ********************
                    *** TCP HEADER *****
                    ********************
                    */
                    final Tcp tcp = new Tcp();
                    if (packet.hasHeader(tcp)) {
                          data = data + "\n" + tcp.toString();
                          paketbereich.add(data);
                          data = "";
                    } else {
                        paketbereich.add("");
                        data = "";
                    }

                    /*
                    ********************
                    *** ICMP HEADER ****
                    ********************
                    */
                    final Icmp icmp = new Icmp();
                    if (packet.hasHeader(icmp)) {
                          data = data + "\n" + icmp.toString();
                          paketbereich.add(data);
                          data = "";
                    } else {
                          paketbereich.add("");
                          data = "";
                    }

                    /*
                    ********************
                    *** DATENTEIL ******
                    ********************
                    */
                    final Payload dataPayload = new Payload();
                    JBuffer buffer = packet.getHeader(dataPayload);
                    
                    if(buffer != null) {
                        data = buffer.toHexdump();
                        paketbereich.add(data);
                    } else {
                        paketbereich.add("");
                    }
                    data = "";

                    // Daten der Liste hinzufuegen
                    eingelesenePakete.add(paketbereich);
           }
        };

        /*
         * Abschliessend kann die Laenge eingetellt werden sowie
         * eine Output-Message und pcap wird geschlossen.
         */
        try {
           pcap.loop(einzulesendePakete, jpacketHandler, ""
                   + " * Received: ein libpcap Paket!"); // Anzahl Packages,instanz,sout
        } finally {
            pcap.close(); // pcap Instanz wird am Ende geschlossen
        }
    }
    
    /**
     * Main-Methide zum Testen
     * @param args  wird nicht verwendet.
     */
    public static void main(String[] args) {
        
        /* Deklaration einer Instanz */
        int einzulesendePakete = 11;
        DatenmitschnittVerarbeiter instanz01 = 
        new DatenmitschnittVerarbeiter("test.pcap", einzulesendePakete);
        instanz01.testeVerarbeiter();
        
        /* ALLE PAKETE DURCHLAUFEN */
        System.out.println("***** ALLE PAKETE ****");

        Iterator it1 = instanz01.eingelesenePakete.iterator();
        Iterator it2 = instanz01.paketbereich.iterator();

        int paketbereichLaenge = instanz01.paketbereich.size();
        for(int i=0; i < einzulesendePakete; i++) {
            for(int j=0; j < paketbereichLaenge; j++) {
                System.out.println(instanz01.paketbereich.get(j));
            }
        }
        
        // Aufgabe 01: Datenpaket Nummer 10 des Mittschnitts
//        System.out.println("*** A1: Paket Nummer 10 ");
//        ArrayList packet10 = (ArrayList)instanz01.eingelesenePakete.get(10);
//        for(int x=0; x < 7;x++) {
//            System.out.println(packet10.get(x));
//        }

 

[nillehammer]

Ich hatte überlegt bei jedem Durchlauf eine neue Arraylist zu erstellen, welche im Index 0-7 jeweils:
Header, Ethernetprotokoll, IP-Protokoll, .... speichert. Diese Arrayliste möchte ich nun einer "zusammenfassenden" Liste übergeben, welche alle Pakete aufsammelt.

Kann man machen. Da es eine feste Anzahl Elemente ist, ist vielleicht ein String-Array besser. Am besten finde ich aber eine Klasse

Paket

mit entsprechenden Instanzvariablen und Gettern (evtl. auch Setter). Du brauchst dann nur noch eine

List<Paket>

. Ist auf jeden Fall übersichtlicher als verschachtelte Listen.

P.S. und noch ein Hinweis zu for-Schleifen: Wenn du innerhalb der Schleife den index nicht brauchst, verwende lieber die foreach-Syntax, ungefähr so:

// allePaketInfos ist Deine Liste, die Listen mit Strings enthält
for (List<String> paketInfo : allePaketInfos) {
  for (String paketAttribut : paketInfo) {
    //tuwas mit dem einzelen String
  }
}

 

[b1zarRe]

Nun... immer wenn man Probleme detailliert beschreibt... findet man doch den Fehler...
THEMA erledigt.

Für alle die es wissen wollen:
Ich habe die obere

paketbereich = new ArrayList<String>();

dringelassen und einen Fehler in der Main gefunden bzw. einfach nochmal die Ausgabe neu aufgeschrieben und es kam
raus:

  public static void main(String[] args) {
        
        /* Deklaration einer Instanz */
        int einzulesendePakete = 11;
        DatenmitschnittVerarbeiter instanz01 = 
        new DatenmitschnittVerarbeiter("test.pcap", einzulesendePakete);
        instanz01.testeVerarbeiter();
        
        /* ALLE PAKETE DURCHLAUFEN */
        System.out.println("****************** ALLE PAKETE *****************");

        Iterator it1 = instanz01.eingelesenePakete.iterator();
        Iterator it2 = instanz01.paketbereich.iterator();
        int paketbereichLaenge = instanz01.paketbereich.size();
        
        for(int i=0; i < einzulesendePakete; i++) {
            for(int j=0; j < 7; j++) {
                System.out.println(instanz01.eingelesenePakete.get(i).get(j));
            }
        }
        
        // Aufgabe 01: Datenpaket Nummer 10 des Mittschnitts
        System.out.println("**************** A1: Paket Nummer 10 ******");
        ArrayList packet10 = (ArrayList)instanz01.eingelesenePakete.get(8);
        for(int x=0; x < 7;x++) {
            System.out.println(packet10.get(x));
        }

Nun klappt alles wie gewünscht

 

[Volvagia]

Wenn jedes (oder zumindest die meisten, kenn mich da nicht soooo gut aus) Pakete einen Header und das ganze Zeug haben, wäre da eine eigene Klasse um Header und Daten getrennt zu speichern nicht sinnvoller? Ebenso dass Übertragungsdaten als byte-Array/Buffer/ByteArrayStream gespeichert werden und nicht als String? Strings können durch ihre Codierung ja byte-Folgen zerstören.

So wie ich das sehe ist testeVerarbeiter DatenmitschnittVerarbeiter? In der Methode erzeugst du jedes mal eine neue Liste (paketbereich) die du in die Instanzvariable schreibst. Am Ende fügst du sie eingelesenePakete hinzu. In der Ausgabe greifst du aber ausschließlich auf paketbereich zu. Und diese enthält nur die letzte ArrayList die wärend der Methodenabarbeitung erzeugt wurde. Also bekommst du nur das der letzten angelegten raus. Mit der äußeren for wiederholst du diesen Vorgang 11 mal, gibst also 11 mal den Inhalt der beim letzten Methodendurchlauf in die Liste geschrieben hast aus.

Keine Ahnung wofür du die Iteratoren ('s?) brauchst.

[EDIT]Werdet doch endlich langsamer. ;([/EDIT]