import java.util.*;
class Data {
int val;
int getVal() {
  return val;
}
void setVal(int val) {
  this.val = val;
}
public String toString()
{
   return getVal()+"";
}
}
class ListTest {
  public static void main(String argv[]) {
   Data data = new Data();
   ArrayList list = new ArrayList();
   for (int i=100; i<103; i++) {
            data.setVal(i);
            list.add(data);
   System.out.println(list);
   
          }
      
        int j = 0;
        while (j < list.size()) {
          Data tmp = (Data )list.get(j);
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
}

为什么输出对象获取的值都一样，我知道从头到尾操作的都是同一个对象，还是有点不明白

从头到尾操作的都是同一个对象?这句话怎么理解？
import java.util.*;
class Data {
int val;
int getVal() {
   return val;
}
void setVal(int val) {
   this.val = val;
}
public String toString()
{
    return getVal()+"";
}
}
class ListTest {
  public static void main(String args[]) {
   Data data = new Data();
   ArrayList<Data> list = new ArrayList<Data>();
   for (int i=100; i<103; i++) {
            data.setVal(i);//100 101 102
            System.out.println(data);
            System.out.println(list+"++++");
            list.add(data);
            System.out.println(list);
          }
      
        int j = 0;
        while (j < list.size()) {
          Data tmp = (Data )list.get(j);
          System.out.println(tmp+"--");
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
}

第一次100
第二次 data变为101
然后存了两次 所以集合变为101 101
第三次 data变为102
存了三次 变成102 102 102

你存入的三个val的值是相等的 都是102

class ListTest {
  public static void main(String argv[]) {
   Data data = new Data();
   ArrayList list = new ArrayList();
   for (int i=100; i<103; i++) {
            data.setVal(i);        //第一次循环存入的是100，第二循环存入的101，但同时上次那个100又加了1，因为i++,所以取出来的三个数都是102
            list.add(data);
   System.out.println(list);
   
          }
      
        int j = 0;
        while (j < list.size()) {
          Data tmp = (Data )list.get(j);
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
}

问题是你对内部的实现不是很了解。
Data date = new Date();//此处你创建了一个date对象，其实真正的理解是date是门牌号，new Date()是在内存中开劈的一块空间。此date门牌号指向了开劈的空间。
data.setVal(i);//此处你通过方法给它的属性赋值，改变的是空间中存储的数据
list.add(data);//list添加了data对象，其实就是list集合的最后一个元素指向date的储存空间。
以上两段代码你是放在循环中的，因此，循环最后一次执行的值才是date的存储空间的值，而list集合的每一个元素都指向date的空间，因此你遍历list集合，结果每一个值是相同。

其实这是一个指向问题，你搞清了java的存储方式就不难理解！
希望对你有帮助..............

import java.util.ArrayList;
class Data {
int val;
int getVal() {
  return val;
}
void setVal(int val) {
  this.val = val;
}
public String toString() {
  return getVal() + "";
}
}
class ListTest {
public static void main(String argv[]) {
  Data data = new Data();
  ArrayList list = new ArrayList();
  for (int i = 100; i < 103; i++) {
   data.setVal(i);
   list.add(data);//注意：存进去的是100，但是他仍旧是可以改变的，应为他是引用类型，我们可以改变他所指向的值
   data.setVal(100000);//就是你这个集合列表中存的是引用类型，即使他已经被存进去了，我们依旧可以改变他的地址所指向的值
  System.out.println(i);
   System.out.println(list);
  }
  int j = 0;
  while (j < list.size()) {
   Data tmp = (Data) list.get(j);
   System.out.println("list(" + j + ") = " + tmp.getVal());
   j++;
  }
}
}
经过改变后的值

1. import java.util.*;
   
2. class Data
   
3. {
   
4.         int val;
   
5.         int getVal()
   
6.         {
   
7.                  return val;
   
8.         }
   
9.         void setVal(int val)
   
10.         {
    
11.                 this.val = val;
    
12.         }
    
13.         public String toString()
    
14.         {
    
15.            return getVal()+"";
    
16.         }
    
17. }
    
18. class ListTest
    
19. {
    
20.         public static void main(String argv[])
    
21.         {
    
22.            Data data = new Data();//定义一个Data类型的变量
    
23.            ArrayList list = new ArrayList();//定义一个ArrayList动态数组。
    
24.                  for (int i=100; i<103; i++)
    
25.                         {
    
26.                                 data.setVal(i);
    
27.                                 System.out.println("i的值为："+i);
    
28.                                 list.add(data);//在这里，添加数据，相当于遍历了list集合，把原有数据都改成现在的i值。
    
29.                                
    
30.                                 System.out.println("list里面的===="+list);
    
31.           
    
32.                         }
    
33.       
    
34.                         int j = 0;
    
35.                         while (j < list.size())//list.size()=3
    
36.                         {
    
37.                           Data tmp = (Data )list.get(j);//返回列表中第j位置的元素（j的值依次是0、1、2.）并转换成Data类型。
    
38.                           System.out.println("list(" + j + ") = " + tmp.getVal());//得到列表中第j位置的元素
    
39.                           j++;
    
40.                          }
    
41.         }
    
42. }
    
43. 
    
44. /*
    
45. 你程序的结果：
    
46. [100]
    
47. [101, 101]
    
48. [102, 102, 102]
    
49. list(0) = 102
    
50. list(1) = 102
    
51. list(2) = 102
    
52. */
    
53. 
    
54. /*
    
55. 现在结果：
    
56. i的值为：100
    
57. list里面的====[100]
    
58. i的值为：101
    
59. list里面的====[101, 101]
    
60. i的值为：102
    
61. list里面的====[102, 102, 102]
    
62. list(0) = 102
    
63. list(1) = 102
    
64. list(2) = 102
    
65. */

复制代码

希望对你有帮助

肖琦 发表于 2012-7-25 00:05
问题是你对内部的实现不是很了解。
Data date = new Date();//此处你创建了一个date对象，其实真正的理解是 ...

有点懂了

黑马振鹏 发表于 2012-7-24 20:51
从头到尾操作的都是同一个对象?这句话怎么理解？
import java.util.*;
class Data {

谢谢你的帮助

郭凯敏 发表于 2012-7-25 00:24
import java.util.ArrayList;
class Data {
int val;

嗯，是的，是的

陈云帆 发表于 2012-7-25 02:44
希望对你有帮助

嗯 很有帮助，非常感谢