Java tableau, ajouter un élément dans le vide suivant l'indice de

En Java, il est un moyen d'ajouter une valeur à un index spécifique, mais à la prochaine non déclarées de l'index? Dire:

int[] negativeArray = new int[21];
int[] positiveArray = new int[21];

Il y a deux tableaux pour les deux types d'entiers, par exemple le négatif et le positif. Je suis en boucle grâce à cela, et je veux qu'il fonctionne quelque chose comme une pile (je ne sais pas trop sur les piles, mais à ma connaissance, vous ne passez pas par le biais de son index, vous venez de pop/pousser des objets sur elle) où si c'est un nombre négatif, mettre le nombre dans le prochain non déclarées de l'indice de spot dans la négative tableau.

J'ai pensé à un moyen de faire un peu de code supplémentaire. J'avais mis toutes les valeurs du tableau à 0. Lors de la vérification si la variable est négatif ou positif, je voudrais parcourir le tableau à la prochaine valeur est de 0. Une fois que j'ai trouver, je sais ce que l'indice de je suis. Cela nécessite un peu d'effort mais, existe-il des moyens plus simples de faire cela?

Edit: Certains commentaires sont en indiquant les différentes façons de le faire sans l'aide d'une base de tableau. J'ai été affecté, et je suis obligé d'utiliser un tableau pour obtenir le crédit pour...

Ne pouvez-vous pas utiliser des Listes?
Ooh je n'ai jamais utilisé un de ces avant, je vais l'essayer. Mais la chose est, je suis dans l'obligation d'utiliser un tableau parce que son école d'affectation.
... ou java.util.Pile?
Vous devez utiliser arrayList.
Poser des questions sur les devoirs est bien, mais s'il vous plaît étiquette de la question homework🙂

OriginalL'auteur Gabriel | 2012-02-15

6

Si vous êtes en train d'utiliser le tableau comme une pile (et donc, ne fera qu'ajouter ou supprimer des éléments dans le haut de la pile), alors vous pouvez garder dans une autre variable de la prochaine gratuit index dans le tableau.
```
int[] array = new int[21];
int nextIndex = 0;

public void push(int e) {
    array[nextIndex] = e;
    ++nextIndex;
}

public int pop() {
    --nextIndex;
    return array[nextIndex];
}
```
Si les absorptions peuvent se produire n'importe où, alors je ne vois pas de meilleure solution que de parcourir le tableau pour trouver une place libre.

Ahh la solution facile ^_^ merci beaucoup
Ce qui se passe à l'élément sur [nextIndex] après vous poped? Serait-il en fuite? Je pense que cet exemple apparaît dans l'efficacité de la Java. Mieux si l'on ajoute dans le menu méthode de quelque chose à l'annulation de l'élément à nextIndex.
Vous vous trouvez dans le cas où nous sommes de stocker des Objets, l'objet ne serait pas les ordures sont collectées que si nous n'avons pas le retirer de la pile. Ce n'est pas un problème pour les entiers (et les autres types primitifs), mais parce que l' "null" (aka 0) que vous devez écrire à la place prend la même quantité de mémoire.

OriginalL'auteur ARRG
2

C'est pourquoi Listont été faites. Simplement utiliser quelque chose comme ceci:
```
List<Integer> negativeIntegers = new ArrayList<Integer>(21);
...
negativeIntegers.add(-127);
```
lire ma question encore une fois, je l'ai montée

OriginalL'auteur Guillaume Polet

Découvrez http://docs.oracle.com/javase/6/docs/api/java/util/Stack.html

Il n'est fondamentalement la même que ARRG de la solution, mais avec moins de lignes de code:

Stack<Integer> negative = new Stack<Integer>();
Stack<Integer> positive = new Stack<Integer>();

public void putMyNumber(int number) {
  //Taking 0 as "positive"
  if (number >= 0) {
    positive.push(number); //Auto-boxing
    return;
  }
  negative.push(number);
}

OriginalL'auteur user3001

Si vous souhaitez créer un tableau avec les valeurs positives et l'autre avec des valeurs négatives, vous pouvez le faire avec l'algorithme de vous proposer:

public static void main(String[] args) throws Exception {
    int[] negativeArray = new int[3];
    int[] positiveArray = new int[3];

    int[] test = new int[] {1, -1, 2, -2, 3, -3};

    int posIndex = 0;
    int negIndex = 0;

    for (int i = 0; i < test.length; i++) {
        if (test[i] > 0) {
            positiveArray[posIndex++] = test[i];
        } else if (test[i] < 0) {
            negativeArray[negIndex++] = test[i];
        }
    }

    System.out.println(Arrays.toString(test)); //[1, -1, 2, -2, 3, -3]
    System.out.println(Arrays.toString(positiveArray)); //[1, 2, 3]
    System.out.println(Arrays.toString(negativeArray)); //[-1, -2, -3]
}

OriginalL'auteur assylias

Vous devez vous connecter pour publier un commentaire.