Réponses:
Java ne prend pas en charge les tableaux associatifs, mais cela pourrait facilement être réalisé en utilisant a Map
. Par exemple,
Map<String, String> map = new HashMap<String, String>();
map.put("name", "demo");
map.put("fname", "fdemo");
// etc
map.get("name"); // returns "demo"
Encore plus précis dans votre exemple (puisque vous pouvez remplacer String par n'importe quel objet qui répond à vos besoins) serait de déclarer:
List<Map<String, String>> data = new ArrayList<>();
data.add(0, map);
data.get(0).get("name");
ArrayList
dans presque tous les cas en raison de différences de performances (inattendues?). Mais c'est une autre discussion.
HashMap
, et certainement pas sans comparer intentionnellement le comportement et trouver un meilleur facteur de charge pour votre cas d'utilisation. La seule raison de spécifier une taille initiale est si vous savez à l'avance que la carte sera très grande. HashMap
ne gaspille pas (beaucoup) de mémoire s'il est vide, mais si vous avez l'intention de créer une grande carte, vous pouvez enregistrer plusieurs redimensionnements de tableau en spécifiant sa taille à l'avance.
Java n'a pas de tableaux associatifs comme PHP.
Il existe différentes solutions pour ce que vous faites, comme l'utilisation d'une carte, mais cela dépend de la façon dont vous souhaitez rechercher les informations. Vous pouvez facilement écrire une classe contenant toutes vos informations et en stocker des instances dans un fichier ArrayList
.
public class Foo{
public String name, fname;
public Foo(String name, String fname){
this.name = name;
this.fname = fname;
}
}
Puis...
List<Foo> foos = new ArrayList<Foo>();
foos.add(new Foo("demo","fdemo"));
foos.add(new Foo("test","fname"));
Vous pouvez donc y accéder comme ...
foos.get(0).name;
=> "demo"
Vous pouvez accomplir cela via Maps. Quelque chose comme
Map<String, String>[] arr = new HashMap<String, String>[2]();
arr[0].put("name", "demo");
Mais lorsque vous commencez à utiliser Java, je suis sûr que vous constaterez que si vous créez une classe / un modèle qui représente vos données, ce seront vos meilleures options. je ferais
class Person{
String name;
String fname;
}
List<Person> people = new ArrayList<Person>();
Person p = new Person();
p.name = "demo";
p.fname = "fdemo";
people.add(p);
Il n'y a pas de tableau associatif en Java. Son parent le plus proche est a Map
, qui est fortement typé, mais a une syntaxe / API moins élégante.
C'est le plus proche que vous pouvez obtenir en fonction de votre exemple:
Map<Integer, Map<String, String>> arr =
org.apache.commons.collections.map.LazyMap.decorate(
new HashMap(), new InstantiateFactory(HashMap.class));
//$arr[0]['name'] = 'demo';
arr.get(0).put("name", "demo");
System.out.println(arr.get(0).get("name"));
System.out.println(arr.get(1).get("name")); //yields null
LazyMap.decorate
et InstantiateFactory
et tout ça pour?
Regardez l' interface Map et la classe concrète HashMap .
Pour créer une carte:
Map<String, String> assoc = new HashMap<String, String>();
Pour ajouter une paire valeur / clé:
assoc.put("name", "demo");
Pour récupérer la valeur associée à une clé:
assoc.get("name")
Et bien sûr, vous pouvez créer un tableau de cartes, car cela semble être ce que vous voulez:
Map<String, String>[] assoc = ...
Eh bien, j'étais également à la recherche d'un tableau associatif et j'ai trouvé la liste des cartes comme la meilleure solution.
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class testHashes {
public static void main(String args[]){
Map<String,String> myMap1 = new HashMap<String, String>();
List<Map<String , String>> myMap = new ArrayList<Map<String,String>>();
myMap1.put("URL", "Val0");
myMap1.put("CRC", "Vla1");
myMap1.put("SIZE", "Vla2");
myMap1.put("PROGRESS", "Vla2");
myMap.add(0,myMap1);
myMap.add(1,myMap1);
for (Map<String, String> map : myMap) {
System.out.println(map.get("URL"));
}
//System.out.println(myMap);
}
}
Équivalent Java du hachage de Perl
HashMap<Integer, HashMap<String, String>> hash;
Java n'a pas de tableaux associatifs, la chose la plus proche que vous pouvez obtenir est l' interface Map
Voici un exemple de cette page.
import java.util.*;
public class Freq {
public static void main(String[] args) {
Map<String, Integer> m = new HashMap<String, Integer>();
// Initialize frequency table from command line
for (String a : args) {
Integer freq = m.get(a);
m.put(a, (freq == null) ? 1 : freq + 1);
}
System.out.println(m.size() + " distinct words:");
System.out.println(m);
}
}
Si exécuté avec:
java Freq if it is to be it is up to me to delegate
Tu auras:
8 distinct words:
{to=3, delegate=1, be=1, it=2, up=1, if=1, me=1, is=2}
Tableaux associatifs en Java comme en PHP:
SlotMap hmap = new SlotHashMap();
String key = "k01";
String value = "123456";
// Add key value
hmap.put( key, value );
// check if key exists key value
if ( hmap.containsKey(key)) {
//.....
}
// loop over hmap
Set mapkeys = hmap.keySet();
for ( Iterator iterator = mapkeys.iterator(); iterator.hasNext();) {
String key = (String) iterator.next();
String value = hmap.get(key);
}
Plus d'informations, voir Class SoftHashMap: https://shiro.apache.org/static/1.2.2/apidocs/org/apache/shiro/util/SoftHashMap.html
Utilisez ArrayList <Map <String, String>>
Voici un exemple de code:
ArrayList<Map<String, String>> products = new ArrayList<Map<String, String>>();
while (iterator.hasNext()) {
Map<String, String> product = new HashMap<String, String>();
Element currentProduct = iterator.next();
product.put("id",currentProduct.get("id"));
product.put("name" , currentProduct.get("name") );
products.add(product );
}
System.out.println("products : " + products);
Production :
produits: [{id = 0001, name = prod1}, {id = 0002, name = prod2}]
En fait, Java prend en charge les tableaux associatifs, ils sont appelés dictionnaires!
En y réfléchissant davantage, je voudrais jeter les tuples comme un moyen plus général de résoudre ce problème. Bien que les tuples ne soient pas natifs de Java, j'utilise des Javatuples pour me fournir la même fonctionnalité qui existerait dans d'autres langues. Un exemple de la façon de traiter la question posée est
Map<Pair<Integer, String>, String> arr = new HashMap<Pair<Integer, String>, String>();
Pair p1 = new Pair(0, "name");
arr.put(p1, "demo");
J'aime cette approche car elle peut être étendue à des triplets et à d'autres groupements d'ordre supérieur avec des classes et des méthodes fournies par l'API.
Concernant le commentaire de PHP «Non, PHP ne l'aimerait pas». En fait, PHP continuerait à chugging à moins que vous ne définissiez des niveaux d'exception / erreur très restrictifs (pour PHP), (et peut-être même pas à ce moment-là).
Ce qui arrivera par défaut, c'est qu'un accès à un élément de tableau variable / hors limites 'désactive' la valeur que vous attribuez. NON, ce n'est PAS nul. PHP a une lignée Perl / C, d'après ce que je comprends. Il y a donc: des variables non définies et non existantes, des valeurs qui SONT définies mais sont NULL, des valeurs booléennes fausses, puis tout le reste des langages standard. Vous devez tester ces éléments séparément, OU choisir l'évaluation DROITE intégrée à la fonction / syntaxe.
NullPointerException
si la carte externe ne contient pas de carte pour l'entrée0
. PHP n'est-il pas plus permissif avec $ arr [0] ['nom'] (je ne connais pas du tout ce langage)?