En términos generales, las estructuras de datos en los libros de texto incluyen matrices, listas vinculadas únicas, pilas, árboles y gráficos. La estructura de datos a la que me refiero aquí es una cuestión de cómo representar un objeto. A veces, una sola declaración variable es inútil, como int, string, doble o incluso matrices unidimensionales y matrices bidimensionales no pueden expresar completamente lo que desea expresar, y es demasiado problemático para definir una clase de clase. En este momento, puede considerar usar la clase de colecciones en Java. Usando la clase de colecciones, debe declarar import java.util.* En el encabezado del archivo;
1. Vector de matriz unidimensional dinámico, ordenado, de tamaño variable y ArrayList
La clase de colecciones incluye vector de matriz unidimensional dinámico, ordenado y de tamaño variable.
La única diferencia entre Vector y ArrayList es: Vector viene con hilos mutuamente excluyentes, y múltiples hilos lanzarán excepciones para leer y escribir, mientras que ArrayList permite que múltiples hilos lean y escriban, y las otras partes son exactamente las mismas. En otras palabras, si un solo hilo está leyendo y escribiendo, no hay diferencia entre el uso de Vector y ArrayList, pero ahora la programación es básicamente ArrayList, y el uso de Vector no es un poco convencional.
1. El uso de vector es el siguiente:
public static void vectortest () {// vector <ouble> significa que este vector solo puede almacenar el doble // vector <string> significa que este vector solo puede almacenar cadena // aunque vector <ject> vector = new vector <sest> (); es equivalente a vector vector = new // vector (); Sin embargo, escribir esto en Eclipse le advertirá, lo que indica que su vector no está estandarizado, () vector <ject> vector = new Vector <Sect> (); vector.add (1.6); vector.add (2.06); vector.add (1); System.out.println ("Agregar simple significa agregar elementos desde el final:" + vector); System.out.println ("size () puede encontrar el número de elementos contenidos en vector:" + vector.size ()); vector.remove (1); System.out.println ("eliminar (1) significa eliminar el primer elemento, porque el recuento comienza desde 0, es decir, el elemento 2.06:" + vector); vector.remove (vector.lastelement ()); System.out.println ("El vector que elimina el último elemento es:" + vector); vector.add (0, 1.8888); System.out.println ("Agregue 1.8888 este elemento en la posición 0:" + vector); vector.set (0, "A"); System.out.println ("Cambie la posición 0:" + vector); } Si se llama a este método en la función principal:
System.out.println ("======== Prueba de inicio de la estructura de datos vectoriales ============"); Vectortest (); System.out.println ("======== Test Fin de la estructura de datos vectoriales ==============); Los resultados de la operación son los siguientes:
======= Prueba de inicio de la estructura de datos vectoriales ======
Un simple agregar significa agregar elementos desde el final: [1.6, 2.06, 1]
size () puede encontrar el número de elementos contenidos en el vector: 3
Eliminar (1) significa eliminar el primer elemento. Dado que el recuento comienza desde 0, es decir, el elemento 2.06: [1.6, 1]
El vector que elimina el último elemento es: [1.6]
Agregue el elemento 1.8888 en la posición 0: [1.8888, 1.6]
Cambie el elemento en la posición 0 a A: [A, 1.6]
======== Test End de la estructura de datos de vector ======
2. Arraylist
public static void ArrayListTest () {ArrayList <Obene> ArrayList = new ArrayList <SowoL> (); ArrayList.Add (1.0); ArrayList.Add (4.0); ArrayList.Add (5.0); ArrayList.Add (2.3); System.out.println ("Agregar simple significa agregar elementos desde el final:" + arrayList); System.out.println ("size () puede encontrar el número de elementos contenidos:" + arrayList.size ()); ArrayList.remove (1); System.out.println ("eliminar (1) significa eliminar el primer elemento. Dado que el recuento comienza desde 0, es decir, el elemento 4:" + ArrayList); ArrayList.remove (ArrayList.Size () - 1); System.out.println ("La ArrayList para eliminar el último elemento es:" + ArrayList); ArrayList.Add (0, 1.8888); System.out.println ("Agregar 1.8888 elemento en la posición 0:" + ArrayList); ArrayList.set (0, 9.0); System.out.println ("Cambie el elemento en la posición 0 a A:" + ArrayList); Colección.sort (ArrayList); System.out.println ("La clasificación es compatible si ArrayList no es un tipo abstracto" + ArrayList); } Aquí puede ver que la forma en que ArrayList elimina el último elemento es diferente de Vector. La razón principal es que ArrayList no tiene el método LastElement () para eliminar el último elemento. Eliminar () solo se puede usar para determinar la posición del último elemento. Si se llama a este método en la función principal como esta:
System.out.println ("========== Prueba de inicio de la estructura de datos de ArrayList ========="); ArrayListTest (); System.out.println ("======== Test Fin de la estructura de datos de ArrayList =================); Luego se obtienen los siguientes resultados de ejecución:
======= Prueba de inicio de la estructura de datos de ArrayList ======
Un simple agregar significa agregar elementos desde el final: [1.0, 4.0, 5.0, 2.3]
size () puede encontrar el número de elementos contenidos: 4
Eliminar (1) significa eliminar el primer elemento. Dado que el recuento comienza desde 0, es decir, el elemento 4: [1.0, 5.0, 2.3]
ArrayList para eliminar el último elemento es: [1.0, 5.0]
Agregue el elemento 1.8888 en la posición 0: [1.8888, 1.0, 5.0]
Cambie el elemento en la posición 0 a A: [9.0, 1.0, 5.0]
Si ArrayList no es un tipo abstracto, la clasificación es compatible [1.0, 5.0, 9.0]
======== Fin de la estructura de datos de ArrayList ======
De los dos ejemplos anteriores, podemos ver que Vector y ArrayList son más que una matriz ordinaria, es decir, la matriz unidimensional enseñada en el libro de texto int Array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; Es mucho más poderoso. Puede insertar elementos en cualquier posición, o puede eliminar elementos en una posición especificada sin atravesar la matriz. Por supuesto, aún necesita saber cómo se atraviesa esta matriz para usted. De hecho, las matrices unidimensionales ordinarias y de matriz se pueden transformar por completo, y ArrayList también se puede usar para ordenar la matriz directamente sin escribir un tipo de burbuja en la matriz. Puede ordenar la matriz directamente con Collections.sort (); y luego use colección.reverse (); Para lograr la clasificación inversa. Por supuesto, sigue siendo la misma oración. Para usted, aún necesita saber cómo se ordene esta matriz.
Por ejemplo, el siguiente método implementa la clasificación y la clasificación inversa de la matriz de matriz unidimensional [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; Primero convierta la matriz en ArrayList y luego ordenela con Collections.sort (); y colección.reverse ();,, y finalmente convierta el contenido de ArrayList en una matriz unidimensional:
public static void arrayListsort () {int Array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; ArrayList <Integer> ArrayList = new ArrayList <Integer> (); para (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); para (int i = 0; i <array.length; i ++) arrayList.add (array [i]); Colección.sort (ArrayList); para (int i = 0; i <array.length; i ++) arrayList.add (array [i]); Colección.sort (ArrayList); para (int i = 0; i <array.length; i <array.length; i ++) arrayList.add (array [i]); Colección.sort (ArrayList); para (int i = 0; i <array.length; i <array.length; i ++) arrayList.add (array [i]); Colección.sort (ArrayList); para (int i = 0; i <array.length; i ++) array [i] = arrayList.get (i); System.out.print ("Array ordenado:"); para (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); Colección.reverse (ArrayList); para (int i = 0; i <array.length; i ++) array [i] = arrayList.get (i); System.out.print ("Array inversamente ordenada:"); para (int i = 0; i <array.length; i ++) system.out.print (array [i]+","); // Destruir la ArrayList después de clasificar. ArrayList = nulo; // Esta oración sugiere que Java recicle la basura de inmediato. Por supuesto, si esta oración está bien o no, Java eliminará automáticamente la basura durante el proceso de ejecución; } En la función principal, el método se llama así:
System.out.println ("=========== Java Array Sort Start inicio =========="); ArrayListsort (); System.out.println ("============== Java Array Sort finaliza ==========); Puede obtener los siguientes resultados de ejecución:
========= Java Array La clasificación de la clasificación de
8,7,100,88,6,4,5,33,7, matriz ordenada: 4,5,6,7,7,8,33,88,100, matriz ordenada inversamente: 100,88,33,8,7,6,5,4,
========= Java Array La clasificación de la clasificación de la clasificación ======
Además, lo mismo es cierto para la anterior "Una breve introducción al uso de la lista en Java" (haga clic para abrir el enlace)
2. Colección hashset
Además, hay un hashset de colección, que es exactamente lo mismo que el concepto de colección matemática. Un conjunto compuesto por uno o más elementos se llama conjunto. Hashset tiene:
1. Determinismo . Los elementos en el conjunto deben ser deterministas. Esto no tiene sentido. Debe ser determinista. ¿Todavía puedo poner algo incierto?
2. Sexo opuesto mutuo , los elementos en el set son diferentes. Por ejemplo: establecer a = {1, a}, entonces A no puede ser igual a 1, es decir, si coloca dos 1 en un hashset, se convertirá automáticamente en un 1
3. Trastorno , no hay orden de elementos en el conjunto. Por lo tanto, hashset no debe realizar operaciones de clasificación, por ejemplo, el siguiente método:
public static void hashsettest () {hashset <pect> hashset = new Hashset <ject> (); hashset.add (1); hashset.add (1); hashset.add (5); hashset.add (2.3); System.out.println ("Agregar simple significa agregar elementos desde el final:" + hashset); System.out.println ("size () puede encontrar el número de elementos contenidos:" + hashset.size ()); hashset.remove (1); System.out.println ("eliminar (1) significa eliminar el elemento '1':" + hashset); Hashset.remove ("ASD"); System.out.println ("Si no hay elemento 'ASD', eliminar no hacer nada:" + hashset); Hashset.add (1.8888); System.out.println ("Agregar 1.8888 elemento:" + hashset); }En la función principal, llame a este método:
System.out.println ("========== Prueba de inicio de la estructura de datos hashset ========="); Hashsettest (); System.out.println ("========= Test Fin de la estructura de datos hashset =================); Los resultados son los siguientes:
======= La prueba comienza con la estructura de datos hashset ======
Un simple agregar significa agregar elementos desde el final: [1, 5, 2.3]
size () puede encontrar el número de elementos contenidos: 3
Eliminar (1) significa eliminar el elemento '1': [5, 2.3]
Sin el elemento 'ASD', eliminar no hace nada: [5, 2.3]
Agregue el elemento 1.8888: [5, 1.8888, 2.3]
========= Test Fin de la estructura de datos hashset ======
Hashset tiene el método add () y el método remove (). Los elementos agregados a add () están en orden. Los resultados impresos con System.out.println () pueden estar en diferentes órdenes. No pueden ser lo mismo que el vector y la lista de matrices de arriba. Mientras los elementos almacenados no sean objetos, colección.sort (ArrayList); se puede usar para ordenarlos.
3. HASHMAP dual
El método de uso aquí es básicamente el mismo que los datos anteriores, y también es muy simple. Es para poner el objeto en el mapa y obtener puede quitar los objetos en el mapa, pero está mal tratar de usar el hashmap binario en un triple. Si un objeto contiene demasiados elementos, debe considerar usar clases. En lugar de estar obsesionado con la clase de colecciones de Java que interfiere entre variables ordinarias y clases de clase.
Por ejemplo, el siguiente método muestra la operación de error de intentar cambiar HashMap a Triple:
public static void Maptest(){ System.out.println("============ Start of use of Map error==============); HashMap<String,String> map=new HashMap<String, String>(); HashMap<String,HashMap<String, String>> bigmap=new HashMap<String, HashMap<String, String >> (); System.out.println (bigMap.get ("test1"). Get ("key1")); System.out.println (bigmap.get ("test2"). Get ("key2")); Incorrectamente ================================================================================================================================================================================================================================================================================================== S ================================================================ ================================================================= ================================================================ ================================================================= ================================================================= ================================================================= Llamar a este código en la función principal proporciona el siguiente resultado de ejecución:
========= La prueba comienza con la estructura de datos del mapa ======
======== Inicio del uso del error del mapa ======
{test1 = {key2 = 4, key1 = 3}, test2 = {key2 = 4, key1 = 3}}
3
4
3
4
======= Fin del uso del error del mapa ======
========= Inicio del uso correcto del mapa ======
{key3 = 3, key2 = 2, key1 = 1}
======== Fin del uso correcto del mapa ======
======== EN FIN DE DATOS DE MAP DE MAP ======
Originalmente, este programa tenía la intención de ser muy obvio, tratando de construir un {test1, key1,1}, {test1, key2,2}, {test2, key3,3}, {test2, key4,4}
Sin embargo, cada BigMap todavía tiene ese mapa. Una vez que borre el mapa, el mapa en Test1 también se borrará. Alguien intentó crear múltiples map1, map2, ... entonces podría usar una clase simple para verse más claro, y puede escribir métodos en la clase en el futuro y ser heredado
4. Notas
Al crear un nuevo vector, ArrayList, Hashset o Hashmap, puede escribirlo como:
Colección <String> a = new ArrayList <String> ();
Lista <String> A = New Vector <String> ();
Debido a que hay ArrayList, Vector, LinkedList, Hashset y Treeset que heredan de la interfaz de colección, y hashmap y hashtable que heredan de la interfaz del mapa, este es un problema de inherencia, polimorfismo, encapsulación y otras clases en Java. Por supuesto, para que sus compañeros vean más claramente, no jueguen con el nombre elegante aquí, escriba un claro ArrayList <integer> arrayList = new ArrayList <Integer> (); Nadie se atreve a decir que no entiendes las clases en Java.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.