1. Por questões de desempenho, os arrays são preferidos
Os arrays são cada vez menos usados no desenvolvimento de projetos, especialmente no desenvolvimento orientado a negócios. Em primeiro lugar, os arrays não possuem muitos métodos fornecidos por coleções, como List e Set. Você mesmo precisa escrever os algoritmos de pesquisa e adição. extremamente complicado e problemático. No entanto, como coleções como List e Set usam suporte genérico, todas elas são armazenadas em classes wrapper e os arrays podem usar tipos de dados básicos. A velocidade de execução dos tipos de dados básicos é muito mais rápida do que a dos tipos de wrapper. e a camada inferior da classe de coleção também é implementada por meio de arrays.
2. Se necessário, use matrizes de comprimento variável
Ao aprender classes de coleção, muitas pessoas gostam de comparar o comprimento fixo do array com o comprimento variável do tipo de coleção, mas na verdade essa comparação não é apropriada. Observando a implementação de classes de coleção como ArrayList, podemos realmente ver que. a chamada coleção se torna mais longa. Na verdade, ela apenas expande o array original com tato.
Copie o código do código da seguinte forma:
public static T[] expandCapacity(T[] dados, int newLength) {
// Determina se é um valor negativo
novoComprimento = novoComprimento < 0 ? 0: novoComprimento;
//Gera um novo array, copia o valor original e especifica o comprimento
retornar Arrays.copyOf(dados, novoComprimento);
}
Quando os requisitos de desempenho são altos, você pode considerar o encapsulamento de arrays. O comprimento constante do array não é uma desculpa para não usá-los.
3. Desconfie de cópias superficiais de arrays
A cópia superficial do array também é a base da programação Java. A cópia superficial significa que ao copiar um array, o tipo básico copia o valor, enquanto o tipo de referência copia o endereço de referência. é uma cópia superficial, então você precisa prestar atenção ao usá-la.
4. Em cenários claros, especifique a capacidade inicial para a coleta
Em nosso uso diário, como o tipo de coleção muda automaticamente de comprimento, o valor inicial não será anexado à classe de coleção ao criar um objeto. Vamos pegar nosso ArrayList mais comumente usado como exemplo. a capacidade é atingida No ponto crítico, a matriz subjacente será A operação copyOf gera um novo array, e a capacidade do novo array é 1,5 vezes maior que a do array antigo, e o comprimento padrão do array é 10. Quando sabemos claramente que a quantidade de dados a serem colocados no contêiner é grande, devemos especificar o valor inicial para evitar sobrecarga excessiva de desempenho causada pelo uso de tempos copyOf
5. Escolha o algoritmo ideal apropriado
Pesquisar o valor máximo ou mínimo dos dados é o conhecimento mais básico da estrutura de dados. Também temos muitas maneiras de implementá-lo em Java.
Copie o código do código da seguinte forma:
public static int getMaxByArray(int[] dados) {
//O método de pesquisa auto-implementado mais simples
int máximo = dados[0];
for (int i = 1, tamanho = data.length; i < tamanho; i++) {
máximo = máximo < eu ?
}
retorno máximo;
}
Copie o código do código da seguinte forma:
public static int getMaxByArray(int[] dados) {
// Classifica primeiro e depois obtém o último bit
Arrays.sort(dados);
retornar dados[data.length - 1];
}
6. Armadilha de conversão de array de tipo básico!
Por favor observe o seguinte código
Copie o código do código da seguinte forma:
public static void main(String[] args) {
int[] nums = new int[] { 1, 2, 3, 4, 5 };
Lista lista = Arrays.asList(nums);
System.out.println(lista.size());
//O tamanho da saída neste momento é 1
}
O resultado que esperávamos era converter os elementos do array em uma classe de coleção por meio de Arrays.asList, mas ao contrário do que esperávamos, apenas adicionamos o próprio array e não separamos os valores no array neste momento. se a coleção Adicionar genéricos à Lista apresentar uma mensagem de erro durante a compilação ou alterar o próprio array para Inteiro pode resolver o problema.
7. O objeto List gerado pelo método asList não pode ser alterado.
Através do exemplo acima, podemos ver que usar o método Arrays.asList pode converter um array em uma Lista. Então, o que há de especial na Lista retornada pelo método asList. Observe que a Lista retornada não suporta alterações porque o método asList retorna? não java.util.ArrayList, mas Array Uma classe interna privada estática na classe de ferramentas s, embora tenha a mesma classe pai AbstractList que ArrayList, mas ao substituir add e outros métodos, uma UnsupportedOperationException é lançada. Esta classe interna privada estática implementa apenas size, toArray, Get, contém estes. métodos
8. Use diferentes métodos de passagem para diferentes estruturas de dados
Por favor, observe o seguinte código
Copie o código do código da seguinte forma:
public static void main(String[] args) {
//A seguir está o método de travessia da coleção ArrayList
número interno = 80 * 10000;
Lista arrayList = new ArrayList(num);
for (int i = 0, tamanho = arrayList.size(); i < tamanho; i++) {
arrayList.get(i);
}
//A seguir está o método de travessia da coleção LinkedList
ListalinkedList = new LinkedList();
for (inteiro inteiro: linkedList) {
}
}
Por que escolher métodos de travessia diferentes para LinkedList e ArrayList?
1. Como ArrayList implementa a interface RamdomAccess (interface de acesso aleatório), a interface RamdomAccess é a mesma interface de marcação em Java que as interfaces Serializable e Cloneable, o que significa que esta classe pode ser acessada aleatoriamente. Para ArrayList, significa que entre os dados Existe. sem correlação, ou seja, duas posições adjacentes não possuem relação de interdependência e podem ser acessadas aleatoriamente.
2. A sintaxe foreach em Java é um uso variante do iterador (iterador). Sabemos que o iterador é um dos 23 padrões de design, mas o iterador precisa saber a relação de tempo entre dois elementos, caso contrário, como fornecer suporte ao hasNext. Isso ocorre porque o elemento anterior precisa determinar se o próximo elemento existe, e esse relacionamento é estabelecido à força, o que viola as características especiais do acesso aleatório ArrayList.
3. No LinkedList, por ser armazenado na forma de uma lista duplamente vinculada, o suporte para iteradores é muito bom. Como há um relacionamento inerente entre dois elementos adjacentes no LinkedList, diferentes métodos de travessia devem ser adotados para LinkedList e ArrayList. Os leitores interessados podem tentar acessar o LinkedList na forma de subscritos e descobrirão que há uma grande lacuna de eficiência entre os dois.
8. Escolha ArrayList ou LinkedList quando apropriado
As principais diferenças entre ArrayList e LinkedList:
1. A estrutura de dados subjacente de ArrayList é uma matriz, enquanto a estrutura subjacente de LinkedList é uma lista duplamente vinculada.
2. Ao inserir dados, como ArrayList precisa mover os elementos da matriz para trás após cada inserção, o LinkedList só precisa alterar o nó principal e o nó final para concluir a operação de inserção, portanto, quando as operações de inserção são mais frequentes, o LinkedList é o preferido.
3. Ao excluir dados, porque ArrayList precisa manter a ordem da matriz, os elementos também precisam ser movidos para trás ou para frente após a exclusão, enquanto LinkedList ainda altera os nós iniciais e finais.
4. Ao atualizar, como o LinkedList usará um método de meia travessia para encontrar o elemento posicionado e, em seguida, atualizá-lo, em comparação com a substituição direta de elementos subscritos posicionados do ArrayList, o ArrayList é mais eficiente na atualização.
5.LinkedList pode simular uma fila por meio de operações como addFirst e addLast do LinkedList.
9. Quando as listas são iguais, você só precisa se preocupar com os dados do elemento
Para que possamos programar interfaces como List, Set e Map com tranquilidade, Java substituiu equlas na classe de coleção, de modo que, ao comparar se duas coleções são iguais, só precisamos comparar se os dados do elemento são iguais Isso evita a correção do código Java incorreto causado pela substituição da classe de implementação da coleção.
Copie o código do código da seguinte forma:
public static void main(String[] args) {
Lista arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
ListalinkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
System.out.println(arrayList.equals(linkedList));
// Não se preocupe com a implementação específica, a saída é verdadeira
}