1. Pour des raisons de performances, les baies sont préférables
Les tableaux sont de moins en moins utilisés dans le développement de projets, en particulier dans le développement orienté métier. Tout d'abord, les tableaux ne disposent pas de nombreuses méthodes fournies par des collections telles que List et Set. Vous devez écrire vous-même les algorithmes de recherche et d'addition. extrêmement fastidieux et gênant.Cependant, étant donné que les collections telles que List et Set utilisent un support générique, elles sont toutes stockées dans des classes wrapper et les tableaux peuvent utiliser des types de données de base. La vitesse d'exécution des types de données de base est beaucoup plus rapide que celle des types wrapper. et la couche inférieure de la classe collection. Elle est également implémentée via des tableaux.
2. Si nécessaire, utilisez des tableaux de longueur variable
Lors de l'apprentissage des classes de collection, de nombreuses personnes aiment comparer la longueur fixe du tableau avec la longueur variable du type de collection, mais en fait, cette comparaison n'est pas appropriée. En observant l'implémentation de classes de collection telles que ArrayList, nous pouvons réellement voir cela. la soi-disant La collection devient plus longue. En fait, elle élargit simplement la gamme originale avec tact.
Copiez le code comme suit :
public static T[] expandCapacity(T[] données, int newLength) {
// Détermine s'il s'agit d'une valeur négative
nouvelleLongueur = nouvelleLongueur < 0 ?
// Génère un nouveau tableau, copie la valeur d'origine et spécifie la longueur
return Arrays.copyOf(data, newLength);
}
Lorsque les exigences de performances sont élevées, vous pouvez envisager d'encapsuler des tableaux. La longueur constante du tableau n'est pas une excuse pour ne pas les utiliser.
3. Méfiez-vous des copies superficielles des tableaux
La copie superficielle d'un tableau est également la base de la programmation Java. La copie superficielle signifie que lors de la copie d'un tableau, le type de base copie la valeur, tandis que le type de référence copie l'adresse de référence. Dans l'exemple ci-dessus, le tableau est copié à l'aide de Arrays.copyOf. est une copie superficielle, vous devez donc faire attention lorsque vous l'utilisez.
4. Dans des scénarios clairs, précisez la capacité initiale de la collecte
Dans notre utilisation quotidienne, comme le type de collection change automatiquement de longueur, la valeur initiale ne sera pas attachée à la classe de collection lors de la création d'un objet. Prenons notre ArrayList le plus couramment utilisé comme exemple. Nous devons d'abord le savoir lors de la collection. capacité est atteinte Au point critique, la baie sous-jacente sera L'opération copyOf génère un nouveau tableau, et la capacité du nouveau tableau est 1,5 fois celle de l'ancien tableau, et la longueur par défaut du tableau est de 10. Lorsque nous savons clairement que la quantité de données à placer dans le conteneur est grande, nous devons spécifier la valeur initiale pour éviter une surcharge de performances excessive causée par l'utilisation des temps copyOf
5. Choisissez l'algorithme optimal approprié
La recherche de la valeur maximale ou minimale des données est la connaissance la plus élémentaire de la structure des données. Nous avons également de nombreuses façons de l'implémenter en Java. Voici deux algorithmes :
Copiez le code comme suit :
public static int getMaxByArray (int[] données) {
//La méthode de recherche auto-implémentée la plus simple
int max = données[0];
pour (int i = 1, taille = data.length; i < taille; i++) {
max = max < je ? je : max;
}
renvoyer maximum ;
}
Copiez le code comme suit :
public static int getMaxByArray (int[] données) {
// Trie d'abord puis récupère le dernier bit
Arrays.sort(données);
renvoyer des données[data.length - 1] ;
}
6. Piège de conversion de tableau de type de base !
Veuillez respecter le code suivant
Copiez le code comme suit :
public static void main (String[] arguments) {
int[] nums = nouveau int[] { 1, 2, 3, 4, 5 };
Liste liste = Arrays.asList(nums);
System.out.println(list.size());
//La taille de sortie à ce moment est 1
}
Le résultat auquel nous nous attendions était de convertir les éléments du tableau en une classe de collection via Arrays.asList, mais contrairement aux attentes, nous avons uniquement ajouté le tableau lui-même et n'avons pas séparé les valeurs dans le tableau pour le moment. si la collection Ajouter des génériques à la liste donnera un message d'erreur lors de la compilation, ou changer le tableau lui-même en Integer peut résoudre le problème.
7. L'objet List généré par la méthode asList ne peut pas être modifié.
Grâce à l'exemple ci-dessus, nous pouvons voir que l'utilisation de la méthode Arrays.asList peut convertir un tableau en liste. Alors, quelle est la particularité de la liste renvoyée par la méthode asList ? Notez que la liste renvoyée ne prend pas en charge les modifications car la méthode asList renvoie ? pas java.util.ArrayList, mais Array Une classe interne privée statique dans la classe d'outils s, bien qu'elle ait la même classe parent AbstractList que ArrayList, mais lors de la substitution de add et d'autres méthodes, une UnsupportedOperationException est levée. Cette classe interne privée statique implémente uniquement size, toArray, Get, les contient. méthodes
8. Utilisez différentes méthodes de parcours pour différentes structures de données
Veuillez regarder le code suivant
Copiez le code comme suit :
public static void main (String[] arguments) {
//Ce qui suit est la méthode de parcours de la collection ArrayList
numéro int = 80 * 10000 ;
Liste arrayList = new ArrayList(num);
pour (int i = 0, size = arrayList.size(); i < size; i++) {
arrayList.get(i);
}
//Ce qui suit est la méthode de parcours de la collection LinkedList
Liste linkedList = new LinkedList();
pour (entier entier : linkedList) {
}
}
Pourquoi choisir différentes méthodes de parcours pour LinkedList et ArrayList ?
1. Étant donné qu'ArrayList implémente l'interface RamdomAccess (interface d'accès aléatoire), l'interface RamdomAccess est la même interface de marquage en Java que les interfaces Serialisable et Cloneable, ce qui signifie que cette classe est accessible de manière aléatoire, pour ArrayList, cela signifie qu'il y a entre les données. aucune corrélation, c'est-à-dire que deux positions adjacentes n'ont aucune relation d'interdépendance et sont accessibles de manière aléatoire.
2. La syntaxe foreach en Java est une variante d'utilisation de l'itérateur (iterator). Nous savons que l'itérateur est l'un des 23 modèles de conception, mais l'itérateur doit connaître la relation temporelle entre deux éléments, sinon comment fournir le support hasNext Quoi ? C'est parce que l'élément précédent doit déterminer si l'élément suivant existe, et cette relation est établie de force, ce qui viole les caractéristiques spéciales de l'accès aléatoire d'ArrayList.
3. Dans LinkedList, parce qu'il est stocké sous la forme d'une liste doublement chaînée, la prise en charge des itérateurs est très bonne. Parce qu'il existe une relation inhérente entre deux éléments adjacents dans LinkedList, différentes méthodes de parcours doivent être adoptées pour LinkedList et ArrayList. Les lecteurs intéressés peuvent essayer d’accéder à LinkedList sous forme d’indices et constateront qu’il existe un grand écart d’efficacité entre les deux.
8. Choisissez ArrayList ou LinkedList le cas échéant
Les principales différences entre ArrayList et LinkedList :
1. La structure de données sous-jacente d'ArrayList est un tableau, tandis que la structure sous-jacente de LinkedList est une liste doublement chaînée.
2. Lors de l'insertion de données, étant donné qu'ArrayList doit déplacer les éléments du tableau vers l'arrière après chaque insertion, LinkedList n'a besoin que de changer le nœud principal et le nœud final pour terminer l'opération d'insertion, donc lorsque les opérations d'insertion sont plus fréquentes, LinkedList est préférable.
3. Lors de la suppression de données, étant donné qu'ArrayList doit conserver l'ordre du tableau, les éléments doivent également être décalés vers l'arrière ou vers l'avant après la suppression, tandis que LinkedList modifie toujours les nœuds de tête et de queue.
4. Lors de la mise à jour, puisque LinkedList utilisera une méthode de demi-traversage pour trouver l'élément positionné puis le mettre à jour, par rapport au remplacement direct par ArrayList des éléments d'indice positionnés, ArrayList est plus efficace dans la mise à jour.
5.LinkedList peut simuler une file d'attente via des opérations telles que addFirst et addLast de LinkedList.
9. Lorsque les listes sont égales, vous n'avez qu'à vous soucier des données des éléments
Afin que nous puissions programmer des interfaces telles que List, Set et Map en toute tranquillité d'esprit, Java a remplacé equlas dans la classe de collection, de sorte que lorsque nous comparons si deux collections sont égales, nous n'avons qu'à comparer si les données des éléments sont égales. .Cela évite Correction du code Java erroné causé par le remplacement de la classe d'implémentation de la collection.
Copiez le code comme suit :
public static void main (String[] arguments) {
Liste arrayList = new ArrayList();
arrayList.add(1);
arrayList.add(2);
Liste linkedList = new LinkedList();
linkedList.add(1);
linkedList.add(2);
System.out.println(arrayList.equals(linkedList));
// Ne vous souciez pas de l'implémentation spécifique, le résultat est vrai
}