Datentypen List.toString wirft NullPointerException

[Streijost]

Hi hier noch ein Beitrag von mir.
Ich hab gerade ein wenig mit den Erben von List und List persönlich liebkost, bin dann aber eiskalt abgeblitzt. ;(


[JAVA=42]
public class ListenKummer{

private static List arraylist = new ArrayList<String>();
private static List linkedlist = new LinkedList<String>();
private static TreeMap<String,String> treemap = new TreeMap<String,String>();
private static Random rnd = new Random();



public static void main(String[] args) {
listenfueller(arraylist);
listenfueller(linkedlist);
mapfueller(treemap);
System.out.println(arraylist.toString());
List arraylistsublist = Listtools.extractSubList(arraylist, 76,888);
List arraylistsublist2 = Listtools.extractSubList(arraylist, 0,1);
List arraylistintersection = Listtools.intersection(arraylistsublist, arraylistsublist2);
System.out.println(arraysublist);
System.out.println(arraylistsublist2);
System.out.println(arraylistintersection);
System.out.println("-------------------------------------------------------");
System.out.println(linkedlist.toString());
List linkedlistsublist = Listtools.extractSubList(linkedlist, 76,888);
List linkedlistsublist2 = Listtools.extractSubList(linkedlist, 0,1);
List linkedlistintersection = Listtools.intersection(linkedlistsublist, linkedlistsublist2);
System.out.println(linkedlistsublist);
System.out.println(linkedlistsublist2);
System.out.println(linkedlistintersection);
System.out.println("-------------------------------------------------------");
System.out.println(treemap.toString());
System.out.println("-------------------------------------------------------");
}

//befuellt Listen!
private static void listenfueller(List t){
System.out.println("Liste: "+t.getClass()+" wird befuellt!");
for(int i=0; i<30000; i++ ){
t.add(""+rnd.nextInt(54365));
}
}
//befuellt Maps!
private static void mapfueller(Map t){
System.out.println("Map: "+t.getClass()+" wird befuellt!");
for(int i=0; i<30000; i++){
t.put(rnd.nextInt(54365), null);
}
}






}

public class Listtools {

//----------------------------------------------------------------
//----------------------------------------------------------------
//----------------------------------------------------------------
//public Methoden.

/**
* Erstellt eine unterliste aus den Elementen
* der Liste li die zwischen start und end liegen.
* **/
public static List extractSubList(List li, int start, int end){
List subli = null;
System.out.println("extractSubList-li: "+li.toString());
System.out.println("extractSubList-li-Size: "+li.size());
if(!(li.size()==0)){
if(start<=0)
start=0;
if(end>=li.size())
end = li.size()-1;
int index = 0;
for(int i = start; i<=end ;i++){
subli.add(index, li.get(i));
index++;
System.out.println("extractSubList-subli: "+subli.toString());
System.out.println("extractSubList-subli-Size: "+subli.size());
}
return subli;
}else{
return new ArrayList<Object>();
}
}
/**
* Ueberfuehrt beide Listen in eine
* und gibt diese zurueck.
* **/
public static List intersection(List l1, List l2){
List combined = null;

Iterator l1Iter = l1.iterator();
while(l1Iter.hasNext()){
Object obj1 = l1Iter.next();
Iterator l2Iter = l2.iterator();
while(l2Iter.hasNext()){
Object obj2 = l2Iter.next();
if(!(obj1.equals(obj2)))
combined.add(obj1);
}
}
Iterator l2Iter = l2.iterator();
while(l2Iter.hasNext()){
Object obj2 = l2Iter.next();
combined.add(obj2);
}
return combined;
}
/**
* Fuegt c sortiert in die Liste li (vorsortiert)
* ein.
* **/
public static void addSorted(List li, Comparable c){
boolean hinzugefuegt = false;
Iterator liIter = li.iterator();
// heangt c an beliebige Stelle.
while(liIter.hasNext()){
Object any = liIter.next();
if(c.compareTo(any)>=0){
li.add(li.indexOf(any), c);
hinzugefuegt = true;
}

}
//haengt c an letzte Stelle.
if(hinzugefuegt==false){
li.add(c);
}
}

//----------------------------------------------------------------
//----------------------------------------------------------------
//----------------------------------------------------------------
}
[/code]


in der Klasse ListUtils bei

public static List extractSubList(List li, int start, int end)

wirft mir der Aufruf

 System.out.println(li.toString())

eine NullPointerException.
Ich raffe aber nicht wieso.

Danke für eure Zeit.

 

[turtle]

Die NPE wird in folgender Zeile geworfen!:noe:

subli.add(index, li.get(i));

Und das ist ja auch nicht verwunderlich, wenn man 8 Zeilen früher sich anschaut

List subli = null;

 

[Streijost]

Die NPE wird in folgender Zeile geworfen!:noe:

subli.add(index, li.get(i));

Und das ist ja auch nicht verwunderlich, wenn man 8 Zeilen früher sich anschaut

List subli = null;

Oh mann wie konnte ich das bloß übersehen :rtfm: dank dir.
Das war mal ein sehr schludriger Beitrag von mir.

Obwohl ich jetzt das problem habe, wie ändere ich die Zeile

List subli = null;

So dass, ich keine Instanz einer spezifischen Liste erzeuge, ich möchte nämlich ein Objekt vom typ Listzurueckgeben.
Wenn ich die Zeile

subli.add(index, li.get(i));

zu

subli.add(li.get(i));

bekomme ich ja wieder eine NPE also muss ich

List subli = null;

Instanzieren mit new.

Hast du ne Idee wie ich das am komfortabelsten lösen kann so dass, List li in die Methode extractSubList geht und eine List x zurueckgegeben wird?

 

[Streijost]

Ok hab die Lösung für mein Problem und werde sie mal mit euch teilen.


[Java]
List sublist = new ArrayList<Object>();
...
...
return (List) sublist;
[/Java]

ist das getan funktioniert der Rest der extraktSublist und Intersection Methode.:applaus:

 

[turtle]

List sublist = new ArrayList<Object>();

Das ist übrigens der "normale" und richtige Programmierstil.:toll:

Es wird das Interface angegeben und mit einer realen Klasse instanziert. Also hier List, kann irgendeine List sein und du nimmst eine ArrayList als Implementierung. Solltest übrigens List<Object> schreiben

Dieses bedeutet, das du in Methoden immer auch List als Parameter angibst und nicht ArrayList!

 

[Streijost]

Gut merk ich mir.
Habt ihr hier im Forum eine Anleitung zu den Generics in Java unter den FAQs habe ich das nicht gefunden.