为什么我的数组列表包含上一个添加到列表中的项的 N 个副本？

This problem has two typical causes:

• Static fields used by the objects you stored in the list

• Accidentally adding the same object to the list

Static Fields

If the objects in your list store data in static fields, each object in your list will appear to be the same because they hold the same values. Consider the class below:

public class Foo {
private static int value;
//      ^^^^^^------------ - Here's the problem!
  

public Foo(int value) {
this.value = value;
}
  

public int getValue() {
return value;
}
}

In that example, there is only one int value which is shared between all instances of Foo because it is declared static. (See "Understanding Class Members" tutorial.)

If you add multiple Foo objects to a list using the code below, each instance will return 3 from a call to getValue():

for (int i = 0; i < 4; i++) {
list.add(new Foo(i));
}

The solution is simple - don't use the static keywords for fields in your class unless you actually want the values shared between every instance of that class.

Adding the Same Object

If you add a temporary variable to a list, you must create a new instance of the object you are adding, each time you loop. Consider the following erroneous code snippet:

List<Foo> list = new ArrayList<Foo>();
Foo tmp = new Foo();


for (int i = 0; i < 3; i++) {
tmp.setValue(i);
list.add(tmp);
}

Here, the tmp object was constructed outside the loop. As a result, the same object instance is being added to the list three times. The instance will hold the value 2, because that was the value passed during the last call to setValue().

To fix this, just move the object construction inside the loop:

List<Foo> list = new ArrayList<Foo>();


for (int i = 0; i < 3; i++) {
Foo tmp = new Foo(); // <-- fresh instance!
tmp.setValue(i);
list.add(tmp);
}

Your problem is with the type static which requires a new initialization every time a loop is iterated. If you are in a loop it is better to keep the concrete initialization inside the loop.

List<Object> objects = new ArrayList<>();


for (int i = 0; i < length_you_want; i++) {
SomeStaticClass myStaticObject = new SomeStaticClass();
myStaticObject.tag = i;
// Do stuff with myStaticObject
objects.add(myStaticClass);
}

Instead of:

List<Object> objects = new ArrayList<>();


SomeStaticClass myStaticObject = new SomeStaticClass();
for (int i = 0; i < length; i++) {
myStaticObject.tag = i;
// Do stuff with myStaticObject
objects.add(myStaticClass);
// This will duplicate the last item "length" times
}

Here tag is a variable in SomeStaticClass to check the validity of the above snippet; you can have some other implementation based on your use case.

Every time you add an object to an ArrayList, make sure you add a new object and not already used object. What is happening is that when you add the same 1 copy of object, that same object is added to different positions in an ArrayList. And when you make change to one, because the same copy is added over and over again, all the copies get affected. For example, Say you have an ArrayList like this:

ArrayList<Card> list = new ArrayList<Card>();
Card c = new Card();

Now if you add this Card c to list, it will be added no problem. It will be saved at location 0. But, when you save the same Card c in the list, it will be saved at location 1. So remember that you added same 1 object to two different locations in a list. Now if you make a change that Card object c, the objects in a list at location 0 and 1 will also reflect that change, because they are the same object.

One solution would be to make a constructor in Card class, that accepts another Card object. Then in that constructor, you can set the properties like this:

public Card(Card c){
this.property1 = c.getProperty1();
this.property2 = c.getProperty2();
... //add all the properties that you have in this class Card this way
}

And lets say you have the same 1 copy of Card, so at the time of adding a new object, you can do this:

list.add(new Card(nameOfTheCardObjectThatYouWantADifferentCopyOf));

Had the same trouble with the calendar instance.

Wrong code:

Calendar myCalendar = Calendar.getInstance();


for (int days = 0; days < daysPerWeek; days++) {
myCalendar.add(Calendar.DAY_OF_YEAR, 1);


// In the next line lies the error
Calendar newCal = myCalendar;
calendarList.add(newCal);
}

You have to create a NEW object of the calendar, which can be done with calendar.clone();

Calendar myCalendar = Calendar.getInstance();


for (int days = 0; days < daysPerWeek; days++) {
myCalendar.add(Calendar.DAY_OF_YEAR, 1);


// RIGHT WAY
Calendar newCal = (Calendar) myCalendar.clone();
calendarList.add(newCal);


}

It can also consequence of using the same reference instead of using a new one.

 List<Foo> list = new ArrayList<Foo>();


setdata();
......


public void setdata(int i) {
Foo temp = new Foo();
tmp.setValue(i);
list.add(tmp);
}

Instead of:

List<Foo> list = new ArrayList<Foo>();
Foo temp = new Foo();
setdata();
......


public void setdata(int i) {
tmp.setValue(i);
list.add(tmp);
}