Java 是否创建具有多个对象类型的ArrayList？

如何使用整数和字符串输入类型创建

ArrayList

？如果我将其创建为：

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

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

这将是

String

类型。 如何创建既可以接受整数输入类型又可以接受字符串输入类型的

ArrayList

？

---

谢谢。

您可以创建一个

列表，但您确实不想这样做。抽象为对象的混合列表不是很有用，并且可能是bug的来源。事实上，您的代码需要这样一个构造，这给了您的代码一种糟糕的代码味道，并表明它的设计可能已经过时。考虑重新设计你的程序，这样你就不会被迫用猩猩来收集桔子了。
取而代之的是——按照GV的建议（我将要建议的），创建一个同时包含int和String的自定义类，并创建它的ArrayList。他的答案是1+
 你可以这样做：

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

List sections=newarraylist（）；

（推荐的）另一种可能的解决方案是使用两个参数创建自定义模型类，一个是整数，另一个是字符串。然后使用该对象的
ArrayList
。
如果不知道类型是整数或字符串，则不需要泛型。用老式的

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


主函数代码，它创建新的person对象、int、float和string类型，然后添加到列表中，并使用for循环进行迭代。识别每个对象，然后打印值

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

Person p=新人（）；
p、 setPersonId（1）；
p、 setPersonName（“Tom”）；
List lstObject=new ArrayList（）；
lstObject.add（1232）；
添加（“字符串”）；
lstObject.add（122.212f）；
添加（p）；
对于（对象对象：lstObject）{
if（obj.getClass（）==String.class）{
System.out.println（“我找到了一个字符串：-”+obj）；
}
if（obj.getClass（）==Integer.class）{
System.out.println（“我找到了一个int:-”+obj）；
}
if（obj.getClass（）==Float.class）{
System.out.println（“我找到了一个float:-”+obj）；
}
if（obj.getClass（）==Person.class）{
人员=（人员）obj；
System.out.println（“我发现了一个人对象”）；
System.out.println（“个人Id:-”+Person.getPersonId（））；
System.out.println（“人名：-”+Person.getPersonName（））；
}
}

您可以在此链接上找到有关对象类的详细信息
您可以始终创建
对象
的
数组列表
。但这对你来说不是很有用。假设您已经像这样创建了
Arraylist
：

List myList=new ArrayList（）

并将对象添加到此列表，如下所示：

myList.add（新整数（“5”）

myList.add（“对象”）

myList.add（newobject（））

在添加和检索对象时不会遇到任何问题，但它不会非常有用。
您必须记住每种类型的对象在什么位置才能使用它。在本例中，在检索之后，您所能做的就是对它们调用
Object
方法。
我也是Java新手，刚刚发现了这一点。您应该创建自己的类来存储字符串和整数，然后列出这些对象。例如（我确信这段代码不完美，但比arrayList好）：

然后在代码中：

private ArrayList<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
}

private ArrayList items=new ArrayList（）；
添加（新材料（标签、价值））；
用于（物料项：物料）{
doSomething（item.getLabel（））；//返回字符串
doSomething（item.getValue（））；//返回整数
}
您只需将不同“类型”的对象添加到ArrayList的实例中即可。无需创建ArrayList。看看下面的例子，
您将获得以下输出：


开始

数组内容：[字符串，1]

列表大小：2

这不是整数字符串

这是一个整数1

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

}

package com.viswa.examples.programs；
导入java.util.ArrayList；
导入java.util.array；
公共类VarArrayListDemo{
@SuppressWarnings（{“rawtypes”，“unchecked”}）
公共静态void main（字符串[]args）{
System.out.println（“开始…”）；
ArrayList varTypeArray=新的ArrayList（）；
添加（“字符串”）；
varTypeArray.add（1）；//存储为整数
System.out.println（“数组内容：+varTypeArray+”\n列表大小：+varTypeArray.Size（））；
stream（varTypeArray.toArray（））.forEach（VarArrayListDemo:：checkType）；
}
专用静态无效检查类型（T）{
if（Integer.class.isInstance（t））{
System.out.println（“这是一个整数”+t）；
}否则{
System.out.println（“这不是整数”+t）；
}
}
}
List List=new ArrayList（）；
增加第（1）款；
列表。添加（“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;  
    }  
} 

import java.util.*；
公共类UserDefinedClassInArrayList{
公共静态void main（字符串[]args）{
//创建用户定义的类对象
学生s1=新生（1，“AAA”，13）；
学生s2=新生（2，“BBB”，14）；
学生s3=新生（3，“CCC”，15）；
ArrayList al=新的ArrayList（）；
al.添加（s1）；
al.添加（s2）；
al.add（s3）；
迭代器itr=al.Iterator（）；
//遍历ArrayList对象的元素
而（itr.hasNext（））{
学生st=（学生）itr.next（）；
System.out.println（st.rollno+“”+st.name+“”+st.age）；
}  
}
}
圣班
List<Object> list = new ArrayList<>();
          list.add(1);
          list.add("1");

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

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

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

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

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<Entry<Integer, String>> sections = new ArrayList<>();
sections.add(new SimpleImmutableEntry<>(anInteger, orString)):

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