Java 如何检测数组中的两个字符串是否相等

我有一系列的人，有名字和薪水的获得者和制定者

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

但它显然不起作用。

---

我该怎么做呢？

您忘记了getName和getSalary上的（）。您需要使用两个嵌套循环来完成此操作。

不要忘记调用

persons.remove（per）

将引发

ConcurrentModificationException

。

---

您需要迭代列表

Iterator personsIter=persons.Iterator（）

然后

personsIter.remove（per）

您可以创建另一个列表（

retainedPersons

在下面的示例中），用它尚未包含的

Person

对象填充它，如果

人员

对象已经存在，则更新薪资

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);

    }

} 

---

如果您使用的是Java 8，则可以使用流API：

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);
    }
}

这个很棘手。 您首先必须循环每个实例，并将其与除自身之外的每个实例进行比较。 接下来，您必须在遍历列表时从列表中删除某些内容

这里，我有一个简单的for循环（在ArrayList这样的情况下可以工作，但是在LinkedList这样的情况下，您必须使用不同的迭代器）

在循环中，我迭代列表中的其余元素，检查它们是否是不同的对象实例，但名称相同。 如果这是真的，则该人员将从列表中删除

        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();
                }
            }
        }

for（inti=0；i

我想这是最容易阅读的，并且不会更改对象引用：D

ArrayList outputList=new ArrayList（）；
    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);

//按姓名分组
Map mapofPersonByName=persons.stream（）.collect（Collectors.groupingBy（新函数（））{
@凌驾
公共字符串应用（人员t）{
//TODO自动生成的方法存根
返回t.getName（）；
}
}));
mapofPersonByName.entrySet（）.forEach（条目->{
字符串名称=entry.getKey（）；
List duplicatePersons=entry.getValue（）；
double salary=duplicatePersons.stream（）.mapToDouble（person->person.getSalary（））.sum（）；
Person personobj=新员工（姓名、工资）；
outputList.add（personobj）；
});
System.out.println（输出列表）；

还有一件事。你在拿一个人和他自己做比较。你应该做2个for循环。所以比较1-1,1-2,1-3,2-1,2-2等等。谢谢，但这只是拼写错误，不符合逻辑。你可以用Set代替List。在集合中，不能保存重复项。如果使用set，请确保覆盖equals和hashcode。在

If

中，您将一个人的姓名与同一个人的姓名进行比较，因此它应始终为

true

。工资也一样。每个人的工资都是双倍；-）我认为，在列表的循环中执行remove元素是非常糟糕的做法，这是最好的解决方案。非常感谢，但我想知道为什么我们需要检查per1！=首先，在这个循环中，它从同一个索引开始检查。因此，它将开始将自身与同名的自身进行比较，但如果删除它，则两者（或相同）都将被删除。其次，如果一个实例被添加到列表中两次，这是相同的，这不应该发生，但可能发生。

[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)]

        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();
                }
            }
        }

    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);