Retirez le même nombre d'une liste de tableaux

J'ai créer une méthode qui a une liste de tableaux; j'ai besoin de supprimer des numéros de cette liste de tableaux. J'ai écrit du code, mais il y a une erreur de logique, je ne pouvais pas identifier.

Voici mon code:

static void sortList(){

   List <Integer> number=new ArrayList <Integer>();

   number.add(11);
   number.add(45);
   number.add(12);
   number.add(32);
   number.add(36);

   System.out.println("Unsorted List: "+number);

   for (int i=0;i<number.size();i++){      
       int even=number.get(i)%2;       
        if (even==0){
            System.out.println("This is Even Number:"+ number.get(i));
            number.remove(i);
        }    
    }

    Collections.sort(number);
    System.out.println("Sorted List: "+number);

 }

La sortie du code est:

Unsorted List: [11, 45, 12, 32, 36]
This is Even Number:12
This is Even Number:36
Sorted List: [11, 32, 45]

Je me demande pourquoi 32 n'est pas pris comme un nombre pair, car c'est un nombre pair, j'ai testé ensuite, à l'aide de différentes le même nombre au même poste, mais le résultat est le même. Pourquoi au niveau de l'index(3) il n'arrive que tout nombre pair n'a pas pu être prises. Je me demande vraiment pourquoi. Donc, svp quelqu'un peut m'aider pour cela et est-il un autre de meilleure façon de mettre en œuvre cette solution.

Grâce

Vous sont en train de modifier la liste lors de l'itération sur elle. Une solution simple consiste à itérer vers l'arrière sur la liste.

InformationsquelleAutor Talha Bin Shakir | 2009-11-05

Utiliser un Iterator. Il a une remove() méthode dont vous avez besoin.

List<Integer> numbers = new ArrayList<Integer>();

numbers.add(11);
numbers.add(45);
numbers.add(12);
numbers.add(32);
numbers.add(36);

System.out.println("Unsorted List: " + numbers);

for (Iterator<Integer> iterator = numbers.iterator(); iterator.hasNext();) {
    Integer number = iterator.next();
    if (number % 2 == 0) {
        System.out.println("This is Even Number: " + number);
        iterator.remove();
    }

}

Collections.sort(numbers);
System.out.println("Sorted List: " + numbers);

InformationsquelleAutor BalusC

8

Lorsque vous supprimez quelque chose à partir de la liste, les indices du tout après que les changements!

Plus précisément, de la mise en œuvre 32 n'est pas supprimé comme il vient directement après l'autre même nombre.

Je voudrais utiliser un Itérateur à marcher sur la liste, et l'opération de suppression sur que itérateur au lieu de cela, quelque chose comme ceci:
```
for(Iterator i = number.iterator(); i.hasNext(); ) {
    if (isEven(i.next()) {
        i.remove();
    }
}
```
- Un itérateur vous donnera O(n^2) performances pour un ArrayList. Qui peut ou peut ne pas être un problème.
- alternativement, marcher à reculons à partir de la fin
- Il le fera? Des sons étranges ... de toute façon, j'ai tendance à utiliser la Liste des<X> (en ignorant si c'est vraiment une liste de tableaux ou d'un autre type de Liste) et d'assumer une itération sera rapide. Il devrait être, et je n'aime pas passer du temps sur l'optimisation de la performance, à moins que j'ai un problème de performances ...
- La suppression de la lenteur de la pour le tableau de listes, mais ce n'est pas la faute de l'itérateur.
- Hawtin: la suppression de O(n^2) pour une ArrayList indépendamment de la façon dont vous le faites. Mais les débutants devraient savoir que l'utilisation d'index pour effectuer une itération sur un LinkedList vous donnera O(n^2), mais en utilisant un itérateur sera toujours en O(n) - j'ai vu que cela fait mal, un nombre incalculable de fois...
- Ah, O(n^2) pour l'ensemble de l'opération, pas pour je.supprimer(). Oui. Mais le seul moyen d'éviter cela avec une ArrayList est marcher dans la liste une fois et copier les éléments que vous souhaitez conserver sur une nouvelle liste au lieu de supprimer les éléments un par un (ou à la place de celui qui, à l'aide d'une lecture d'index et une réduction de l'indice).
InformationsquelleAutor Rasmus Kaj
4

