De um modo geral, as estruturas de dados nos livros didáticos incluem matrizes, listas vinculadas, pilhas, árvores e gráficos. A estrutura de dados a que estou me referindo aqui é uma questão de como representar um objeto. Às vezes, uma única declaração de variável é inútil, como int, string, matrizes duplas ou até unidimensionais e matrizes bidimensionais, não podem expressar completamente o que você deseja expressar, e é muito problemático definir uma classe de classe. Neste momento, você pode considerar o uso da aula de coleções em Java. Usando a classe de coleções, você deve declarar importar java.util.* No cabeçalho do arquivo;
1. Dinâmico, ordenado, de tamanho variável, vetor de matriz unidimensional e Arraylist
A classe de coleções inclui vetor de matriz unidimensional de tamanho dinâmico, ordenado e de tamanho variável.
A única diferença entre o vetor e o Arraylist é: o vetor vem com threads mutuamente exclusivos, e vários threads lançarão exceções para ler e escrever, enquanto o ArrayList permite que vários threads leiam e escrevam, e as outras partes são exatamente as mesmas. Em outras palavras, se um único thread estiver lendo e escrevendo, não há diferença entre usar o vetor e o Arraylist, mas agora a programação é basicamente Arraylist, e o uso do vetor é um pouco não-mainstream.
1. O uso do vetor é o seguinte:
public static void vectTorTest () {// Vector <blus> significa que esse vetor pode armazenar apenas duplo // vetor <string> significa que esse vetor pode armazenar apenas string // embora o vetor <ject> vetor = new vetor <ject> (); é equivalente ao vetor vetor = new // vetor (); No entanto, escrever isso no Eclipse avisará você, indicando que seu vetor não está padronizado, () vetor <ject> vetor = new Vector <ject> (); vetor.add (1.6); vetor.add (2.06); vetor.add (1); System.out.println ("Simples Add significa adicionar elementos do final:" + vetor); System.out.println ("size () pode encontrar o número de elementos contidos no vetor:" + vetor.size ()); vetor.remove (1); System.out.println ("Remover (1) significa excluir o primeiro elemento, porque a contagem começa em 0, ou seja, o elemento 2.06:" + vetor); Vector.Remove (Vector.LASTELEMENT ()); System.out.println ("O vetor que exclui o último elemento é:" + vetor); vetor.add (0, 1.8888); System.out.println ("Adicione 1.8888 Este elemento na posição 0:" + vetor); vetor.set (0, "A"); System.out.println ("Altere a posição 0:" + vetor); } Se este método for chamado na função principal:
System.out.println ("======== Teste Início da estrutura de dados vetoriais ==========="); VectorTest (); System.out.println ("======== Teste final da estrutura de dados vetoriais =============); Os resultados da operação são os seguintes:
======= Teste Início da estrutura de dados vetoriais =======
Um adicional simples significa adicionar elementos do final: [1.6, 2.06, 1]
tamanho () pode encontrar o número de elementos contidos no vetor: 3
Remova (1) significa excluir o primeiro elemento. Como a contagem começa em 0, ou seja, o elemento 2.06: [1.6, 1]
O vetor que exclui o último elemento é: [1.6]
Adicione o elemento 1.8888 na posição 0: [1.8888, 1.6]
Altere o elemento na posição 0 para a: [a, 1.6]
======== Teste final da estrutura de dados vetoriais =======
2. Arraylist
public static void ArrayListTest () {ArrayList <Houble> ArrayList = new ArrayList <Houble> (); ArrayList.add (1.0); ArrayList.add (4.0); ArrayList.add (5.0); ArrayList.add (2.3); System.out.println ("Simples Add significa adicionar elementos do final:" + ArrayList); System.out.println ("size () pode encontrar o número de elementos contidos:" + ArrayList.size ()); ArrayList.Remove (1); System.out.println ("Remover (1) significa excluir o primeiro elemento. Como a contagem começa em 0, ou seja, o elemento 4:" + ArrayList); ArrayList.Remove (ArrayList.size () - 1); System.out.println ("O ArrayList para excluir o último elemento é:" + ArrayList); ArrayList.add (0, 1.8888); System.out.println ("Adicione 1.8888 elemento na posição 0:" + ArrayList); ArrayList.set (0, 9.0); System.out.println ("Altere o elemento na posição 0ª para A:" + ArrayList); Coleções.sort (Arraylist); System.out.println ("A classificação é suportada se o ArrayList não for um tipo abstrato" + ArrayList); } Aqui você pode ver que a maneira como a lista de Arrays exclui o último elemento é diferente do vetor. O principal motivo é que o ArrayList não possui o método lastElement () para remover o último elemento. Remover () só pode ser usado para determinar a posição do último elemento. Se este método for chamado na função principal como esta:
System.out.println ("========= Teste Início da estrutura de dados ArrayList ========="); ArrayListTest (); System.out.println ("======== Teste final da estrutura de dados ArrayList ======================;); Em seguida, são obtidos os seguintes resultados em execução:
======= Teste Início da estrutura de dados Arraylist =======
Um adicional simples significa adicionar elementos do final: [1.0, 4.0, 5.0, 2.3]
tamanho () pode encontrar o número de elementos contidos: 4
Remova (1) significa excluir o primeiro elemento. Desde que a contagem começa em 0, ou seja, o elemento 4: [1.0, 5.0, 2.3]
A lista de Array para excluir o último elemento é: [1.0, 5.0]
Adicione o elemento 1.8888 na posição 0: [1.8888, 1.0, 5.0]
Altere o elemento na posição 0 para A: [9.0, 1.0, 5.0]
Se a Arraylist não for um tipo abstrato, a classificação é suportada [1.0, 5.0, 9.0]
======== Teste final da estrutura de dados Arraylist =======
A partir dos dois exemplos acima, podemos ver que o vetor e o Arraylist são mais do que uma matriz comum, ou seja, a matriz unidimensional ensinada no livro intray int [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; É muito mais poderoso. Você pode inserir elementos em qualquer posição ou excluir elementos em uma posição especificada sem atravessar a matriz. Obviamente, você ainda precisa saber como essa matriz é atravessada para você. De fato, as matrizes unidimensionais de Arraylist e comuns podem ser completamente transformadas, e o ArrayList também pode ser usado para classificar a matriz diretamente sem escrever uma espécie de bolha na matriz. Você pode classificar a matriz diretamente com as coleções.sort (); e então use coleções.Reverse (); para obter classificação inversa. Claro, ainda é a mesma frase. Para você, você ainda precisa saber como essa matriz é classificada.
Por exemplo, o método a seguir implementa a classificação e a classificação inversa da matriz unidimensional Int Array [] = {8, 7, 100, 88, 6, 4, 5, 33, 7}; Primeiro converta a matriz em ArrayList e depois classifique -a com coleções.sort (); e coleções.Reverse ();, e finalmente converte o conteúdo da Arraylist de volta a uma matriz unidimensional:
public static void ArrayListSort () {int matriz [] = {8, 7, 100, 88, 6, 4, 5, 5, 33, 7}; ArrayList <Teger> ArrayList = new ArrayList <Teger> (); for (int i = 0; i <Array.Length; i ++) System.out.print (Array [i]+","); for (int i = 0; i <Array.Length; i ++) ArrayList.add (Array [i]); Coleções.sort (Arraylist); for (int i = 0; i <Array.Length; i ++) ArrayList.add (Array [i]); Coleções.sort (Arraylist); for (int i = 0; i <Array.Length; i <Array.Length; i ++) ArrayList.add (Array [i]); Coleções.sort (Arraylist); for (int i = 0; i <Array.Length; i <Array.Length; i ++) ArrayList.add (Array [i]); Coleções.sort (Arraylist); for (int i = 0; i <Array.Length; i ++) Array [i] = ArrayList.get (i); System.out.print ("Array classificado:"); for (int i = 0; i <Array.Length; i ++) System.out.print (Array [i]+","); Coleções.Reverse (Arraylist); for (int i = 0; i <Array.Length; i ++) Array [i] = ArrayList.get (i); System.out.print ("Array inversamente classificada:"); for (int i = 0; i <Array.Length; i ++) System.out.print (Array [i]+","); // Destrua o Arraylist depois de classificar. ArrayList = null; // Esta frase sugere que Java Recicle o lixo imediatamente. Obviamente, se essa frase está bem ou não, o Java removerá automaticamente o lixo durante o processo de execução; } Na função principal, o método é chamado assim:
System.out.println ("========== Java Array STRIPE =========="); ArrayListsort (); System.out.println ("============= Java Array Classificação termina ==========); Você pode obter os seguintes resultados em execução:
======== Java Classificação da matriz inicia =======
8,7,100,88,6,4,5,33,7, matriz classificada: 4,5,6,7,7,8,33,88,100, matriz invertida invertida: 100,88,33,8,7,7,6,5,
========== Java Classificação de triagem =======
Além disso, o mesmo vale para a anterior "Uma breve introdução ao uso da lista em java" (clique para abrir o link)
2. Coleção Hashset
Além disso, existe um hashset de coleção, que é exatamente o mesmo que o conceito de coleção matemática. Um conjunto composto por um ou mais elementos é chamado de conjunto. Hashset tem:
1. Determinismo . Os elementos no conjunto devem ser determinísticos. Isso não faz sentido. Deve ser determinístico. Ainda posso colocar uma coisa incerta?
2. Sexo oposto mútuo , os elementos do conjunto são diferentes. Por exemplo: set a = {1, a}, então a não pode ser igual a 1, ou seja, se você colocar dois 1s em um hashset, ele se tornará automaticamente um 1
3. Transtorno , não há ordem de elementos no conjunto. Portanto, o hashset não deve executar operações de classificação, por exemplo, o seguinte método:
public static void hashSetTest () {hashset <ject> hashSet = new HashSet <ject> (); hashset.add (1); hashset.add (1); hashset.add (5); hashset.add (2.3); System.out.println ("Simples Add significa adicionar elementos do final:" + hashset); System.out.println ("size () pode encontrar o número de elementos contidos:" + hashset.size ()); Hashset.Remove (1); System.out.println ("remover (1) significa excluir o elemento '1':" + hashset); hashset.Remove ("ASD"); System.out.println ("Se não houver elemento 'ASD', remova nada:" + hashset); hashset.add (1.8888); System.out.println ("Adicionar 1.8888 elemento:" + hashset); }Na função principal, chame este método:
System.out.println ("========= Teste Início da estrutura de dados do hashset ========="); HashSetTest (); System.out.println ("========= Teste final da estrutura de dados do hashset =================); Os resultados são os seguintes:
======= O teste começa com a estrutura de dados de hashset =======
Um adicional simples significa adicionar elementos do final: [1, 5, 2.3]
tamanho () pode encontrar o número de elementos contidos: 3
Remova (1) significa excluir o elemento '1': [5, 2.3]
Sem o elemento 'ASD', remova nada: [5, 2.3]
Adicione o elemento 1.8888: [5, 1.8888, 2.3]
======== Teste final da estrutura de dados de hashset =======
Hashset possui o método add () e o método remove (). Os elementos adicionados para add () estão em ordem. Os resultados impressos com system.out.println () podem estar em pedidos diferentes. Eles não podem ser os mesmos que o vetor e o Arraylist acima. Enquanto os elementos armazenados não forem objetos, coleções.Sort (ArrayList); pode ser usado para classificá -los.
3. Hashmap dual
O método de uso aqui é basicamente o mesmo que os dados acima e também é muito simples. É colocar o objeto no mapa e obter pode tirar os objetos no mapa, mas é errado tentar usar o hashmap binário em um triplo. Se um objeto contiver muitos elementos, considere usar as classes. Em vez de ficar obcecado com a classe de coleções de Java, que está interferindo entre variáveis comuns e classes de classe.
Por exemplo, o método a seguir mostra a operação de erro de tentar alterar o hashmap para triplicar:
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 >> () Map.put (Key1 "," 1 "); System.out.println (bigmap.get ("test1"). Get ("key1")); System.out.println (bigmap.get ("test2"). Get ("key2")); incorrectly================================================================================================================ =============================================================== ================================================================ =============================================================== ================================================================ ================================================================ ================================================================ Chamar esse código na função principal fornece o seguinte resultado de execução:
======== O teste começa com a estrutura de dados do mapa =======
======== Início do uso do erro do mapa =======
{test1 = {key2 = 4, key1 = 3}, test2 = {key2 = 4, key1 = 3}}
3
4
3
4
======= Fim do uso do erro do mapa =======
========= Início do uso correto do mapa ======
{key3 = 3, key2 = 2, key1 = 1}
======== Fim do uso correto do mapa ======
======== Teste final da estrutura de dados do mapa =======
Este programa foi originalmente destinado a ser muito óbvio, tentando construir um {test1, key1,1}, {test1, key2,2}, {test2, key3,3}, {test2, key4,4}
No entanto, todo BigMap ainda tem esse mapa. Depois de limpar o mapa, o mapa no Test1 também será limpo. Alguém tentou criar vários map1, map2, ... então você pode usar uma classe simples para parecer mais clara, e você pode escrever métodos na classe no futuro e ser herdado
4. Notas
Ao criar um novo vetor, Arraylist, Hashset ou Hashmap, você pode escrever como:
Coleção <string> a = new ArrayList <String> ();
Lista <String> a = new Vector <string> ();
Como existem Arraylist, Vector, LinkedList, Hashset e Treeset que herdam da interface de coleta, e hashmap e hashtable que herdam da interface do mapa, isso é um problema de herança, polimorfismo, encapsulamento e outras classes em Java. Obviamente, para que seus companheiros vejam com mais clareza, não toque a nomeação sofisticada aqui, escreva um ArrayList claro <Integer> ArrayList = new ArrayList <Teger> (); Ninguém ousa dizer que você não entende aulas em Java.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.