Question

我试图创建很多对象，但反复使用new ObjectName(...)并不是我想要的。

new Obj("String", 0, true);
new Obj("Diff", 9, true);
new Obj("Changed", 2, false);
...

我想要类似的东西：

massCreateObj({
    {"String",  0, true },
    {"Diff",    9, true },
    {"Changed", 2, false}
    ...
});

我想这样做是因为管理多个对象会更容易，例如：

massCreateObjs({
    "Obj" => {
        {"str", 0, false},
        {"sss", 1, true}
    },
    "Obj2" => {
        {false, "different"},
        {true, "diff"}
    }
});

否则，我不得不压扁这个：

new Obj("str", 0, false);
new Obj("sss", 1, true);
new Obj2(false, "different");
new Obj2(true, "diff");

这只是不可扩展。使用数组，我可以轻松查看正在创建的对象，并且没有重复的文本（新的对象名称）。

有没有办法可以使用Hashmaps，Arrays或tuples来实现这一目标？（也可以打开其他解决方案）

我已经看了一下哈希图，但它基本上只是一个K-> V设置。

我也看过包装纸，但是，它又回到了我开始的地方。如果我创建一个类/接口，我仍然需要使用新的类名或其他什么，这是我首先要避免的。

Answer 1

不是在Java中指定对象，而是从文件中读取它们的参数。该文件可以是您喜欢的任何格式，并且可以解析。编写Java代码以从包含读取文件的数组的对象的构造函数调用并从中生成数组。

作为对此的变体，编写一个单独的程序来读取和解析文件，并从中生成Java程序。这样，您可以直接复制Color.BLUE等初始化程序。

Answer 2

如果您想对代码中的参数进行硬编码，但又想避免重复“new”关键字，那么就可以使用简单的循环。

String[] args1 = {"hello", "bye", "potatoe"};
int[] args2 = {5,2,7};
boolean[] args3 = {true,false,true};

Obj[] objects = new Obj[3];

for (int i = 0; i < 3; i++) {
    objects[i] = new Obj(args1[i], args2[i], args3[i]);
}

这不是好的代码，但可以更好的方式应用这个想法：）

Answer 3

您可以使用反射，但您必须按如下方式定义自己的功能：

public static <T> Object[] multipleConstructor(Class<T> type,
        Object[]... initargs) {
    ArrayList<T> list = new ArrayList<>();
    @SuppressWarnings("unchecked")
    Constructor<T>[] ctors = (Constructor<T>[]) type.getConstructors();
    for (int i = 0; i < initargs.length; i++) {
        for (Constructor<T> c : ctors) {
            try {
                list.add(c.newInstance(initargs[i]));
                break;
            } catch (Throwable t) {
                continue;
            }
        }
    }
    return list.toArray();
}

Answer 4

创建一个名为＆＃34; Node＆＃34;的内部类。如果输入数据遵循特定类型，例如str，int，boolean，str，int，bool和创建每个Node对象并将其放在HashMap中，如果对象有名称或者HashTable中没有名称。

Answer 5

如果要内联创建数组，可以随时执行

Obj[] objects = new Obj[] {
    new Obj("String", 0, true),
    new Obj("Diff", 9, true),
    new Obj("Changed", 2, false)
};

如果您正在尝试创建新对象，则无法使用new（或一些调用它的包装工厂函数）。

顺便说一下，你的用例听起来像你真正想要的是不可变数据结构，你应该考虑Guava的ImmutableList而不是裸阵列。

Answer 6

这是我的解决方案。我知道这不是codereview，但这样可以吗？

import java.lang.reflect.Constructor;
import java.util.Array;

public class MassCreate {
    private Array<Obj> objs = new Array<Obj>();

    public MassCreate(Object[][][] components) {
        Constructor<?> construct = null;
        try {
            for (int i = 0; i < components.length; i++)
                for (int i2 = 0; i2 < components[i].length; i2++)
                    if (i2 == 0) {
                        Class<?>[] classes = new Class[components[i][i2].length - 1];
                        for (int i3 = 1; i3 < components[i][i2].length; i3++)
                            classes[i3 - 1] = (Class<?>) components[i][i2][i3];
                        construct = ((Class<?>) components[i][i2][0])
                                .getConstructor(classes);
                    } else
                        objs.add((Obj) construct
                                .newInstance(components[i][i2]));
        } catch (Exception e) {}
    }

    public Obj[] getObjs() {
        Obj[] export = new Obj[objs.size];
        for (int i = 0; i < objs.size; i++)
            export[i] = objs.get(i);
        return export;
    }
}

现在，对于有趣的部分，我可以使用Object[][][]生成新对象。

Object[][][] components = {
        {
            {Obj.class, String.class, int.class, boolean.class},
            {"test 1", 0, true},
            {"test 2", 3, false}
        },
        {
            {Obj2.class, boolean.class, String.class},
            {true, "hello"},
            {false, "diff"}
        }
};

new MassCreate(components).getObjs(); //Obj2 extends Obj

这就是它的含义：

{Obj.class, String.class, int.class, boolean.class}

第一个类表示要制作的内容，其余的表示要使用的构造函数。所以对于这个，Obj.class的构造函数将是：

 public Obj(String str, int num, boolean bool);

第一级数组中的以下项目是对象，因此：

{"test 1", 0, true},
{"test 2", 3, false}

将使用这些值调用上述构造函数两次。

你们有什么想法？

数组中的多个类型用于初始化

6 个答案: