Créer une ArrayList avec plusieurs types d'objet?
Comment créer un ArrayList avec des types d'entrée entiers et chaînes? Si j'en crée un en tant que:
List<Integer> sections = new ArrayList <Integer>();
ce sera un Integer type ArrayList. Si j'en crée un en tant que:
List<String> sections = new ArrayList <String>();
ce sera de type String. Comment créer un ArrayList pouvant prendre à la fois des types entiers et des types de chaîne? Je vous remercie.
Exemple de liste de matrices de classes définies par l'utilisateur
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;
}
}
Sortie du programme:
1 AAA 13
2 BBB 14
3 CCC 15
Vous pouvez le faire comme:
List<Object> sections = new ArrayList <Object>();
(Recommandé) Une autre solution possible serait de créer une classe de modèle personnalisée avec deux paramètres, un entier et une autre chaîne. Puis en utilisant un ArrayList de cet objet.
(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);
Vous pouvez utiliser Object pour stocker tout type de valeur, par exemple. int, float, String, objets de classe ou tout autre objet Java, puisqu'il s'agit de la racine de toute la classe. Par exemple.
Déclarer une classe
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; }}le code de la fonction principale, qui crée les nouveaux types d'objet personne, int, float et string, puis est ajouté à la liste et itéré à l'aide de la boucle for. Chaque objet est identifié, puis la valeur est imprimée.
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()); } }
Vous pouvez trouver plus d’informations sur la classe d’objets sur ce lien Objet en Java
Je suis également nouveau sur Java et je viens de le comprendre. Vous devez créer votre propre classe qui stocke la chaîne et l'entier, puis dressez une liste de ces objets. Par exemple (je suis sûr que ce code est imparfait, mais meilleur que arrayList):
class Stuff {
private String label;
private Integer value;
// Constructor or setter
public void Stuff(String label, Integer value) {
if (label == null || value == null) {
return;
}
this.label = label;
this.value = value;
}
// getters
public String getLabel() {
return this.label;
}
public Integer getValue() {
return this.value;
}
}
Puis dans votre code:
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
}
Vous ne savez pas que le type est Integer ou String alors vous n'avez pas besoin de générique. Allez avec le style ancien.
List list= new ArrayList ();
list.add(1);
list.add("myname");
for(Object o = list){
}
Cela dépend du cas d'utilisation. Pouvez-vous, s'il vous plaît, décrire plus?
- Si vous voulez pouvoir ajouter les deux à la fois, vous pouvez faire ce qui est bien décrit par @Sanket Parikh. Mettez Integer et String dans une nouvelle classe et utilisez-la.
Si vous voulez ajouter la liste soit une chaîne, soit un entier, mais seulement un à la fois, assurez-vous que c'est bien le
List<Object>qui a l'air bien mais seulement pour la première vue! Ce n'est pas un bon modèle. Vous devrez vérifier quel type d'objet vous avez chaque fois que vous obtenez un objet de votre liste. Aussi Ce type de liste peut contenir n'importe quel autre type. Donc non, ce n'est pas une solution intéressante. Bien que peut-être pour un débutant, il peut être utilisé. Si vous choisissez cela, je vous conseillerais de vérifier ce qui est "instanceof" en Java.
- Je conseillerais fortement de reconsidérer vos besoins et de réfléchir à ce que votre véritable tête consiste à encapsuler des entiers dans un
List<Integer>et des chaînes dans unList<String>séparé
Puis-je vous dire une métaphore de ce que vous voulez faire maintenant? Je dirais que vous voulez faire une liste qui peut contenir des grains de café et des cafés. Ces types d'objets sont totalement différents! Pourquoi sont-ils placés sur la même étagère? :)
Ou avez-vous peut-être des données qui peuvent être un mot ou un nombre? Yepp! Cela aurait du sens, les deux sont des données! Essayez ensuite d’utiliser un objet contenant les données sous forme de chaîne et, si nécessaire, pouvant être traduit en valeur entière.
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;
}
}
De cette façon, vous pouvez utiliser List<MyDataObj> pour vos besoins. Encore une fois, cela dépend de vos besoins! :)
Une édition: Qu'en est-il de l'inharitance? Ceci est préférable à la solution List<Object>, car vous ne pouvez pas définir d’autres types dans la liste, puis Strings ou Integers: Interface:
public interface IMyDataObj {
public String getInfo();
}
Pour String:
public class MyStringDataObj implements IMyDataObj {
final String info;
public MyStringDataObj(String info){
this.info = info;
}
@Override
public String getInfo() {
return info;
}
}
Pour Integer:
public class MyIntegerDataObj implements IMyDataObj {
final Integer info;
public MyIntegerDataObj(Integer info) {
this.info = info;
}
@Override
public String getInfo() {
return Integer.toString(info);
}
}
Enfin, la liste sera: List<IMyDataObj>
Vous pouvez créer un List<Object>, mais vous ne voulez vraiment pas le faire. Les listes mixtes qui résument en Object ne sont pas très utiles et constituent une source potentielle de bogues. En fait, le fait que votre code nécessite une telle construction donne à votre code une mauvaise odeur de code et laisse à penser que sa conception peut être incorrecte. Pensez à redéfinir votre programme afin de ne pas être obligé de collecter des oranges avec des orangs-outans.
Au lieu de cela, faites ce que G V recommande et que j'étais sur le point de recommander, créez une classe personnalisée contenant à la fois int et String et créez une liste ArrayList. 1+ à sa réponse!
ArrayList list = new ArryaList();
list.Add(1);
list.Add("1");
Comme le type de retour de ArrayList est object, vous pouvez donc ajouter n’importe quel type de données à ArrayList, mais il n’est pas recommandé d’utiliser ArrayList car il existe un boxing inutile et un unboxing existant.
Vous pouvez toujours créer une ArrayList sur Objects. Mais cela ne vous sera pas très utile. Supposons que vous ayez créé la Arraylist comme ceci:
List<Object> myList = new ArrayList<Object>();
et ajoutez des objets à cette liste comme ceci:
myList.add(new Integer("5"));
myList.add("object");
myList.add(new Object());
Vous ne rencontrerez aucun problème lors de l'ajout et de la récupération de l'objet, mais cela ne sera pas très utile. Vous devez vous rappeler à quel emplacement chaque type d'objet est-il pour pouvoir l'utiliser. Dans ce cas, après avoir récupéré, tout ce que vous pouvez faire est d’appeler les méthodes de Object.
Vous pouvez simplement ajouter des objets de "Types" différents à une instance de ArrayList. Pas besoin de créer une ArrayList. Regardez l'exemple ci-dessous, vous obtiendrez une sortie ci-dessous:
Début....
Contenu du tableau: [String, 1]
Taille de la liste: 2
Ceci n'est pas une chaîne entière
Ceci est un entier 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);
}
}
}