frage zu generics wie List<?>.

[dermoritz]

es geht im allgemeinen darum wie ich eine funktion für list<object> definieren kann und diese dann mit list<string> aufrufen kann. geht das überhaupt. meine anfängervorstellung ist irgendwie, dass ja jeder string ein objekt ist und somit alles was ich mit objekten machen kann auch mit strings machen kann.

mein konkretes problem bezieht sich auf die funktion: http://www.java-forum.org/de/viewtopic.php?p=421040#421040

wenn ich versuche cartProduct(inputs) wobei inputs vom typ list<list<string>> aufzurufen kommt die fehlermeldung, dass cartProduct(list<list<object>>) nicht anwendbar ist für list<list<string>>.

die stringlisten defininer ich:

          List<String> set1 = new ArrayList<String>();
	  List<String> set2 = new ArrayList<String>();
          set1=Arrays.asList("1","2","3");
	  set2.add("a");
	  set2.add("b");
	  set2.add("c");
	  List<List<String>> inputs=new ArrayList<List<String>>();
	  inputs.add(set1);
	  inputs.add(set2);

aufruf:

System.out.println(cartProduct(inputs));

vielen dank im voraus

 

[Illuvatar]

Ich vermute du meinst sowas:

  public static <T extends Object> List<List<T>> cartProduct(List<List<T>> sets) {
      List<List<T>> cartesian_product=new ArrayList<List<T>>();
      List<T> cartesian_product_element;
      int n=1;
      Iterator<List<T>> sets_it=sets.iterator();
       //loop to get cardinality of Cartesian product
      while (sets_it.hasNext()) {
         List<T> set = sets_it.next();
         n*=set.size();
      }
      //loop to create all elements of Cartesian product
       for (int i=0;i<n;i++){
          int j=1;
          cartesian_product_element=new ArrayList<T>();
          sets_it=sets.iterator();
          //loop that collects one element of each class
          while (sets_it.hasNext()) {
            List<T> set = sets_it.next();
            cartesian_product_element.add(set.get((i/j)%set.size()));
            j*=set.size();
         }
          cartesian_product.add(cartesian_product_element);
       }
      return cartesian_product;
  }

 

[dermoritz]

erstmal danke, da ich einjava anfänger bin weiß ich nicht genau ob ich das meine .
aber auf den ersten blick würde ich mich frage warum ich die eigenschaften von objekt erstmal auf t vererben soll (das macht doch dieses "t extends object"?).

ich hab deine lösung nicht ausprobiert aber ich geh davon aus das dann der aufruf mit jeder liste funtkioniert die "objekte" enthält. insbesondere mit list<list<string>>. aber wie gesagt ich würde gerne verstehen wieso ich typ t einführen muss.

 

[Illuvatar]

T ist nur eine Art "Platzhalter". Am Anfang gebe ich an, dass die Klasse von T eine beliebige Unterklasse von Object sein darf.

Auch möglich wäre etwas wie

public static List<List<? extends Object>> cartProduct(List<List<? extends Object>> sets)

aber da muss das Eingangs-Fragezeichen dann nicht das gleiche wie das Ausgangs-Fragezeichne sein, das führt dann auch zu unnötigem Casten, das man ja durch Generics vermeiden will

 

[Guest]

dank, aber ich verstehs immer noch nich richtig. "object" ist mir ja generisch genug und jeder string ist doch automatisch ein object, oder?
deswegen versteh ich nicht wieso ich entweder bei deklaration mit list<object> die listen elemente als string casten muss damit die liste dann eine liste von objekten ist (eine liste von strings ist doch eine liste von objecten?!), oder eben dein vorschlag in dem ich mir einen typ t definiere der aber eigentlich auch nur ein objct ist.

 

[dermoritz]

danke, ich habs mal probiert und es funktioniert so . Leider hab ich das wie erwähnt (^^der gast war ich ) alles noch nicht volständig begriffen. ich hab z.b. mal "extends object" weggelassen - das funktioniert auch - macht das irgendeinen unterschied? <T> sollte doch automatisch "mindestens" ein object sein?!

 

[dermoritz]

hmmh irgendwie funktioniert die funktion nun nicht wenn man sie mit arraylist<arraylist<double >> aufruft "not applicable".

meinziel ist es ja nach wie vor, das die funktion alle 2 dimensionalen listen frisst. wie definiert man sowas?

 

[SlaterB]

normalerweise verwendet man ja auch keine
Arraylist<Arraylist<Double>>

was bringt es dir, wenn du die innere List genauer spezifierst?
allgemeiner ist eine
Arraylist<List<Double>>

bzw. gar vom Typ her
List<List<Double>>

