创建一个具有多个对象类型的数组列表？

小开

你可以创建一个 List<Object>，但你真的不想这样做。抽象为 Object 的混合列表不是很有用，而且可能是 bug 的来源。事实上，您的代码需要这样一个结构，这使您的代码有一种不好的代码味道，并表明它的设计可能是错误的。考虑重新设计你的程序，这样你就不用被迫和猩猩一起收集橙子了。

相反——按照 G V 的建议，创建一个同时包含 int 和 String 的自定义类，并创建它的 ArrayList。他的回答是1 + ！

小开

最佳答案

你可以这样做:

List<Object> sections = new ArrayList <Object>();

(推荐)另一个可能的解决方案是使用两个参数一个 Integer 和另一个 String 创建一个自定义模型类。然后使用该对象的 ArrayList。

小开

如果你不知道类型是 Integer 或 String，那么你就不需要泛型了。

List list= new ArrayList ();


list.add(1);
list.add("myname");


for(Object o = list){


}

小开

可以使用 Object 存储任何类型的值，例如 int、 float、 String、 class 对象或任何其他 Java 对象，因为它是所有类的根。举例来说。

声明一个类

class Person {
public int personId;
public String personName;


public int getPersonId() {
return personId;
}


public void setPersonId(int personId) {
this.personId = personId;
}


public String getPersonName() {
return personName;
}


public void setPersonName(String personName) {
this.personName = personName;
}}

main function code, which creates the new person object, int, float, and string type, and then is added to the List, and iterated using for loop. Each object is identified, and then the value is printed.

    Person p = new Person();
p.setPersonId(1);
p.setPersonName("Tom");


List<Object> lstObject = new ArrayList<Object>();
lstObject.add(1232);
lstObject.add("String");
lstObject.add(122.212f);
lstObject.add(p);


for (Object obj : lstObject) {
if (obj.getClass() == String.class) {
System.out.println("I found a string :- " + obj);
}
if (obj.getClass() == Integer.class) {
System.out.println("I found an int :- " + obj);
}
if (obj.getClass() == Float.class) {
System.out.println("I found a float :- " + obj);
}
if (obj.getClass() == Person.class) {
Person person = (Person) obj;
System.out.println("I found a person object");
System.out.println("Person Id :- " + person.getPersonId());
System.out.println("Person Name :- " + person.getPersonName());
}
}

You can find more information on the object class on this link Object in java

小开

您总是可以创建 ArrayList的 Object。但这对你没什么用。假设您已经像下面这样创建了 Arraylist:

List<Object> myList = new ArrayList<Object>();

并像下面这样向列表中添加对象:

myList.add(new Integer("5"));

myList.add("object");

myList.add(new Object());

在添加和检索对象时不会遇到任何问题，但是它不会非常有用。为了使用它，你必须记住每种类型的对象在什么位置。在这种情况下，检索之后，您所能做的就是对它们调用 Object的方法。

小开

创建自己的类来存储字符串和整数，然后列出这些对象。

class Stuff {
private String label;
private Integer value;


// Constructor
public void Stuff(String label, Integer value) {
if (label == null || value == null) {
throw NullPointerException();
}
this.label = label;
this.value = value;
}


// getters
public String getLabel() {
return this.label;
}


public Integer getValue() {
return this.value;
}
}

然后在你的代码中:

private List<Stuff> items = new ArrayList<Stuff>();
items.add(new Stuff(label, value));


for (Stuff item: items) {
doSomething(item.getLabel()); // returns String
doSomething(item.getValue()); // returns Integer
}

小开

您只需将不同“类型”的对象添加到 ArrayList 的实例中即可。不需要创建数组列表。看看下面的例子, 您将得到以下输出: < br/> < br/> 开始..。
Array 的内容: [ String，1]
名单大小: 2
这不是整数字符串
这是一个整数1 < br/>

package com.viswa.examples.programs;


import java.util.ArrayList;
import java.util.Arrays;


public class VarArrayListDemo {


@SuppressWarnings({ "rawtypes", "unchecked" })
public static void main(String[] args) {
System.out.println(" Beginning....");


ArrayList varTypeArray = new ArrayList();
varTypeArray.add("String");
varTypeArray.add(1); //Stored as Integer


System.out.println(" Contents of array: " + varTypeArray + "\n Size of the list: " + varTypeArray.size());


Arrays.stream(varTypeArray.toArray()).forEach(VarArrayListDemo::checkType);
}


private static <T> void checkType(T t) {


if (Integer.class.isInstance(t)) {
System.out.println(" This is an Integer " + t);
} else {
System.out.println(" This is not an Integer" + t);
}
}


}

