Discussion :

[marcopaul2]

Bonjours tout le monde!

J'ai 3 algorithmes à faire et je ne sais pas comment.

1) Supprimer tous les entiers négatifs d'une liste.
2) Copiés tous les entiers négatifs dans une deuxièmes liste
3) déplacés tous les entier négatif dans une deuxièmes liste

chaque algorithmes doit être dans des méthodes différente. J'ai fait une méthode pour créer le tableau arrayList:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
    public static int[] creerConsoleListeInt(int[] tab) {
        int[] tableauArray = new int[20];
        int x = 0;      // variable de controle
 
        for (int i = 0; i < tab.length; i++) {
            tableauArray[x] = tab[i];
            x++;
        }
        return tableauArray;
    }

comment faire les 3 algorithmes ?

[CosmoKnacki]

Il faut commencer par être clair dans les termes que tu utilises entre tableau, list et arrayList, on ne sait plus où on en est vraiment. La fonction que tu as écrite renvoie un Array, pas une List et encore moins un ArrayList.
La documentation Java consacre une page à chacune de ces structures de données. Lis ces pages pour bien comprendre les différences et corrige ta fonction. Pour le reste, tu trouveras ton bonheur parmi les méthodes disponibles.

[JuPer71]

Bonjour,

pour commencer je pense que tu vas avoir rapidement un problème dans le code que tu nous présente.
Que se passe-t-il si le tableau d'entiers passé en paramètre (tab) a une taille supérieure à 20?

Ensuite, tu parles de listes à modifier. Et je vois dans ton code que tu utilises des tableaux. Les objets Java que tu utilises ne sont peut-être pas les plus adéquates.

Pour finir, je te conseille de poser sur le papier les 3 méthodes que tu dois implémenter et décrire leur fonctionnement de manière algorithmique.
Par exempe :
Si tableau[element_i] < 0 Alors supprimer tableau[element_i] de tableau.

En espérant t'avoir donné des pistes.

A bientôt.

[marcopaul2]

Merci beaucoup pour m'avoir indiquer mon erreur. J'ai rectifier le tire. voici mon code à date.
sachant que je dois faire :

Algo A) On veut supprimer tous les entiers négatifs de la liste.
Algo B) On veut que tous les entiers négatifs de la liste soient copiés dans une 2e liste.
Algo C) On veut que tous les entiers négatifs de la liste soient déplacés dans une 2e liste.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
public class C3A4 {
 
    static ArrayList<Integer> liste = creerConsoleListeInt();
 
    public static void main(String[] args) {
        ArrayList<Integer> listeSupprimer = new ArrayList();
        listeSupprimer = EntierNegSupprimer();
        ArrayList<Integer> listeNegCopier = new ArrayList();
        listeNegCopier = EntierNegCopier();
        ArrayList<Integer> listeNegDeplacer = new ArrayList();
        listeNegDeplacer = EntierNegDeplacer();
 
    }
 
    public static ArrayList<Integer> creerConsoleListeInt() {
        Scanner scan = new Scanner(System.in);
        System.out.println("Entrer une liste d'entiers: ");
 
        while (scan.hasNextInt()) {
            liste.add(scan.nextInt());
        }
        return liste;
    }
 
    public static ArrayList<Integer> EntierNegSupprimer() {
        int c = 0;  //variable de controle
        ArrayList<Integer> listeSuprimer = new ArrayList();
 
        for (int i = 0; i < liste.size(); i++) {
            liste.get(c);
 
            if (c < 0) {
                liste.remove(i);
            }
 
            if (c >= 0) {
                listeSuprimer.add(i);
            }
            i++;
        }
        return listeSuprimer;
 
    }
 
    public static ArrayList<Integer> EntierNegCopier() {
        ArrayList<Integer> listeNegSupp = new ArrayList();
        int c = 0;      //variable de controle
 
        for (int i = 0; i < liste.size(); i++){
            liste.get(c);
 
            if (c < 0)
                listeNegSupp.add(i);
 
         i++;       
        }
        return listeNegSupp;
 
 
    }

Comment feriez vous le tri de la liste d'entier que l'utilisateur entre, pour déplacer les entiers négatif dans une autre liste, pour que dans le main, je puis faire un sout d'une liste d'entier positive, et une liste d'entier négative.

[CosmoKnacki]

Concernant la création de la liste originale.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
static ArrayList<Integer> liste = creerConsoleListeInt();
 
// ...
 
public static ArrayList<Integer> creerConsoleListeInt() {
    Scanner scan = new Scanner(System.in);
    System.out.println("Entrer une liste d'entiers: ");
 
    while (scan.hasNextInt()) {
        liste.add(scan.nextInt());
    }
    return liste;
}

Soit tu fais une méthode qui renvoie void et qui agit directement sur liste, soit tu fais une méthode qui renvoie un ArrayList que tu affectes à liste. Là tu es le cul entre deux chaises parce que tu agis sur liste dans le corps de ta méthode et en plus tu retournes la liste. Concrètement soit tu fais ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
static ArrayList<Integer> liste = ArrayList<Integer>();
 
public static void main(String[] args) {
    creerConsoleListInt();
    // ...
}
 
public static void creerConsoleListeInt() {
    Scanner scan = new Scanner(System.in);
    System.out.println("Entrer une liste d'entiers: ");
 
    while (scan.hasNextInt()) {
        liste.add(scan.nextInt());
    }
    return liste;
}

soit tu fais ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
static ArrayList<Integer> liste = creerConsoleListeInt();
 
// ...
 
public static ArrayList<Integer> creerConsoleListeInt() {
    ArrayList<Integer> maliste = new ArrayList<Integer>();
 
    Scanner scan = new Scanner(System.in);
    System.out.println("Entrer une liste d'entiers: ");
 
    while (scan.hasNextInt()) {
        maliste.add(scan.nextInt());
    }
    return maliste;
}

Concernant la suite, je ne vois pas trop ce que tu fabriques avec ta variable c ni pourquoi tu incrémentes i deux fois à chaque tour de boucle. listeSuprimer avec un seul p n'est pas très heureux et complique l'édition du code. Aussi, pense à utiliser else lors de tes tests conditionnels quand c'est approprié.

Merci pour tes prochains postes d'utiliser les balises code et de fournir un code indenté qui compile.