Java 列表<；列表<；字符串>&燃气轮机；仿制药问题

我有以下方法：

public static List<List<String>> createObject() {
    List<List<String>> listOfListOfStrings = new LinkedList<List<String>>();
    List<String> listOfStrings = new LinkedList<String>();
    //do some populating on the lists here
    listOfListOfStrings.add(listOfStrings);
    return listOfListOfStrings;
}

公共静态列表createObject（）{
List ListofListofString=new LinkedList（）；
List listofstring=newlinkedlist（）；
//在这里的列表上做一些填充
添加（listOfStrings）；
返回ListofListofString；
}

现在，我希望能够使用ArrayList/Vector/Stack而不是LinkedList（如果需要，可以进行不同的组合。我阅读了一些有关泛型的帖子，发现使用工厂模式来创建它们最合适（因为我不需要反射，而且使用泛型

也不起作用）.因此，我提出的解决方案如下：

public class Tester {
public static void main(String[] args){
    checkGenericsOfLists();
}

public static void checkGenericsOfLists(){
    List<List<String>> listOfListOfStrings = createObject(new LinkedListFactory<List<String>>(), new LinkedListFactory<String>());
    print(listOfListOfStrings);
    translate(listOfListOfStrings);
    print(listOfListOfStrings);
}

public static List<List<String>> createObject(ListFactorable mainListFactory, ListFactorable subListsFactory) {
    List<List<String>> listOfListOfStrings = mainListFactory.create();//new LinkedList<List<String>>();
    List<String> listOfStrings = subListsFactory.create();//new LinkedList<String>();
    listOfStrings.add("A");
    listOfListOfStrings.add(listOfStrings);
    return listOfListOfStrings;
}

public static void transform(List<List<String>> listOfListOfStrings){ 
            //do some abuse on the lists here.
}}

公共类测试器{
公共静态void main（字符串[]args）{
checkGenericOfList（）；
}
公共静态void checkGenericOfList（）{
List ListOfListFstrings=createObject（新建LinkedListFactory（），新建LinkedListFactory（））；
打印（列表字符串列表）；
翻译（ListofListofString）；
打印（列表字符串列表）；
}
公共静态列表createObject（ListFactorable主ListFactory、ListFactorable子ListFactory）{
List listofListofString=mainListFactory.create（）；//新建LinkedList（）；
List listofstring=subListsFactory.create（）；//新建LinkedList（）；
添加（“A”）；
添加（listOfStrings）；
返回ListofListofString；
}
公共静态无效转换（列表ListofListofString）{
//在这里的列表上做一些滥用。
}}

此解决方案提供以下警告：

ListFactorable是原始类型。对泛型类型ListFactorable的引用应参数化

这用于createObject方法签名。并且：

类型安全：类型列表的表达式需要未选中的转换才能符合字符串列表>>

这适用于工厂调用create（）方法的行

但如果我用这个：

public static List<List<String>> createObject(ListFactorable<List<List<String>>, List<String>> mainListFactory, ListFactorable<List<String>, String> subListsFactory) {
    List<List<String>> listOfListOfStrings = mainListFactory.create();//new LinkedList<List<String>>();
    List<String> list = subListsFactory.create();//new LinkedList<String>();
    list.add("A");
    listOfListOfStrings.add(list);
    return listOfListOfStrings;
}

公共静态列表createObject（ListFactorable主列表工厂、ListFactorable子列表工厂）{
List listofListofString=mainListFactory.create（）；//新建LinkedList（）；
List List=subListsFactory.create（）；//新建LinkedList（）；
列表。添加（“A”）；
listofListofString.add（列表）；
返回ListofListofString；
}

我发现编译器错误：

The method createObject(ListFactorable<List<List<String>>,List<String>>, ListFactorable<List<String>,String>) in the type Tester is not applicable for the arguments (LinkedListFactory<List<String>>, LinkedListFactory<String>)

类型测试仪中的方法createObject（ListFactorable，ListFactorable）不适用于参数（LinkedListFactory，LinkedListFactory）

有什么方法可以使编译器不抛出警告或错误，并在createObject方法不知道所使用的列表实现（在编译时）的情况下实例化这些列表吗

干杯，
暴君

编辑： 请原谅我没有发布其余的课程（我真傻：））。我们开始：

public interface ListFactorable<T extends List<K>, K> {
T create();}

public class LinkedListFactory<K> implements ListFactorable<LinkedList<K>, K> {
public LinkedList<K> create(){
    return new LinkedList<K>();
}}

公共接口ListFactorable{
T create（）；}
公共类LinkedListFactory实现ListFactory{
公共链接列表创建（）{
返回新的LinkedList（）；
}}

编辑2（尤金接受采访）：