falls es daran nicht liegt bitte kurzes komplettes Code-Beispiel,
die fragliche Operation kann ja leer sein, es geht nur um die ÜBergabe

 

[dermoritz]

schau mal nach oben spezifiziert ist die funktion mit list<list<object>> bzw 'T' - so geht ja der thread los. also die funktion soll so allgemein gehalten werden damit ich sie eben mit allen möglichen list<list<object>> aufrufen kann.

die frage ist ob die funktion so richtig deklariert ist?! bzw wie ruft man sie dann mit arraylist<arraylist<double>> auf?

 

[SlaterB]

gar nicht, sondern sie ist dafür ausgelegt, mit List<List<Double>> aufgerufen zu werden,
wie gesagt

edit:
so, der Fragesteller möchte sich mal wieder die Arbeit sparen, also selber das Beispiel programmieren:

public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        ArrayList<ArrayList<String>> list = new ArrayList<ArrayList<String>>();
        cartProduct(list); // geht nicht
        List<List<String>> list2 = new ArrayList<List<String>>();
        cartProduct(list2); // geht
    }

    public static <T extends Object>List<List<T>> cartProduct(List<List<T>> sets)
    {
        return null;
    }
}

 

[dermoritz]

das hat tatsächlich mal nix mit faulheit zu tun, sondern ich blicks einfach nicht.

1. wieso muss man 'T' benutzen und gibt nicht einfach list<list<object>> an. denn "T extends Object" Object macht doch nix anderes?

2. bei der deklaration von (2d) listen blick ich nicht durch:

public List<List<Double>> liste=new ArrayList<List<Double>>();

funktioniert aber,

public List<List<Double>> valid_signal_values=new ArrayList<ArrayList<Double>>();

funktioniert nicht.

und

public ArrayList<ArrayList<Double>> valid_signal_values=new ArrayList<ArrayList<Double>>();

funktioniert wieder.

(ich mach da immer ein fleißiges try and error in eclipse :-|)

in diesem fall würde ich gerne eine list<list<type>> mit arraylist<arraylist<typ>> deklarieren. also beide listen als arraylist. aber das geht ja so nicht?!

3. zu meiner frage zu dem aufruf der funktion: ich versteh eben nicht wieso deine zeile 8,9 nicht geht. jede arraylist ist doch auch eine liste wieso kann ich nicht einfach eine arrayliste anlegen und sie in eine liste funktion stecken.

bzw. kann man eine funktion so deklarieren das sie alle sorten frisst und es eben egal ist ob man sowas

ArrayList<ArrayList<String>> list = new ArrayList<ArrayList<String>>();

oder sowas

List<List<String>> list2 = new ArrayList<List<String>>();

übrergibt.

 

[SlaterB]

> das hat tatsächlich mal nix mit faulheit zu tun, sondern ich blicks einfach nicht.

kannst es nennen wie es willst, meinen obigen Code musst ich mir jedenfalls selber zusammenschreiben,
während du ihn schon vor dir liegen hattest und der Compiler darüber gemeckert hat

----------

generische Parameter kann man nicht einfach ändern wie man lustig ist

in eine
List<Number>
passen keine Integer rein, dann müsste man
List<? extends Number>
schreiben

(edit: na da habe ich übers Ziel hinausgeschossen, das geht doch, siehe lieber Benis Post)

hier ist es genauso,
List<List> verlangt List, ArrayList ist was anderes, Generics haben leider was gegen Vererbung

public class Test
{

    public static void main(String[] args)
        throws Exception
    {
        ArrayList<ArrayList<String>> list = new ArrayList<ArrayList<String>>();
        cartProduct(list); // geht 
        List<List<String>> list2 = new ArrayList<List<String>>();
        cartProduct(list2); // geht
        List<? extends List<String>> list3 = new ArrayList<ArrayList<String>>();
        cartProduct(list3); // geht
    }

    public static <T extends Object>List<List<T>> cartProduct(List<? extends List<T>> sets)
    {
        return null;
    }


}

 

[Beni]

Generics und Vererbungshierarchien sind orthogonal.

Wäre eine List<String> auch eine List<Object>, könne man ja jede List<String> in eine List<Object> casten und dann beliebige Objects (auch solche die nicht String sind) reinschreiben.

Deshalb ist "T extends Object" und "Object" auch überhaupt nicht dasselbe.

Dein letztes Problem, dass alle Sorten von Listen gefressen werden:

package test;

import java.util.ArrayList;
import java.util.List;

public class Test {
	public void huup(){
		ArrayList<ArrayList<Double>> quack = new ArrayList<ArrayList<Double>>();
		
		test( quack );
	}
	
	public <V, L extends List<V>> void test( List<L> quack ){
		
	}
}