import java.util.*;
public class CollectionDemo
{
        public static void main(String[] args)
        {
                method_get();
        }
        public static void method_get()
        {
                ArrayList al = new ArrayList();
                //添加元素
                al.add("java01");
                al.add("java02");
                al.add("java03");
                al.add("java04");
                sop(al);
               
                Iterator it = al.iterator();
                while(it.hasNext())
                {
                        sop(it.next());       
                }

        }
        public static void sop(Object obj)
        {
                System.out.print(obj);
        }
}
第一个问题：为什么uitl包需要导入，而lang包中的却不必要导入就可以直接使用？
第二个问题：hasNext和next有内在联系吗？所谓的迭代是简单的说是什么啊？
第三个问题：为什么此处必须要Object来接收参数呢？

1.list属于util包，所以要导入。
2.hashnext是判断是否存在，next是读取下一个，不调用hashnext调用next可能会报空指针，自己试下。
3.object强转是应为list不是不是泛型，而且本身也容易出现安全问题，编译器本身也会提示的
一般都会加上泛型，或是@的一个注解，不记得了。

郭振 发表于 2012-5-14 11:02
赵玮同学说的很好，前两个问题解答的很好，不过第三个问题答案，有点小毛病，那我就补充一下int和char是基 ...

嗯  看到你这么说  我就觉得我说的有问题了  
如果 " 那我就补充一下int和char是基本数据类型，不属于Object的子类 "
那么为什么 传过去的int  char 或者boolean值 可以被作为Object输出呢？  是强转还是？

郭振 发表于 2012-5-14 12:20
呵呵，不好意思啊，没有注意看，对不起！你答的真的很好！

come on together!:victory:

赵玮_Tom 发表于 2012-5-14 11:34
谢谢！不过我已经在后面注释了基本数据类型自动装箱的情况

呵呵，不好意思啊，没有注意看，对不起！你答的真的很好！

第一个问题：为什么uitl包需要导入，而lang包中的却不必要导入就可以直接使用？
首先java 程序 开发时初期只有lang一个包,后来随着发展逐渐发现包中的内容不够用了,后推出（添加）了   例如uitl 等工具包，但是由于有的人需要而有的人不需要，在考虑到内存占用的情况下，就将这些工具包编外
待开发人员根据自己的需求选择添加与否，节省内存空间
第二个问题：hasNext和next有内在联系吗？所谓的迭代是简单的说是什么啊？
可以说有联系也可以说没联系，因为无论hasNext 或者next 都是一种取值方法，取下一个元素，hasNext 返回类型是 Boolean，只有true 和false两种，而next 返回类型是集合中的子集，所以hasNext通常作为判断语句来应用。
所谓迭代简单的说就是对元素进行循环，进行点名，跟遍历有点类似，同时在迭代期间从所指向的collection中移除元素。

第三个问题：为什么此处必须要Object来接收参数呢？
首先这里是打印语句的应用，因为打印的元素是不确定的，可能是数组，也可能是字符串等，而这些元素都使用了Object作为超类，所以为更好的接受元素，同时解决元素的不确定性就用了Object 来接受这些元素

郭振 发表于 2012-5-14 11:02
赵玮同学说的很好，前两个问题解答的很好，不过第三个问题答案，有点小毛病，那我就补充一下int和char是基 ...

谢谢！不过:)我已经在后面注释了基本数据类型自动装箱的情况:)

java.lang.*包是java的默认引用包
hasNext返回Boolean，如果仍有元素可以迭代，则返回 true。next返回迭代的下一个元素。
迭代器与枚举有两点不同： 迭代器允许调用者利用定义良好的语义在迭代期间从迭代器所指向的 collection 移除元素。 方法名称得到了改进。
print(Object obj) 打印对象。每个类都使用object作为超类，用print(Object obj)不只可以打印String，兼容性更好

第一个问题：为什么uitl包需要导入，而lang包中的却不必要导入就可以直接使用？
答:lang 包也是需要导入的,但是因为lang包是编写java程序时所需要的最基础的包,所以java默认导入java.lang.*;
比如 数据类型 Integer String  都是lang包里的，在用这些对象的时候都不需要引包的。

第二个问题：hasNext和next有内在联系吗？所谓的迭代是简单的说是什么啊？

hasNext  就好比
if(数组[i+1]!=null){
    sop(数组[i+1]);
}

hasNext 是判断下一个是否有值 ,此时地址未指向下一个, 当使用了next后  地址就指向了下一个了  ,所以在sop的时候就输出了 下一个的内容。
至于迭代为什么是最简单的我谈谈我的个人看法,
1.迭代出来的元素不一定是按照存储时的顺序出来的,
2.迭代只需要将指针后移,而ArrayList 需要得到长度 ,需要建立对象数组,建立下标与值的索引
.....


第三个问题：为什么此处必须要Object来接收参数呢？
这个我用代码来告诉你

1. package com.cn;
   
2. import java.util.*;
   
3. 
   
4. public class CollectionDemo
   
5. {
   
6.         public static void main(String[] args)
   
7.         {
   
8.                 method_get();
   
9.         }
   
10.         public static void method_get()
    
11.         {
    
12.                     String string = new String();//引用String 不需要引lang包
    
13.                 ArrayList al = new ArrayList();
    
14.                 al.add("java01");
    
15.                 al.add("java02");
    
16.                 al.add("java03");
    
17.                 al.add("java04");//string型的
    
18.                 al.add(1231);//int型的
    
19.                 al.add(false);//boolean型的
    
20.                 al.add('A');//字符型的
    
21.                 sop(al);//但是不管是什么类型的   它都是object 型的
    
22.                 Iterator it = al.iterator();
    
23.                 while(it.hasNext())
    
24.                 {
    
25.                         sop(it.next());        
    
26.                 }
    
27.                 System.out.println();
    
28. 
    
29.         }
    
30.         public static void sop(Object obj)
    
31.         {
    
32.                 System.out.println(obj);
    
33.         }
    
34. }
    

复制代码

赵玮同学说的很好，前两个问题解答的很好，不过第三个问题答案，有点小毛病，那我就补充一下int和char是基本数据类型，不属于Object的子类。Object是所有引用类型的父类。

1）java.lang包是自动导入的，而其他包需要在用到包中的类时，手动导入。
2）迭代器内部封装了指针。当hasNext()返回值为true时，说明有指针下一个可取的元素，next（）返回下一个元素，指针自动后移一位。如果hasNext()返回值为false，说明指针后面没有元素了。“迭代”可以简单理解为对集合中的元素进行“点名”，和遍历有相似之处。
3）sop()方法是老毕自创的打印方法，由于要打印的内容不确定，可能是字符串，也可能是int或者char类型的数据。但这些数据都属于Object的子类（基本数据类型自动装箱），可以利用多态中父类引用接收子类对象这种向上转型的方式实现打印功能。（需要指出的是，如果该方法打印一个数组，或者一个自定义的类，如Person，会默认调用其toString()方法）