小开

List<Object> list = new ArrayList<>();
list.add(1);
list.add("1");

由于 ArrayList 的返回类型是 object，因此可以向 ArrayList 添加任何类型的数据，但是使用 ArrayList 不是一个好的做法，因为存在不必要的装箱和解箱操作。

小开

用户定义的类数组列表示例

import java.util.*;


public class UserDefinedClassInArrayList {


public static void main(String[] args) {


//Creating user defined class objects
Student s1=new Student(1,"AAA",13);
Student s2=new Student(2,"BBB",14);
Student s3=new Student(3,"CCC",15);


ArrayList<Student> al=new ArrayList<Student>();
al.add(s1);
al.add(s2);
al.add(s3);


Iterator itr=al.iterator();


//traverse elements of ArrayList object
while(itr.hasNext()){
Student st=(Student)itr.next();
System.out.println(st.rollno+" "+st.name+" "+st.age);
}
}
}


class Student{
int rollno;
String name;
int age;
Student(int rollno,String name,int age){
this.rollno=rollno;
this.name=name;
this.age=age;
}
}

程序输出:

1 AAA 13

2 BBB 14

3 CCC 15

小开

(1)

   ArrayList<Object> list = new ArrayList <>();`
list.add("ddd");
list.add(2);
list.add(11122.33);
System.out.println(list);

(2)

 ArrayList arraylist = new ArrayList();
arraylist.add(5);
arraylist.add("saman");
arraylist.add(4.3);
System.out.println(arraylist);

小开

这取决于用例，你能更详细地描述一下吗？

如果您希望能够同时添加两者，那么可以使用@Sanket Parikh 所描述的方法。将 Integer 和 String 放入一个新类并使用它。
如果您希望添加一个 String 或 int 列表，但一次只添加其中一个，那么确保它是 List<Object>

看起来不错，但只是第一眼！这不是一个好的模式。每次从列表中获取对象时，都必须检查对象的类型。此外，这种类型的列表也可以包含任何其他类型。.所以，这不是个好办法。不过对于初学者来说也许可以用。如果您选择这个，我建议您检查 Java 中的“ instanceof”是什么。
我强烈建议重新考虑您的需求，并考虑您的真正需要是将整数封装为 List<Integer>，将字符串封装为单独的 List<String>

我能打个比方说说你现在想做什么吗？我会说，你想做一个列表，其中可以包含咖啡豆和咖啡店。这些对象的类型是完全不同的！为什么把这些放在同一个架子上？:)

或者你有可能的数据，可以是一个词或一个数字？没错！这就说得通了，它们都是数据！然后尝试使用一个对象，其中包含的数据作为字符串，如果需要，可以转换为整数值。

public class MyDataObj {
String info;
boolean isNumeric;


public MyDataObj(String info){
setInfo(info);
}


public MyDataObj(Integer info){
setInfo(info);
}


public String getInfo() {
return info;
}


public void setInfo(String info) {
this.info = info;
this.isNumeric = false;
}


public void setInfo(Integer info) {
this.info = Integer.toString(info);
this.isNumeric = true;
}


public boolean isNumeric() {
return isNumeric;
}
}

这样你就可以使用 List<MyDataObj>来满足你的需求了。同样，这也取决于你的需求! :)

一些版本: 使用遗传怎么样？这比 List<Object>解决方案更好，因为你不能在列表中有其他类型，然后字符串或整数: 界面:

public interface IMyDataObj {
public String getInfo();
}

字符串:

public class MyStringDataObj implements IMyDataObj {


final String info;


public MyStringDataObj(String info){
this.info = info;
}


@Override
public String getInfo() {
return info;
}
}

对于整数:

public class MyIntegerDataObj implements IMyDataObj {


final Integer info;


public MyIntegerDataObj(Integer info) {
this.info = info;
}


@Override
public String getInfo() {
return Integer.toString(info);
}
}

最后列表将是: List<IMyDataObj>

小开

只需使用 Entry (如 java.util. Map.Entry)作为列表类型，并使用(java.util. AbstractMap 的) SimpleImmutableEntry 填充它:

List<Entry<Integer, String>> sections = new ArrayList<>();
sections.add(new SimpleImmutableEntry<>(anInteger, orString)):

小开

对我来说，这个方法在 jdk 16中完全可以正常工作

import java.util.ArrayList;
public class Array {
public static void main(String[] args) {
ArrayList arrayList= new ArrayList();
arrayList.add("alien");
arrayList.add(1);
arrayList.add(0,'b');
System.out.println(arrayList);
System.out.println((arrayList.get(0)) instanceof Integer);
}
}

输出

[b, alien, 1]
false