Comment faire l’union, intersecter, différencier et inverser les données en Java

Je veux avoir des opérations d’union, d’intersection, de différence et d’inversion en Java.

J’ai d’abord 2 instances de ArrayList

 a = [0,2,4,5,6,8,10] b = [5,6,7,8,9,10] 

une union b devrait renvoyer c = [0,2,3,4,5,6,7,8,9,10]

une intersection b devrait renvoyer c = [5,8,10]

une defference b devrait renvoyer c = [0,2,3,4]

inverser a = [10,8,6,5,4,2,0]

Quelque chose comme ça.

Comment implémenter cette méthode en Java?


Mise à jour : je dois commencer par ce modèle:

 package IntSet; import java.util.ArrayList; import java.util.Collection; public class IntSet { private ArrayList intset; public IntSet(){ intset = new ArrayList(); } public void insert(int x){ intset.add(x); } public void remove(int x){ //implement here intset.indexOf(x); } public boolean member(int x){ //implement here return true; } public IntSet intersect(IntSet a){ //implement here return a; } public IntSet union(IntSet a){ //implement here return a; } public IntSet difference(IntSet a){ //implement here IntSet b = new IntSet(); return b; } 

 //Union List c = new ArrayList(a.size() + b.size()); addNoDups(c,a); addNoDups(c,b); private void addNoDups(List toAddTo,List iterateOver) { for(Integer num:iterateOver){ if(toAddTo.indexOf(num) == -1) { toAddTo.add(num); } } } //intersection List c = new ArrayList (a.size() > b.size() ?a.size():b.size()); c.addAll(a); c.retainAll(b); //difference ab List c = new ArrayList (a.size()); c.addAll(a); c.removeAll(b); 

Tout d’abord, les opérations que vous décrivez (sauf inverser) sont des opérations définies, pas des opérations de liste, utilisez donc HashSet ou (si vous avez besoin d’une commande) TreeSet.

  Set a = new TreeSet(Arrays.asList(new Integer[]{0,2,4,5,6,8,10})); Set b = new TreeSet(Arrays.asList(new Integer[]{5,6,7,8,9,10})); //union Set c = new TreeSet(a); c.addAll(b); System.out.println(c); //intersection Set d = new TreeSet(a); d.retainAll(b); System.out.println(d); //difference Set e = new TreeSet(a); e.removeAll(b); System.out.println(e); //reverse List list = new ArrayList(a); java.util.Collections.reverse(list); System.out.println(list); 

Si vous utilisez Sets (comme vous devriez le faire, pour toutes les opérations excepté reverse, Set), Guava fournit ces opérations dans sa classe Sets .

 Set union = Sets.union(set1, set2); Set intersection = Sets.intersection(set1, set2); Set difference = Sets.difference(set1, set2); 

Tous ces éléments renvoient des vues non modifiables, soutenues par les jeux d’origine.

Voir Guava Explained -> Utilitaires de collecte -> Ensembles

Si les listes sont ce que vous avez, vous pouvez les convertir en un ensemble en utilisant le constructeur de copie présent dans toutes les collections standard:

 List list = new ArrayList<>(); // fill up list here Set set = new HashSet<>(list); 

Un grand nombre de réponses vous indiquent d’utiliser des bibliothèques qui feront le travail pour vous. Bien que ce soit la bonne solution pour le monde réel, gardez à l’esprit que vous faites vos devoirs, et que votre enseignant veut probablement que vous compreniez comment les fonctions sont écrites, et pas seulement comment trouver des bibliothèques pour faire le travail pour vous.

Cela dit, vous avez un bon départ avec le code que vous avez montré. Prenons le problème une étape à la fois.

Tout d’abord, savez-vous où se trouve la documentation Java? http://download.oracle.com/javase/1.4.2/docs/api/ ceci est essentiel, car c’est de cette manière que vous découvrez quelles fonctions font quoi. Voici le lien vers Java 1.4. Je n’ai pas remarqué quelle version vous utilisez, mais Java est rétrocompatible, donc cela devrait être suffisant.

Dans la documentation, recherchez l’entrée ArrayList.

Maintenant que nous avons les documents de l’API, nous devons ventiler votre question. vous avez posté du code, alors je vais le traiter par fonction.

insert (): faut-il avoir une liste ordonnée ou la commande n’a-t-elle pas d’importance? Ou êtes-vous assuré que des valeurs vous seront fournies dans l’ordre? Avez-vous déjà appris les algorithmes de sorting?

remove (): cette fonction ne fonctionne pas. jetez un oeil à l’API ArrayList et voyez comment supprimer un élément de la liste. Utilisez cette méthode.

member (): votre méthode membre ne fonctionne pas. Vous devez vérifier chaque entrée de la liste et déterminer si le membre actuel correspond à l’argument de fonction. Avez-vous appris pour les boucles?

intersect (): ok, dites-moi en anglais ce que l’intersection est censée faire. N’utilisez pas la description de l’enseignant si vous pouvez l’aider – utilisez vos propres mots (notez aux autres: ceci est un exercice pour que le PO apprenne à programmer, alors ne vous en rendez pas compte)

difference (): encore une fois, dites-moi en anglais ce qu’il est censé faire.

reverse (): encore une fois, donnez-moi la description en anglais de ce que cela est censé faire.

Une fois que vous avez des descriptions en anglais, décrivez un algorithme qui peut faire le travail. ne l’écrivez pas encore en Java. Il suffit d’écrire un algorithme, en anglais, décrivant comment vous feriez le travail avec un stylo et du papier.

à ce stade, essayez de convertir l’algorithme en code Java.

Cet extrait trouvera l’union de deux collections en utilisant la méthode apache commons CollectionUtils.union

 Collection totalFriends = CollectionUtils.union(yourFriends, myFriends); 

Je vais juste le laisser ici. Il y a une nouvelle façon avec java-8 et les streams

 List listA = Arrays.asList(0, 2, 4, 5, 6, 8, 10); List listB = Arrays.asList(5, 6, 7, 8, 9, 10); List intersection = listA.stream() .filter(listB::contains) .collect(Collectors.toList()); List union = Stream.concat(listA.stream(), listB.stream()) .distinct().sorted() .collect(Collectors.toList()); List aDiffB = listA.stream() .filter(i -> !listB.contains(i)) .collect(Collectors.toList()); System.out.println(intersection); // [5, 6, 8, 10] System.out.println(union); // [0, 2, 4, 5, 6, 7, 8, 9, 10] System.out.println(aDiffB); // [0, 2, 4]