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

我正在尝试创建很多对象，但反复使用

newobjectname（…）

并不是我想要的

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、数组或元组来实现这一点？（对其他解决方案也持开放态度）

我已经看了hashmaps，但它本质上只是一个K->V设置

---

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

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

---

作为一种变体，编写一个单独的程序来读取和解析文件，并从中生成一个Java程序。这样，您就可以直接复制像

Color.BLUE

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

---

作为一种变体，编写一个单独的程序来读取和解析文件，并从中生成一个Java程序。这样，您就可以直接复制像

Color.BLUE

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

---

作为一种变体，编写一个单独的程序来读取和解析文件，并从中生成一个Java程序。这样，您就可以直接复制像

Color.BLUE

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

---

作为一种变体，编写一个单独的程序来读取和解析文件，并从中生成一个Java程序。这样，您就可以直接复制初始值设定项，如

Color.BLUE

如果您想硬编码代码中的参数，但又想避免重复“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]);
}

String[]args1={“你好”，“再见”，“土豆”}；
int[]args2={5,2,7}；
布尔值[]args3={true，false，true}；
Obj[]对象=新Obj[3]；
对于（int i=0；i<3；i++）{
对象[i]=新对象（args1[i]、args2[i]、args3[i]）；
}

---

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

如果您想硬编码代码中的参数，但又想避免重复“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]);
}

String[]args1={“你好”，“再见”，“土豆”}；
int[]args2={5,2,7}；
布尔值[]args3={true，false，true}；
Obj[]对象=新Obj[3]；
对于（int i=0；i<3；i++）{
对象[i]=新对象（args1[i]、args2[i]、args3[i]）；
}

---

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

如果您想硬编码代码中的参数，但又想避免重复“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]);
}

String[]args1={“你好”，“再见”，“土豆”}；
int[]args2={5,2,7}；
布尔值[]args3={true，false，true}；
Obj[]对象=新Obj[3]；
对于（int i=0；i<3；i++）{
对象[i]=新对象（args1[i]、args2[i]、args3[i]）；
}

---

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

如果您想硬编码代码中的参数，但又想避免重复“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]);
}

String[]args1={“你好”，“再见”，“土豆”}；
int[]args2={5,2,7}；
布尔值[]args3={true，false，true}；
Obj[]对象=新Obj[3]；
对于（int i=0；i<3；i++）{
对象[i]=新对象（args1[i]、args2[i]、args3[i]）；
}

---

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

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

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();
}

publicstaticobject[]multipleConstructor（类类型，
对象[]…initargs）{
ArrayList=新建ArrayList（）；
@抑制警告（“未选中”）
构造函数[]构造函数=（构造函数[]）类型.getConstructors（）；
for（int i=0；i

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

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();
}

publicstaticobject[]multipleConstructor（类类型，
对象[]…initargs）{
ArrayList=新建ArrayList（）；
@抑制警告（“未选中”）
构造函数[]构造函数=（构造函数[]）类型.getConstructors（）；
for（int i=0；i

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

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();
}

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