Deux réponses à propos de la liste des indices de changement sont corrects. Cependant, gardez à l'esprit que la suppression d'un élément à partir d'une liste de tableaux est lent, car il a fait lecture aléatoire de toutes les entrées suivantes vers le bas. Au lieu de cela, je vous recommande de créer une nouvelle liste contenant uniquement les numéros, et puis il suffit de jeter la vieille liste. Si vous souhaitez utiliser l'Itérateur à base de supprimer le code dans l'autre réponse, cela fonctionnera très bien pour les petits les résultats comme il est, et pour les grands ensembles de données si vous utilisez LinkedList. (Je crois que c'est le nom; mon Java est certes légèrement rouillé.)
- tu veux dire ArrayList.
- Bourrillion: Vous avez certainement raison. Modifié en conséquence.
InformationsquelleAutor Walter Mundt
1

Si vous supprimez une entrée de la liste alors que boucler sur elle, vous aurez à régler votre indice de boucle. N'oubliez pas, en supprimant l'élément réduit la longueur de la liste par un, et de manière efficace "shuffle back" l'indice de tous les éléments d'après elle.

InformationsquelleAutor Adam Wright

Le problème (comme d'autres l'ont mentionné), c'est que vous êtes en train de modifier la liste alors que vous êtes le traverser. Essayez d'ajouter un "i--;" ligne à l'intérieur de votre "si (même==0)" bloquer. Comme ceci:

for (int i=0;i<number.size();i++){
    int even=number.get(i)%2;

    if (even==0){
        System.out.println("This is Even Number:"+ number.get(i));
        number.remove(i);

        //Add this:
        i--;
    }
}

InformationsquelleAutor Stephen

0

Voici une autre manière astucieuse de filtrage pour les impair d'éléments. Au lieu de boucle à travers la collection manuellement, décharger le travail à Apache Commons Collections
```
 //apply a filter to the collection
 CollectionUtils.filter(numbers, new Predicate() {
     public boolean evaluate(Object o) {
         if ((((Integer) o) % 2) == 0) { 
             return false;  //even items don't match the filter
         }
         return true;  //odd items match the filter
     }
 });
```
On peut se demander si c'est réellement plus facile à lire et à comprendre, mais c'est plus amusant. Si un certain type de Prédicat est fréquemment utilisé, il peut être reconstruit dans une constante statique et réutilisés dans tous les sens. Cela pourrait tourner à l'utilisation de celui-ci en quelque chose de beaucoup plus propre:
```
CollectionUtils.filter(numberList, ODD_PREDICATE);
```
InformationsquelleAutor dustmachine

Ce que je fais (Intelliji avec kotlin)

fun main(args: Array<String>) {

 var numbers = arrayList(1,2,3,4,5,6)
 println(numbers.filter{it %2 == 0})

}

résultat=2,4,6

InformationsquelleAutor volvox

public class RemoveEvenUsingAL {

    public static void main(String[] args) {
        List<Integer> list= new ArrayList<Integer>();

        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);
        list.add(6);

        Iterator<Integer> it = list.iterator();
        while(it.hasNext()){
            Integer number= it.next();
            if(number % 2 ==0){
                it.remove();
            }
        }
        System.out.println("ArryList Odd Number="+list);
    }
}

Bienvenue à Débordement de Pile! Alors que ce code peut répondre à la question, il est préférable d'inclure certains des commentaires dans votre réponse. En particulier, la façon dont votre réponse est différente de celles déjà existantes.

InformationsquelleAutor Sudhir Kumar

Nous pouvons utiliser removeIf méthode par défaut dans la classe ArrayList .

     List <Integer> number=new ArrayList <Integer>();

       number.add(11);
       number.add(45);
       number.add(12);
       number.add(32);
       number.add(36);

       number.removeIf(num -> num%2==0);

       System.out.println(number);

InformationsquelleAutor Arpit Agrawal

Vous devez vous connecter pour publier un commentaire.