final LinkedList<String> linkedList = new LinkedList<>();
linkedList.add("A");
linkedList.add("B");
linkedList.add("C");
if (Objects.equals(linkedList.get(1), "B")) {
System.out.println("💥");
}
System.out.println("---");
for (final Iterator<String> iterator = linkedList.iterator(); iterator.hasNext();) {
final String string = iterator.next();
if (Objects.equals(string, "B")) {
iterator.remove();
System.out.println("🔥");
} else {
System.out.println(string);
}
}
System.out.println("---");
for (final String string : linkedList) {
if (Objects.equals(string, "C")) {
System.out.println("💥");
} else {
System.out.println(string);
}
}
System.out.println("---");
for (int i = 0; i < linkedList.size(); i++) {
final String string = linkedList.get(i);
if (Objects.equals(string, "C")) {
System.out.println("💥");
} else {
System.out.println(string);
}
}
System.out.println("---");
linkedList.forEach(string -> {
if (Objects.equals(string, "C")) {
System.out.println("💥");
} else {
System.out.println(string);
}
});
System.out.println("---");
linkedList.stream().forEach(string -> {
if (Objects.equals(string, "C")) {
System.out.println("💥");
} else {
System.out.println(string);
}
});
final Iterator<String> iterator = linkedList.iterator();
iterator.forEachRemaining(string -> {
if (Objects.equals(string, "C")) {
System.out.println("💥");
} else {
System.out.println(string);
}
});
Also generell solltest Du wissen, was in der LinkedList ist. Dazu dienen ja die Generics. Das hat den Hintergrund, dass man in der Regel typsicher entwickeln möchte.Wie kann ich überprüfen, ob die LinkedList ein Enum enthält also z.B. einen Wochentag?
if (list.get(i) instanceof MyEnum)
Nicht nur bei Strings sondern bei allen Klassen ist equals der bessere Weg.Richtig. Gegebenenfalls .equals() bei Strings.
public enum Allergen {
NUTS, PEANUTS, SOYBEANS, GLUTEN, FISH, MILK, EGGS;
}
import java.util.LinkedList;
abstract class Item implements ItemInfo {
private double price;
private int ID;
private LinkedList<Allergen> allergenes = new LinkedList<Allergen>();
public double getPrice() {
return price;
}
public int getID() {
return ID;
}
public LinkedList<Allergen> getAllergenes() {
return allergenes;
}
public void setPrice(double price) {
this.price = price;
}
public void setID(int iD) {
ID = iD;
}
public void setAllergenes(LinkedList<Allergen> allergenes) {
this.allergenes = allergenes;
}
}
import java.util.LinkedList;
public class StorageManager extends Employee {
private LinkedList<Item> items = new LinkedList<Item>();
public boolean buyNewItem(Object Item) {
if (items.contains(Item)) {
return false;
} else {
items.add((Item) Item);
return true;
}
}
public LinkedList<Item> filterStorage() {
LinkedList<Item> newItems = new LinkedList<Item>();
for (int i = 0; i < items.size(); i++) {
//Hier muss überprüft werden, ob die Allergene aus dem Enum
// "Allergen" in der Liste vorhanden sind, wenn ja sollen diese
//in "newItems" kopiert werden.
newItems.add(items.get(i));
}
return newItems;
}
public LinkedList<Item> getItems() {
return items;
}
public void setItems(LinkedList<Item> items) {
this.items = items;
}
}
Das ist eigentlich eine schlechte Idee, da LinkedList auch null enthalten kann. Man sollte immer Objects.equals verwenden.Du kannst dazu auch generell equals verwenden. Da wäre es dann etwas wie:
if (list.get(i).equals(MyEnum.SOME_VALUE))
Aber vielleicht zeigst Du uns einfach den ganzen Code, um den es Dir hier geht und dann kann man Dir besser helfen.
Würde ich aus genau dem Grund nicht mit Objects.equals machen: entweder die Liste soll null enthalten, dann lieber mit !=null explizit machen, oder da soll fachlich kein null drin sein, dann equals und durch die NPE den Fehler damit wenigstens finden können.Das ist eigentlich eine schlechte Idee, da LinkedList auch null enthalten kann. Man sollte immer Objects.equals verwenden.
Da sollte man dann eifnach einmal die KLasse LinkedList im Detail betrachten. Da findet sich dann evtl. ja eine Methode contains ...Es soll jedes Item, welches den Filter in seiner allergen-Liste enthaelt, in eine neue LinkedList kopiert werden. Diese soll am Ende zurueckgegeben werden.
Eine NPE ist eine EntwicklerZuBlödException, dass hat nichts mit Fehlersuche zu tun. Für die Fehlersuche würde sich z.B.: Objects.requireNonNull(String obj, String message), eine Assertition oder eine Annotation anbieten. Objects.equals macht den Quellcode lesbarer, als X-mal den Ausdruck: (a == b) || (a != null && a.equals(b)) einzufügen.Würde ich aus genau dem Grund nicht mit Objects.equals machen: entweder die Liste soll null enthalten, dann lieber mit !=null explizit machen, oder da soll fachlich kein null drin sein, dann equals und durch die NPE den Fehler damit wenigstens finden können.
public LinkedList<Item> filterStorage() {
LinkedList<Item> newItems = new LinkedList<Item>();
for (int i = 0; i < items.size(); i++) {
//Hier muss überprüft werden, ob die Allergene aus dem Enum
// "Allergen" in der Liste vorhanden sind, wenn ja sollen diese
//in "newItems" kopiert werden.
newItems.add(items.get(i));
}
return newItems;
}
List<?> list = items.get(i).getAllergenes();
if (list != null && !list.isEmpty()) {
// list contains Allergenes
}
Mein "Fehler finden" ist eher als ein "Fehler anzeigen, damit man merkt, dass an anderer Stelle ein Fehler gemacht wurde"
Expliziter >> lesbarerObjects.equals macht den Quellcode lesbarer, als X-mal den Ausdruck: (a == b) || (a != null && a.equals(b)) einzufügen.
Aber nicht ausschließlich eigentlich? Ich hatte schon den Fall das alle Eingaben die der Public Test macht in die neue Liste kopiert wurden, das waren 5 glaub ich, es sollen aber wohl nur 2 seinDie einzige Möglichkeit wäre, dass die Liste null oder empty ist, ansonsten müssen da immer Allergene drin sein.
1) testStorageManagerFilterStorage(PublicTests)
java.lang.AssertionError: expected:<[Food@ba4d54, Food@12bc6874]> but was:<[]>
at org.junit.Assert.fail(Assert.java:88)
at org.junit.Assert.failNotEquals(Assert.java:834)
at org.junit.Assert.assertEquals(Assert.java:118)
at org.junit.Assert.assertEquals(Assert.java:144)
at PublicTests.testStorageManagerFilterStorage(PublicTests.java:183)
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.base/java.lang.reflect.Method.invoke(Method.java:566)
at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:52)
at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runners.Suite.runChild(Suite.java:128)
at org.junit.runners.Suite.runChild(Suite.java:27)
at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
at org.junit.runner.JUnitCore.run(JUnitCore.java:115)
at org.junit.runner.JUnitCore.runMain(JUnitCore.java:77)
at org.junit.runner.JUnitCore.main(JUnitCore.java:36)
Wenn in der Liste immer 2 Elemente sein sollen, dann ist eine Liste möglicherweise der falsche Objekttyp. Eine Datenstruktur fester Länge wäre z.B.: ein Array.Ich hatte schon den Fall das alle Eingaben die der Public Test macht in die neue Liste kopiert wurden, das waren 5 glaub ich, es sollen aber wohl nur 2 sein
Noch mal:Es sollen nicht immer 2 Elemente sein. Es geht ja darum aus der Liste "items" die Item rauszufiltern, die Allergene sind, diese sollen dann in eine neue Liste kopiert werden. Der Public Test gibt der Liste in dem Fall wie gesagt 5 Items, wovon zwei dann Allergene sind. Ich kriege es nur nicht hin, diese zwei Allergene rauszufiltern.
public enum Allergen {
NUTS, PEANUTS, SOYBEANS, GLUTEN, FISH, MILK, EGGS;
}
private LinkedList<Allergen> allergenes = new LinkedList<Allergen>();
abstract class Item implements ItemInfo {
private double price;
private int ID;
private LinkedList<Allergen> allergenes = new LinkedList<Allergen>();
...
}
List<Allergenes> list = items.get(i).getAllergenes();
if (list != null && !list.isEmpty()) {
// list contains Allergenes
}
Das nicht, aber die Liste items enthält nur Items und jedes Item enthält eine Liste mit Allegenes.Aber "items" ist doch nicht die selbe Liste wie "allergenes"?
Wenn ich damit versuche irgendwas zu erreichen scheitert es am getAllergenes() und jegliche Änderung die von Eclipse vorgeschlagen wird ist gegen die "Regeln" der Aufgabe.allergenes - kann null oder leer sein.
Java:List<Allergenes> list = items.get(i).getAllergenes(); if (list != null && !list.isEmpty()) { // list contains Allergenes }
Inwiefern "scheitert" es denn? Du könntest da gerne etwas konkreter werden oder möchtest du ein Quiz mit uns veranstalten?scheitert es am getAllergenes()
public LinkedList<Allergen> filterStorage(Allergen ALLERGEN) {
LinkedList<Allergen> list = new LinkedList<Allergen>();
for (int i = 0; i < items.size(); i++) {
list = items.get(i).getAllergenes();
if ((list != null) && !list.isEmpty()) {
list.add(ALLERGEN);
}
} return list;
}
There was 1 failure:
1) testStorageManagerFilterStorage(PublicTests)
java.lang.AssertionError: expected:<[Food@ba4d54, Food@12bc6874]> but was:<[FISH, SOYBEANS, EGGS, GLUTEN]>
@Test
public void testStorageManagerFilterStorage() {
Item bread = new Food();
bread.getAllergenes().add(Allergen.GLUTEN);
Item nutella = new Food();
nutella.getAllergenes().add(Allergen.NUTS);
nutella.getAllergenes().add(Allergen.PEANUTS);
nutella.getAllergenes().add(Allergen.GLUTEN);
Item kuhmilch = new Beverage();
kuhmilch.getAllergenes().add(Allergen.MILK);
Item tuna = new Food();
tuna.getAllergenes().add(Allergen.FISH);
tuna.getAllergenes().add(Allergen.SOYBEANS);
Item catfood = new Food();
catfood.getAllergenes().add(Allergen.FISH);
catfood.getAllergenes().add(Allergen.SOYBEANS);
catfood.getAllergenes().add(Allergen.EGGS);
StorageManager s = new StorageManager();
s.buyNewItem(bread);
s.buyNewItem(nutella);
s.buyNewItem(kuhmilch);
s.buyNewItem(tuna);
s.buyNewItem(catfood);
LinkedList<Item> gluten = new LinkedList<Item>();
gluten.add(bread);
gluten.add(nutella);
LinkedList<Item> nuts = new LinkedList<Item>();
nuts.add(nutella);
LinkedList<Item> peanuts = new LinkedList<Item>();
peanuts.add(nutella);
LinkedList<Item> milk = new LinkedList<Item>();
milk.add(kuhmilch);
LinkedList<Item> fish = new LinkedList<Item>();
fish.add(tuna);
fish.add(catfood);
LinkedList<Item> soybeans = new LinkedList<Item>();
soybeans.add(tuna);
soybeans.add(catfood);
LinkedList<Item> eggs = new LinkedList<Item>();
eggs.add(catfood);
assertEquals(gluten, s.filterStorage(Allergen.GLUTEN));
assertEquals(nuts, s.filterStorage(Allergen.NUTS));
assertEquals(peanuts, s.filterStorage(Allergen.PEANUTS));
assertEquals(milk, s.filterStorage(Allergen.MILK));
assertEquals(fish, s.filterStorage(Allergen.FISH));
assertEquals(soybeans, s.filterStorage(Allergen.SOYBEANS));
assertEquals(eggs, s.filterStorage(Allergen.EGGS));
}
public class Auto {
private String type;
public Auto(String type) {
this.type = type;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Auto auto = (Auto) o;
return type != null ? type.equals(auto.type) : auto.type == null;
}
@Override
public int hashCode() {
return type != null ? type.hashCode() : 0;
}
public static void main(String[] args) {
Auto audi = new Auto("Audi");
Auto opel = new Auto("Opel");
Auto nochEinAudi = new Auto("Audi");
System.out.println(audi.equals(opel));
System.out.println(audi.equals(nochEinAudi));
}
}
assertEquals(gluten, s.filterStorage(Allergen.GLUTEN));
s.filterStorage(Allergen.GLUTEN)
. Das muss also ebenfalls eine Liste von Items sein (die Gluten enthalten).public LinkedList<Item> filterStorage(Allergen ALLERGEN) {
LinkedList<Item> list = new LinkedList<Item>();
for (int i = 0; i < items.size(); i++) {
list.add(items.get(i));
//filter? "if" Bedingung? Was anderes?
} return list;
}
1) testStorageManagerFilterStorage(PublicTests)
java.lang.AssertionError: expected:<[Food@ba4d54, Food@12bc6874]> but was:<[Food@ba4d54, Food@12bc6874, Beverage@de0a01f, Food@4c75cab9, Food@1ef7fe8e]>
Damit bekomme ich diese Ergebnis, sieht eigentlich ja so aus, als wäre ich auf dem richtigen Pfad
public LinkedList<Item> filterStorage(Allergen ALLERGEN) {
LinkedList<Item> list = new LinkedList<Item>();
for (int i = 0; i < items.size(); i++) {
if (items.get(i).equals(ALLERGEN)) {
list.add(items.get(i));
}
} return list;
}
items.get(i)
ein einzelnes Item. Du versuchst ein Item mit einem Allergen zu vergleichen. Das sind wieder Äpfel und Birnen.Dann versuche die Bedingung, bzw. den Algorithmus erst mal ohne Code ganz einfach in Worte zu fassen: "Für jedes Item in der Liste.."Ich meinte nur, dass mir die Bedingung in Codeform überhaupt nicht klar ist.
public LinkedList<Item> filterStorage(Allergen allergen) {
LinkedList<Item> result = new LinkedList<Item>();
for (Item item : items) {
// mach was mit dem item
}
return result;
}
Du möchtest für jedes Item, dessen Liste von Allergenen prüfen, ob das bestimmte Allergen darin enthalten ist.
public LinkedList<Item> filterStorage(Allergen ALLERGEN) {
LinkedList<Item> list = new LinkedList<Item>();
for (Item item : items) {
if (item.getAllergenes().contains(ALLERGEN)) {
list.add(item);
}
} return list;
}