Wie erkennen, ob zwei Strings in einem Array gleich sind

Question

Ich habe eine Reihe von Personen, mit Gettern und Setter von Namen und Gehältern.

Jetzt muss ich gleiche Namen in einem Array finden, und wenn es so ist, fügen Sie ein Gehalt zu einander hinzu und entfernen Sie das doppelte davon.

Ich habe das versucht

for(Persons per : persons) { 

    if(per.getName().equals(per.getName())) 
    { 
     per.setSalary(per.getSalary()+per.getSalary()) 
     persons.remove(per) 
    } 
} 

Aber es ist offensichtlich nicht funktioniert. Wie kann ich es tun?

Answer 1

Dieser heikel ist. Sie müssen zuerst jede Instanz durchlaufen und mit jeder Instanz außer sich selbst vergleichen. Neben dem müssen Sie etwas aus einer Liste entfernen, während Sie darüber iterieren.

Hier habe ich eine einfache for-Schleife (die in Fällen wie eine Arraylist funktionieren würde, aber im Falle von so etwas wie eine LinkedList, haben Sie einen anderen Iterator haben)

In der Schleife I iterieren über die restlichen Elemente in der Liste und prüfen, ob sie unterschiedliche Objektinstanzen sind, aber denselben Namen haben. Wenn das stimmt, wird die Person aus der Liste entfernt.

 for (int i = 0; i < persons.size(); i++) 
     { 
      Person per1 = persons.get(i); 

      for (ListIterator<Person> iter = persons.listIterator(i); iter.hasNext();) 
      { 
       Person per2 = iter.next(); 
       if (per1 != per2 && 
        per1.getName().equals(per2.getName())) 
       { 
        per1.setSalary(per1.getSalary() + per2.getSalary()); 
        iter.remove(); 
       } 
      } 
     } 

Ich nehme an, das ist am einfachsten zu lesen, und es tut die Objektreferenzen ändern: D

Answer 2

Sie vergessen() auf getName und getSalary.

Answer 3

Sie vergleichen gerade dasselbe Array-Element. Sie müssen dies mit zwei verschachtelten Schleifen tun.

Answer 4

Vergessen Sie nicht, dass der Aufruf an persons.remove(per)ConcurrentModificationException auslösen soll. Sie müssen die Liste iterieren Iterator personsIter = persons.iterator() dann personsIter.remove(per)

Answer 5

Sie können eine weitere Liste (retainedPersons im folgenden Beispiel) erstellen, füllen Sie es mit Person Objekte, die es nicht bereits enthalten, und aktualisieren das Gehalt, wenn die Person Objekt bereits Dort.

ArrayList<Person> persons = new ArrayList<>(); 
ArrayList<Person> retainedPersons = new ArrayList<>(); 

for (Person per : persons) { 

    int personsIndex = retainedPersons.indexOf(per); 

    // Person found, update salary 
    if (personsIndex > -1) { 

     Person retainedPerson = retainedPersons.get(personsIndex); 
     retainedPerson.setSalary(retainedPerson.getSalary() + per.getSalary()); 

    } else { 

     // Person not found, add it 

     retainedPersons.add(per); 

    } 

} 

Beachten Sie, dass für indexOf korrekt zu arbeiten, Ihr Person Objekt muss die equals Methode überschreiben, so dass zwei Personen mit dem gleichen Namen als gleich betrachtet werden. z:

public class Person { 

    private double salary; 
    private String name; 

    public double getSalary() { 
     return salary; 
    } 

    public void setSalary(final double salary) { 
     this.salary = salary; 
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(final String name) { 
     this.name = name; 
    } 


    @Override 
    public boolean equals(final Object obj) { 
     if (this == obj) { 
      return true; 
     } 
     if (obj == null) { 
      return false; 
     } 
     if (getClass() != obj.getClass()) { 
      return false; 
     } 
     Person other = (Person) obj; 
     if (name == null) { 
      if (other.name != null) { 
       return false; 
      } 
     } else if (!name.equals(other.name)) { 
      return false; 
     } 
     return true; 
    } 

} 

Answer 6

Wenn Sie Java 8 verwenden können Sie es Stream-API machen mit:

import lombok.AllArgsConstructor; 
import lombok.Data; 
import lombok.NoArgsConstructor; 
import org.junit.Test; 

import java.util.Arrays; 
import java.util.Collection; 
import java.util.List; 

import static java.util.stream.Collectors.groupingBy; 
import static java.util.stream.Collectors.reducing; 

@Data 
@NoArgsConstructor 
@AllArgsConstructor 
class Person { 
    private String name = ""; 
    private Double salary = 0.0; 
} 

public class PersonTest { 

    @Test 
    public void test() { 

     List<Person> persons = Arrays.asList(
       new Person("John", 2.0), 
       new Person("Mary", 2.4), 
       new Person("John", 4.0)); 

     System.out.println(persons); 

     Collection<Person> filteredPersons = persons.stream() 
       .collect(groupingBy(Person::getName, reducing(new Person(), (p1, p2) -> new Person(p2.getName(), p1.getSalary() + p2.getSalary())))) 
       .values(); 

     System.out.println(filteredPersons); 
    } 
} 

Ausgang:

[Person(name=John, salary=2.0), Person(name=Mary, salary=2.4), Person(name=John, salary=4.0)] 
[Person(name=John, salary=6.0), Person(name=Mary, salary=2.4)] 

Answer 7

ArrayList<Person> outputList = new ArrayList<Person>(); 

    // grouping persons by name 
    Map<String, List<Person>> mapofPersonByName = persons.stream().collect(Collectors.groupingBy(new Function<Person, String>() { 

     @Override 
     public String apply(Person t) { 
      // TODO Auto-generated method stub 
      return t.getName(); 
     } 
    })); 

    mapofPersonByName.entrySet().forEach(entry -> { 
     String name = entry.getKey(); 
     List<Person> duplicatePersons = entry.getValue(); 
     double salary = duplicatePersons.stream().mapToDouble(person -> person.getSalary()).sum(); 
     Person personobj = new Person(name, salary); 
     outputList.add(personobj); 
    }); 

    System.out.println(outputList);