annuaire
Qu'est-ce qu'une collection de
Pourquoi il devrait y avoir un ensemble de
Comment utiliser une collection
Il dispose d'une collection de
La différence entre les collections et les tableaux
Qu'est-ce qu'une collection de
Collections et tableaux comme, est placé dans un conteneur de données, mais son magasin est le plus de choses java commun: objets.
Pourquoi il devrait y avoir un ensemble de
Programme savent toujours lors de l' exécution de certaines conditions, ainsi de créer des objets. Mais avant que ne savait pas le nombre et le type de l'objet, il ne peut pas compter sur la création d' une référence nommée pour tenir chaque objet, il est nécessaire de créer un certain nombre d'objets à tout moment et en tout lieu . Où est - ce que ces objets existent? Nous savons, d' économiser beaucoup de temps, notre première pensée est ce tableau, mais le tableau est statique, la longueur a été réglée, il ne peut pas créer un certain nombre de lignes à nos exigences. Zezheng il? Depuis que la collection est née -
Comment utiliser une collection
Collection propose:
1, un récipient pour le stockage d'objets.
2, la longueur de la variable est définie.
3, la valeur de consigne ne peuvent être stockées dans les types de données de base.
Il y a beaucoup de collections, ce que nous pouvons être divisés en catégories: Collection ensembles et carte
Pourquoi diviser-vous?
Collection: est une séquence d'éléments indépendants, comme si, comme les tableaux, il est l'un de l'objet indépendant, comme [chat, chien, poisson], c'est une collection qui contient trois objets distincts.
Carte: il est composé d'une paire de clés « sur les » clés d'objet {valeur} {exemple 1, chat} {2, chien} {3,} poissons. Il fait ce qui est bon? Carte appelée carte, qui vous permet de trouver la cible à la valeur de l'objet, trouver un tableau de goût classique un peu moins d'un tableau de contenu à l'intérieur, comme un dictionnaire avec le mot phonétique est venu à la même, de sorte que la carte est aussi appelée « tableaux associatifs », « Dictionnaire ".
Alors que le dessin Da, l'écriture est Shane?
Nous pouvons voir, les interfaces Collection et carte sont écrits << >> Les deux sont très abstraite génération de caractères « grand-père », la position haute, on peut généralement intouchable.
Collection sous la charge de l'interface de file d'attente (de file d'attente) Liste Interface (liste) et interfaces (SET) trois membres du personnel squelette, nous utilisons principalement, ils sont l'homme droit de mise en œuvre.
Carte a donné naissance à pas si prospère, principalement utilisé, est TreeMap, HashMap, Hashtable.
La différence entre les collections et les tableaux
1, le tableau peut stocker les types de données de base et le type de données de référence (objet), mais seulement stocke les mêmes. La collection ne peut stocker les types de données de référence (objets), mais vous pouvez stocker différents types d'objets (mais nous ne le faisons pas).
2, le tableau est statique, la longueur ne peut pas être modifié une fois créé. la capacité de collecte est dynamique et peut être réglé à l'état atteint après l'expansion.
3, la mise en œuvre différents sous-jacent, le réseau sous-jacent est un tableau séquentiel, et définir les structures sous-jacentes pour parvenir à une variété de telle table de séquence, une table de hachage, et les arbres.
Et Liste spécifique, Set, un article sur Carte n'est pas clair, nous marquons plus de quelques articles, la combinaison de code source, ladite comprendre lentement -
Laissez-nous d'abord parler de l'interface de niveau supérieur, ils ont une fonction.
Interface collection
En tant que haut niveau Collection, il a la fonction doit être raffinée à la plus extrême, car ce type de collection (séquence séparée) devrait avoir à réaliser toutes les fonctions spécifiques nécessaires, nous devons donner une structure spécifique légèrement.
Commençons à parler de la naissance, la collection comme un « tableau complémentaire », il doit avoir quelle fonction? Copier au sujet d'un tableau, il doit être la base de la propriété, CRUD il est nécessaire, mais aussi un traversal tableau, nous devons le traverser.
1, par
Ajouter booléenne (Object obj):
booléen addAll (Collection coll):
méthode Look saura, « augmentation » fonctionnement d'au moins deux façons, d'abord par un seul objet, le second est toute une collection augmentera dans, et enfin retour est la « augmentation » si l'opération a réussi.
2, supprimer
supprimer booléen (obj de l'objet):
booléen removeAll (Collection coll);
vide clair ();
« Supprimer » dans les deux premiers cas et la « augmentation » très bien même, ce qui est clair est-ce tiers? Il est de supprimer tous les éléments de la collection, une collection de complètement vidé.
3, le changement
Comme mentionné plus haut, la Collection est une suite d'éléments individuels, en rat [chat, chien, poisson] Dans le poisson ne sera pas augmenter le rat de poisson est supprimé après, donc
4, chèque
boolean contient (objet obj):
boolean containsAll (Colllection coll);
boolean isEmpty (): s'il y a des éléments de l'ensemble est déterminé.
Voici toutes les méthodes de collecte, nous ne les voyons pas ici.
Par exemple ~
public class DJ_CollectionDemo {
public static void main(String[] args) {
Collection coll = new ArrayList(); //ArrayList后面会说到滴，这里可以先略过，直接看作Collection
show(coll);
}
public static void show(Collection coll) {
// 1.添加元素
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
System.out.println(coll);// [abc1, abc2, abc3] 打印集合会打印集合里的所有值：一个字符串整体
// 2.删除集合
coll.remove("abc2");
System.out.println(coll);// [abc1, abc3] remove会改变集合长度
// coll.clear();
// System.out.println();// 无内容
// 判断
System.out.println(coll.contains("abc4"));// false
System.out.println(coll.contains("abc1"));// true
}public class DJ_CollectionDemo {
public static void main(String[] args) {
Collection c1 = new ArrayList();
Collection c2 = new ArrayList();
show(c1, c2);
}
//关于ALL类的
public static void show(Collection c1, Collection c2) {
// 给c1添加元素。
c1.add("abc1");
c1.add("abc2");
c1.add("abc3");
// 给c2添加元素。
c2.add("abc1");
c2.add("abc2");
c2.add("abc4");
//演示addAll
c1.addAll(c2);//将c2中的元素添加到c1中。
System.out.println(c1);//[abc1, abc2, abc3, abc1, abc2, abc4]
// 演示removeAll
boolean b = c1.removeAll(c2);//将两个集合中的相同元素从调用removeAll的集合中删除。
System.out.println("removeAll:"+b);//true
System.out.println(c1);//[abc3]
// 演示containsAll
boolean b2 = c1.containsAll(c2);
System.out.println("containsAll:"+b2);//false
// 演示retainAll
c2.add("abc3");//c1通过removeAll已经只剩abc3了。c2加一个以演示下面方法
boolean b3 = c1.retainAll(c2);// 取交集，保留和指定的集合相同的元素，而删除不同的元素。
// 和removeAll功能相反 。
System.out.println("retainAll:" + b3);//true
System.out.println("c1:" + c1);//[abc3]
}5, get
int size ():
Iterator iterator ():
public class DJ_IteratorDemo {
public static void main(String[] args) {
Collection coll = new ArrayList();
coll.add("abc1");
coll.add("abc2");
coll.add("abc3");
coll.add("abc4");
System.out.println(coll); //[abc1, abc2, abc3, abc4]
//使用了Collection中的iterator()方法。 调用集合中的迭代器方法，是为了获取集合中的迭代器对象。
Iterator it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next()); //类似指针，一开始指向第一个，然后往下指
}
for(Iterator it2 = coll.iterator(); it.hasNext(); ){//优点：若迭代器用过以后就不用了，这种方法能省一点内存
System.out.println(it.next());
}
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());
// System.out.println(it.next());//java.util.NoSuchElementException
}
}
carte Interface
Ainsi, le même ordre d'idées, les interfaces carte devrait également fonctionner comme « tableau associatif » besoin. Qu'est-ce? regard CRUD ~
1, solubiliser
mis en valeur (clé, valeur): valeur d'une clé associée et, avant de retourner null si aucun.
putAll vide (Map <? étend K, étend V> m);
2, perforer
clear () vide: Vide ensemble de la carte.
supprimer la valeur (clé): Cette paire de valeurs de clé sort en fonction de la clé spécifiée.
3, le changement
default V replace(K key, V value);
default boolean replace(K key, V oldValue, V newValue)4, 判断
containsKey booléen (clé):
containsValue boolean (valeur):
isEmpty () boolean;
5, pour obtenir.
get (clé) Valeur: Obtenir les valeurs clés, sinon la clé pour revenir nulle.
int size (): Obtenir le nombre de paires de valeurs de clé.
booléen containsKey (touche Object); Carte est inclus dans cette clé
booléenne containsValue (Object value), ce qui est inclus dans la carte Valeur
public class DJ_MapDemo {
public static void main(String[] args) {
Map<Integer, String> map=new HashMap<Integer, String>();
method(map);
}
public static void method(Map<Integer,String> map) {
//添加元素
System.out.println(map.put(8, "caidj"));//null
System.out.println(map.put(8, "chenp")); //caidj 存相同键，系统会覆盖
map.put(5, "value5");
map.put(2, "value2");
System.out.println(map);//{2=value2, 5=value5, 8=chenp}
System.out.println("******************");
//删除元素
System.out.println("remove:"+map.remove(2));//remove:value2
System.out.println(map);//{5=value5, 8=chenp}
System.out.println("******************");
//判断
System.out.println("containskey:"+map.containsKey(5));
System.out.println("******************");//containskey:true
System.out.println("get:"+map.get(5));//get:value5
}
}public class DJ_MapDemo {
public static void main(String[] args) {
Map<Integer, String> map=new HashMap<Integer, String>();
method_2(map);
}
public static void method_2(Map<Integer, String> map) {
map.put(8,"zhaoliu");
map.put(2,"zhaoliu");
map.put(7,"xiaoqiang");
map.put(6,"wangcai");
//取出map中所有的元素
//法一：
//原理：通过keySet方法获取map中所有的键所在的Set集合，通过set的迭代器获取每一个键
//再对每一个键获取其对应的值即可
Set<Integer> keySet = map.keySet();
Iterator<Integer> iterator = keySet.iterator();
while(iterator.hasNext()) {
Integer keySet1 =iterator.next();
String string=map.get(keySet1);
System.out.println(keySet1+":"+string);
}
/*法二：entrySet
* 通过Map转成set就可以迭代。
* 该方法将键和值的映射关系作为对象存储到了Set集合中，而这个映射关系的类型就是Map.Entry(类型)
*/
/*
* Set<Map.Entry<Integer, String>> entrySet =map.entrySet();
* Iterator<Map.Entry<Integer, String>> iterator2=entrySet.iterator();
while(iterator2.hasNext()) {
Map.Entry<Integer, String> me = iterator2.next();
Integer key = me.getKey();
String value = me.getValue();
System.out.println(key+"::::"+value);
}
*/
}
}