公共接口EugeneListFactorable>{
公共链接列表创建（）{
将新的LinkedList返回到列表
-绑定不匹配：类型为的泛型方法createObject（EugeneListFactorable，EugeneListFactorable）
Tester不适用于参数（EugeneLinkedListFactory、EugeneLinkedListFactory）。推断的类型为LinkedList
不是有界参数的有效替代项

---

请尝试编译并运行我发布的示例和您的解决方案。这是一个测试类，您可以轻松地在您的IDE上运行。谢谢！

您需要正确地列出Factorable类：

public class ListFactorable<T extends List<?>> {
  public T create() {
    ...
  }
}

---

公共类ListFactorable您需要正确的ListFactorable类：

public class ListFactorable<T extends List<?>> {
  public T create() {
    ...
  }
}

public class ListFactorable这并不能完全解决您的问题，但它有助于更快地找到解决方案

当你有任何这样的事情时，请考虑重构到一个类中。我将提供一个例子。你看起来像是在使用转换。现在我不知道你的目标是什么，因为你没有声明它们，但是一种常见的方法是：
List<String> english = new LinkedList<String>();
List<String> french = new LinkedList<String>();
List<String> spanish = new LinkedList<String>();

List<List<String>> languages = new LinkedList<List<String>>();
languages.add(english);
languages.add(french);
languages.add(spanish);

for(String word : someWordList) {
    for(List<String> language : languages) {
         // oh snap! I really have no idea what language I'm working in...
         // I could do something silly like make list.get(0) be the language
         // name, but that seems lame
    }
}

List english=newlinkedlist（）；
List french=新链接列表（）；
List西班牙语=新建LinkedList（）；
列表语言=新建LinkedList（）；
语言。添加（英语）；
语言。添加（法语）；
语文.加上（西班牙文）；
for（字符串字：someWordList）{
for（列表语言：语言）{
//哎呀！我真的不知道我在用什么语言工作。。。
//我可以做一些愚蠢的事情，比如列清单。让（0）成为语言
//名字，但这似乎是站不住脚的
}
}

最好是这样：

public static <N extends List<List<String>>,M extends List<String>> N createObject( //
        ListFactorable<N> mainListFactory, //
        ListFactorable<M> subListsFactory) {
    N listOfListOfStrings = mainListFactory.create();//new LinkedList<List<String>>();
    M listOfStrings = subListsFactory.create();//new LinkedList<String>();
    listOfStrings.add("A");
    listOfListOfStrings.add(listOfStrings);
    return listOfListOfStrings;
}

class Language {
    final String language;
    final Map<String,String> english2current;
    Language(String language, Set<String> words) {
        this.language = language;
        english2current = new HashMap<String,String>();
        Translator t = TranslatorFactory.getTranslator(language);
        for(String word : words) english2current.put(word,t.translate(word));
    }
}

Collection<String> wordSet() {
    return english2current.values();
}

类语言{
最终字符串语言；
最终地图显示当前地图；
语言（字符串语言、集合词）{
这种语言=语言；
english2current=新HashMap（）；
Translator t=TranslatorFactory.getTranslator（语言）；
对于（字符串词：单词）英语2当前。put（单词，t.translate（单词））；
}
}
集合词集（）{
返回当前的.values（）；
}

现在，如果看不到更多的实现，就很难确切地看出您做错了什么。但是无论您在做什么，都要考虑删除任何嵌套泛型，而不是尝试将它们隔离到类中。。这将允许您以面向对象的方式整合行为，并更好地组织您的逻辑，以便能够让我们知道它应该做什么，而不是泛型的语义。
这并不能完全解决您的问题，但它有助于更快地找到解决方案

当你有任何这样的事情时，请考虑重构到一个类中。我将提供一个例子。你看起来像是在使用转换。现在我不知道你的目标是什么，因为你没有声明它们，但是一种常见的方法是：
List<String> english = new LinkedList<String>();
List<String> french = new LinkedList<String>();
List<String> spanish = new LinkedList<String>();

List<List<String>> languages = new LinkedList<List<String>>();
languages.add(english);
languages.add(french);
languages.add(spanish);

for(String word : someWordList) {
    for(List<String> language : languages) {
         // oh snap! I really have no idea what language I'm working in...
         // I could do something silly like make list.get(0) be the language
         // name, but that seems lame
    }
}

List english=newlinkedlist（）；
List french=新链接列表（）；
列表西班牙语=新建LinkedList（）
public class Tester {

    public static void main(String[] args) {
        checkGenericsOfLists();
    }

    public static void checkGenericsOfLists() {
        List<List<String>> listOfListOfStrings = createObject(
                new LinkedListFactory<List<String>>(),
                new LinkedListFactory<String>());
        transform(listOfListOfStrings);
    }

    public static List<List<String>> createObject(
            ListFactorable<List<List<String>>, List<String>> mainListFactory, 
            ListFactorable<List<String>, String> subListsFactory
    ) 
    {
        List<List<String>> listOfListOfStrings = mainListFactory.create();
        List<String> listOfStrings = subListsFactory.create();
        listOfStrings.add("A");
        listOfListOfStrings.add(listOfStrings);
        return listOfListOfStrings;
    }

    public static void transform(List<List<String>> listOfListOfStrings) {
        // do some abuse on the lists here.
        System.out.println(listOfListOfStrings);
    }

    public interface ListFactorable<T extends List<K>, K> {
        T create();
    }

    static public class LinkedListFactory<K> implements ListFactorable<List<K>, K> {
        public LinkedList<K> create() {
            return new LinkedList<K>();
        }
    }
}

public class Tester2 {
    public static void main(String[] args) {
        checkGenericsOfLists();
    }

    public static void checkGenericsOfLists() {
        List<List<String>> listOfListOfStrings = createObject(
                new LinkedListFactory<List<String>>(),
                new LinkedListFactory<String>());
        transform(listOfListOfStrings);
    }

    public static List<List<String>> createObject(
            ListFactory<List<String>> mainListFactory, 
            ListFactory<String> subListsFactory
    ) 
    {
        List<List<String>> listOfListOfStrings = mainListFactory.create();
        List<String> listOfStrings = subListsFactory.create();
        listOfStrings.add("A");
        listOfListOfStrings.add(listOfStrings);
        return listOfListOfStrings;
    }

    public static void transform(List<List<String>> listOfListOfStrings) {
        // do some abuse on the lists here.
        System.out.println(listOfListOfStrings);
    }

    public interface ListFactory<T> {
        List<T> create();
    }

    static public class LinkedListFactory<T> implements ListFactory<T> {
        public List<T> create() {
            return new LinkedList<T>();
        }
    }
}