Colección: solo se pueden almacenar objetos, los tipos de objetos pueden ser diferentes y la longitud puede ser variable.
Interfaces y clases de uso común:
1. Interfaz de lista (ordenada y repetible): ArrayList Class, LinkedList, Vector Clase
2. Establezca la interfaz (desordenada, no se puede repetir): clase hashset, clase de árbol de árboles
3. Interfaz de mapa (pares de valor clave, solo llave, valor no único): clase hashmap, clase hashtable, clase Treemap
Traversal de bucle de clases de recolección
1. Ordinario para bucle: como para (int i = 0; i <arr.size (); i ++) {...}
2. Foreach (mejorado para bucle): como para (objeto i: arr) {...}
3. Iterador (iterador): por ejemplo, iterator it = arr.iterator (); while (it.hasnext ()) {objeto o = it.next (); …}
Nota: Las matrices o colecciones no se pueden modificar durante el recorrido, mientras que para los bucles se pueden modificar durante el recorrido.
La diferencia entre ArrayList, LinkedList y Vector
ArrayList: alta eficiencia, utilizada principalmente para consultar
LinkedList: se usa principalmente para inserción y eliminación
Vector: a prueba de hilos, se usa principalmente para consultar
Código:
import java.util.arrayList; import java.util.iterator; import java.util.linkedList; import java.util.list; import java.util.vector; public class Listest {public static void main (string [] args) {list indic. Vector (); arrayList.add ("1"); // Tipo de personaje ArrayList.Add ("1"); // Repita el elemento ArrayList.Add ("2"); ArrayList.Add (1); // Tipo de número LinkedList.add ("" 1 "); LinkedList.add (" 1 "); LinkedList.add (" 2 "); LinkedList.add (1); vector.add (" 1 "); vector.add (" 1 "); vector.add (" 2 "); vector.add (1); para (object obj: arsaylist) System.out.println (obj);} for (int i = 0; i <linkedList.size (); i ++) {// ordinario para bucle system.out.println (arrayList.get (i));} iterator it = vector.iterator (); // iterator while (it.hasnext ()) {object j = it.next (); system.out.println (j);}}}La diferencia entre hashset y árbol de árboles
Hashset: Hashset es implementado por una tabla hash. Los datos en el hashset están desordenados. Puedes poner nulo, pero solo puedes poner uno nulo.
TreeSet: Treeset es implementado por un árbol de dos diferencias. Los datos en TreeSet se clasifican automáticamente y no se permite colocar los valores nulos.
Código:
public class settest {public static void main (string [] args) {set hashset = new Hashset (); set treeSet = new TreeSet (); Hashset.add ("1"); // Tipo de personaje Hashset.add ("1"); // repetir elemento hashset.add ("2"); hashset.add (1); // Tipo de número TreeSet.add ("1"); TreeSet.add ("1"); TreeSet.add ("2"); //treeset.add(1); // Informe de error, TreeSet no puede agregar diferentes tipos de datos para (Object I: Hashset) {// foreach loop system.out.println (i);} iterator it = treeSet.iterator (); // iterator while (it.hasnext ()) {object j = it.next (); system.out.println (j);}}}Nota: La interfaz SET no tiene un método GET, por lo que no puede usar un bucle normal para atravesar.
La diferencia entre hashmap, hashtable y treemap
Hashmap: Hashmap permite una tecla nula y múltiples valores nulos
Hashtable: la clave y el valor de la hashtable no pueden ser nulos
Treemap: puede ordenar los registros que guarda según la clave. Por defecto, se clasifica en orden ascendente de valores clave. También puede especificar el comparador ordenado. Cuando está atravesado con iterador, los registros obtenidos están ordenados.
Código:
import java.util.hashmap; import java.util.hashtable; import java.util.iterator; import java.util.map; import java.util.set; import java.util.Treemap; public class maptest {public static main (string [] args) Hashtable (); map areemap = new TreeMap (); Hashmap.put (1, "1"); // Valor de tipo de personaje Hashmap.put (2, "1"); // el mismo valor hashmap.put (3, "2"); hashmap.put (4, 1); // El valor de tipo numérico hashmap.put ("5", 1); // La clave de tipo de caracteres hashtable.put (1, "1"); Hashtable.put (2, "1"); Hashtable.put (3, "2"); Hashtable.put (4, 1); Hashtable.put ("5", 1); Treemap.put (1, "1"); TemeP.put (2, "1"); Treemap.put (5, "2"); Treemap.put (4, 1);//Treemap.); Treemap.put (5, "2"); Treemap.put (4, 1);//Treemap.put ("5", Treemap.put (5, "2"); Treemap.put (4, 1);//Treemap. 1); Treemap.put (1, "1"); Treemap.put (2, "1"); Treemap.put (5, "2"); Treemap.put (4, 1); // Treemap.put ("5", 1); // Se informa un error, TreeMap no puede agregar diferentes tipos de claves // clave de hashmap transip para (clave de objeto: hashmap.keyset ()) {system.out.println (key);} // valor de transip hashtable para (valor de objeto: hashtable.values ()) {system.println (valor);} // key keyshmap set set = = hashmap.keyset (); for (iterator iter = set.iterator (); iter.hasnext ();) {objeto key = iter.next (); objeto valor = hashmap.get (key); system.out.println (key+"/t"+valor);} // pares de valores de llave de keyshttttttttttttttttTTATA iterativamente! Tabla iterator = hashtable.entryset (). Iterator (); while (table.hasnext ()) {map.entry entry = (map.entry) table.next (); Key de objeto = Entry.getKey (); // Obtener valor de objeto clave = entry.getValue (); // Obtener el valor System.out.println (clave+"/t"+valor); } // iterativamente Traverse TreeMap Key-Value Par iterator tmp = treemap.EntrySet (). Iterator (); while (tmp.hasnext ()) {map.entry entry = (map.entry) tmp.next (); Key de objeto = Entry.getKey (); // Obtener valor de objeto clave = entry.getValue (); // Obtener el valor System.out.println (clave+"/t"+valor); }}}Las clases sobre la seguridad del hilo incluyen: Vecto, Hashtabl, StringBuffe
Seguridad sin subprocesos: ArrayList, LinkedList, Hashmap, Hashset, Treemap, TreeSet, StringBulider
Nota: Concurrenthashmap se puede usar en lugar de hashmap para la seguridad de los subprocesos y es más eficiente que el hashtable.
El propio mecanismo de Java no puede garantizar completamente la seguridad de los subprocesos. Necesita codificarlo y controlarlo usted mismo.