我自己推算的是100 101 102
而我用eclipse运行了下结果是 102 102 102
求明白人把main方法里的运行过程给我讲一下   
绕的我很迷糊

class Data {
        int        val;
        int        getVal() {
                return val;
        }
        void        setVal(int val) {
                this.val = val;
        }
}

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

        int j = 0;
        while (j < list.size()) {
          Data tmp = (Data )list.get(j);
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
}

我晕 你就new了一个 Data的对象 然后你用for循环反复修改添加的都是这一个对象。等于说修改的都是一个Data对象的val值。所以你把他输出的时候当然是三个一样的val 都是 102。要把你的意图用代码反应出来应该是这样的：
public static void main(String argv[]) {
          Data data = null;
          ArrayList list = new ArrayList();

          for (int i=100; i<103; i++) {
            data = new Data();
            data.setVal(i);
            list.add(data);
          }

        int j = 0;
        while (j < list.size()) {
          Data tmp = (Data )list.get(j);
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
}

class Data
{
   int val;
   int getVal()
       return val;
   void setVal(int val)
   {
     this.val = val;
   }
}
public class ListTest
{
  public static void main(String argv[])
   {
          Data data = new Data(); //创建一个对象
          ArrayList list = new ArrayList(); //创建一个ArrayList集合
          for (int i=100; i<103; i++) //100-102 运行3次
          {
            data.setVal(i); //设置对象data 的i值 依次传入100,101,102。                              
                                 //注意这里你的data只是一个对象实例，你修改
                                 //了对象的内容那么i的值也随着该变最终是102
            list.add(data); //将对象data加入ArrayList集合中，共三次，
                                 //也就是集合说三次引用了同一对象。
          }
        int j = 0;   
        while (j < list.size()) //size() 为3 循环3次
        {
          Data tmp = (Data )list.get(j);//按下标取得集合list元素，因为未使用泛型，故需强制类型转换，
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
}
主要的问题你通过设置了Data这个对象的值，list存入的只是对象的引用。表现出来的就是
Data以最后修改的那次为标准。

import java.util.*;
class Data
{
        int        val;
        int        getVal()
                {
                return val;
        }
        void        setVal(int val)
                {
                this.val = val;
        }
}

public class ListTest
{

  public static void main(String argv[])
{
         
          ArrayList list = new ArrayList();

          for (int i=100; i<103; i++)
                  {
                        Data data = new Data();//把这句话放循环里面就对了。
            data.setVal(i);
                        System.out.println("data"+data.getVal());
            list.add(data);
          }

        int j = 0;
        while (j < list.size())
                {
          Data tmp=(Data)list.get(j);
          System.out.println("list(" + j + ") = " + tmp.getVal() );
          j++;
        }
  }
}
你的程序里面只new过一个Data，for循环中每次只是在修改val，然后把这个data对象再重新存到list中。  按照你的写法list中其实只存了一个data对象。
循环最后把data的val修改成了102，所以你输出的肯定都是102，因为list中只有一个值，输出是一样的。

解释见代码注释部分。

1. public class ListTest
   
2. {
   
3.         
   
4.         public static void main(String argv[])
   
5.         {
   
6.         
   
7.                 ArrayList list = new ArrayList();
   
8.                 // Data data = new Data();在这里建立一个对象的时候内存中只会存在一份Data的对象。（方法一）
   
9.                 for (int i = 100; i < 103; i++)
   
10.                 {
    
11.                         // 在这里的话每调用一次都会建立一个新对象，（方法二）
    
12.                         Data data = new Data();
    
13.                         // 按照方法一的话调用这个setVal的方法只会改变这个对象内val的值
    
14.                         // 按照方法二的话调用这个setVal的方法将会给每个对象的val设置一个不同的值。
    
15.                         data.setVal(i);
    
16.                         // 按照第一种方法的话只能让指针指向同一个对象。改变这个对象的值将会使ArrayList容器中的每个对象的值都改变。
    
17.                         // 按照第二种方法的话能让指针指向不同的对象，将会有不同的值。
    
18.                         list.add(data);
    
19.                 }
    
20.                
    
21.                 int j = 0;
    
22.                 while (j < list.size())
    
23.                 {
    
24.                         Data tmp = (Data) list.get(j);
    
25.                         System.out.println("list(" + j + ") = " + tmp.getVal());
    
26.                         j++;
    
27.                 }
    
28.         }
    
29. }
    
30. 
    
31. public class Data
    
32. {
    
33.         
    
34.         int        val;
    
35.         
    
36.         int getVal()
    
37.         {
    
38.         
    
39.                 return val;
    
40.         }
    
41.         
    
42.         void setVal(int val)
    
43.         {
    
44.         
    
45.                 this.val = val;
    
46.         }
    
47. }
    

复制代码

for (int i=100; i<103; i++) {
            data.setVal(i);
            list.add(data);
          }
      //程序执行到这里，相当于已经创建了一个拥有100,101,102三个元素的集合，接下来要想输出的结果为100,101,102，就应该取该集合中的元素，但你的程序接下来做的事并不是取该集合中的元素，而是用一个 while  循环，想通过 调用tmp.getVal()) 输出100,101.102
      分析：当上面的for循环结束后，最后一次内存中val的值被修改为102。当j=0时，list（0）+tmp.getVal()); 开始调用getval（）方法，你的 getVal方法是这样写的  int  getVal() {  return val; }与100根本对不上， 因为val的作用域是整个Data类， 内存中只会记住最后一个val值为102 ，当然输出的也就为102了；i=1和2时，亦如此，故最终程序输出的结果为102,102,102      
        int j = 0;
        while (j < list.size()) {
          Data tmp = (Data )list.get(j);
          System.out.println("list(" + j + ") = " + tmp.getVal());
          j++;
        }
  }
      要想输出结果为100,101,102，则应该对getVal() 方法进行重写，使 getVal() 方法中实现取list集合中的元素的功能

你一直在把data引用往list集合中去加，加了三次。最后一次将data的val值设置为102.所以打印三次每次都是102.你若想得到结果：100 101 102 。可以new出三个Data对象。分别指定val的值，或者一个对象设置三次val值，然后将val值加入list集合中。下面代码是后一种情况（Data类没改，只改的main方法）：
public 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.getVal());             //每次加入不同val值，用了基本类型的自动装箱
                }

                int j = 0;
                while (j < list.size()) {
                        // Data tmp = (Data )list.get(j);
                        System.out.println("list(" + j + ") = " + list.get(j));             //打印结果
                        j++;
                }
        }
}