J'essaie de créer une fonction pour obtenir l'élément suivant dans une liste qui n'est pas dans une autre liste, tout en bouclant également jusqu'au début de la liste lorsqu'elle atteint la fin.
En gros, ce que je veux, c'est:
public String nextItem() {
index++;
if(index == list.size()) index = 0;
while(list2.contains(list[index])) {
index++;
if(index == list.size()) index = 0;
}
return list[index];
}
J'ai essayé de faire ceci:
String[] list = new String[]{"apple", "banana", "cherry", "donut", "egg", "fish", "grape"};
List<String> list2 = new ArrayList<String>( Arrays.asList("apple", "cherry", "donut", "fish"));
int index = 4;
System.out.println(nextItem());
System.out.println(nextItem());
System.out.println(nextItem());
System.out.println(nextItem());
System.out.println(nextItem());
//Returns:
//egg
//grape
//banana
//egg
//grape
mais cela ne fonctionne pas , l'index reste le même.
Y a-t-il une meilleure façon de faire ceci / quelque chose de similaire que je ne connais pas?
3 Réponses :
Quelques changements et ça marche comme un charme:
public class Example {
String[] list = new String[]{"apple", "banana", "cherry", "donut", "egg", "fish", "grape"};
List<String> list2 = new ArrayList<>(Arrays.asList("apple", "cherry", "donut", "fish"));
public int index = 4;
public static void main(String[] args) {
new Example().start();
}
public void start() {
for (int i = 0; i < 100000; i++) {
System.out.println(nextItem());
}
}
public String nextItem() {
index++;
if (index == list.length) index = 0;
while (list2.contains(list[index])) {
index++;
if (index == list.length) index = 0;
}
return list[index];
}
}
Le point principal étant que index doit être global.
Pouvez-vous être un peu plus précis?
Dépend de l'endroit où list et list2 sont déclarés. Je suggérerais de fournir le String Array (liste) et l'interface de liste (list2) comme arguments de la méthode nextItem () ainsi qu'une valeur d'index de départ comme troisième argument, par exemple:
banana egg grape ** There are no more non-shared items in the lists! **
L'exemple ci-dessus de la méthode nextItem () renvoie une valeur Integer qui serait la valeur d'index à laquelle un élément du tableau de chaînes (liste) n'est pas également contenu dans la liste Collection d'interface (list2). Votre premier appel naturel à cette méthode fournirait un 0 comme argument pour le paramètre startIndex . Pour obtenir l'élément suivant qui n'est pas partagé à la fois dans list et list2 , vous devez fournir la valeur d'index renvoyée à partir de l'appel nextItem () précédent, ajouter 1 et la fournir comme valeur startIndex au suivant Appel de méthode nextItem () . Voici un exemple:
String[] list = {"apple", "banana", "cherry", "donut", "egg", "fish", "grape"};
List<String> list2 = new ArrayList<>( Arrays.asList("apple", "cherry", "donut", "fish"));
String noMore = "** There are no more non-shared items in the lists! **";
// Get first non-shared item
int idx = nextItem(list, list2, 0);
if (idx > -1) {
System.out.println(list[idx]);
}
else {
System.out.println("Both lists contain all the same items");
// return from method or event
}
// Get second non-shared item
idx = nextItem(list, list2, idx + 1);
if (idx > -1) {
System.out.println(list[idx]);
}
else {
System.out.println(noMore);
// return from method or event
}
// Get third non-shared item
idx = nextItem(list, list2, idx + 1);
if (idx > -1) {
System.out.println(list[idx]);
}
else {
System.out.println(noMore);
// return from method or event
}
// Get fourth non-shared item (if any)
idx = nextItem(list, list2, idx + 1);
if (idx > -1) {
System.out.println(list[idx]);
}
else {
System.out.println(noMore);
// return from method or event
}
La fenêtre de la console afficherait:
banana egg grape
L'exemple de code suivant n'utilise pas de boucle et est fourni ici pour être peut-être une meilleure aide visuelle à ce que fait le code:
String[] list = {"apple", "banana", "cherry", "donut", "egg", "fish", "grape"};
List<String> list2 = new ArrayList<>( Arrays.asList("apple", "cherry", "donut", "fish"));
int idx = 0;
while (idx != -1) {
idx = nextItem(list, list2, idx);
if (idx != -1) {
System.out.println(list[idx]);
idx++;
}
}
La fenêtre de la console afficherait:
public static int nextItem(String[] stringArray, List<String> listInterface, int startIndex) {
int index = -1;
for (int i = startIndex; i < stringArray.length; i++) {
if (!listInterface.contains(stringArray[i])) {
return i;
}
}
return -1;
}
La clé est de continuer à augmenter l ' index jusqu'à ce qu'un élément de la liste soit trouvé dans list2 . Je l'ai fait en utilisant la boucle while dans le programme ci-dessous:
egg grape banana egg grape
Sortie:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Main {
static String[] list = new String[] { "apple", "banana", "cherry", "donut", "egg", "fish", "grape" };
static List<String> list2 = new ArrayList<String>(Arrays.asList("apple", "cherry", "donut", "fish"));
static int index = 4;
public static void main(String[] args) {
System.out.println(nextItem());
System.out.println(nextItem());
System.out.println(nextItem());
System.out.println(nextItem());
System.out.println(nextItem());
}
static String nextItem() {
if (index == list.length) {
index = 0;
}
while (list2.contains(list[index])) {
index++;
}
return list[index == list.length ? 0 : index++];
}
}
AlarmClockMan - Si l'une des réponses a résolu votre problème, vous pouvez aider la communauté en la marquant comme acceptée. Une réponse acceptée aide les futurs visiteurs à utiliser la solution en toute confiance. Vérifiez meta.stackexchange.com/questions / 5234 /… pour savoir comment procéder.