A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© wyf880204 中级黑马   /  2013-12-27 23:44  /  1796 人查看  /  10 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

import java.util.*;
public class Demo{
        public static void main(String[] args){

                        List li=new ArrayList();
                        li.add(1);
                        li.add(2);
                        li.add(3);
                        for(Integer a : li){
                                System.out.println(a);
                                }
        }
}
这个怎么会编译错误 运行没错啊  for遍历的时候 不能直接 Integer a : li
不应该吧

遍历的是对象 我已经知道 存入的是基本类型封装类 怎么不行啊

评分

参与人数 1技术分 +1 收起 理由
乔兵 + 1

查看全部评分

10 个回复

倒序浏览
使用增强for循环读取集合中的元素需要用泛型说明元素类型,这样编译器就会将list内的元素转换为Integer类型来读取而不报错

  1. import java.util.*;
  2. public class Demo{
  3.         public static void main(String[] args){

  4.                         List<Integer> li=new ArrayList<>();  //因为下面程序要读取集合中的元素,所以需要用泛型说明元素类型
  5.                         li.add(1);
  6.                         li.add(2);
  7.                         li.add(3);
  8.                         for(Integer a : li){
  9.                                 System.out.println(a);
  10.                                 }
  11.         }
  12. }
复制代码
回复 使用道具 举报
你把集合加上一个泛型<Integer>就可以了,实际上增强for循环遍历集合底层是用Itenter遍历的。用Iterator遍历的时候如果没有泛型,就要用(Integer)it.next()强转,而你用增强for循环的时候没有强转,也不能强转,所以这时候要加上泛型。
回复 使用道具 举报

  1. import java.util.*;
  2. public class Demo{
  3.         public static void main(String[] args){
  4.                         //集合加上泛型<Integer>,以便让你的程序好读取元素
  5.                         List<Integer> li=new ArrayList();
  6.                         li.add(1);
  7.                         li.add(2);
  8.                         li.add(3);
  9.                         for(Integer a : li){
  10.                                 System.out.println(a);
  11.                                 }
  12.         }
  13. }
复制代码
回复 使用道具 举报
因为你没有用泛型限定你集合中要存的是什么类型的数据。

List li=new ArrayList(); //这句你没有说明你要存的是什么类型的,那么就是什么类型的都可以存喽。
li.add(1);   
li.add(2);   //这三句,你是存的int,然后自动装箱了。问题是只有你知道,编译器并不知道
li.add(3);
li.add("a");   //这里我也可以这样存,不会报错。

for(Integer a : li){ //所以这里会报错。不论我上面有没有添加"a"。编译器都不知道li里面到底装的是什么
                            //它会默认的认为,你里面装的是Object。
        System.out.println(a);
     }
   你将你的代码加上泛型  。或者将    for(Integer a : li)里的  integer 改为Object  就没错了。
  在转换成字节码的时候  编译器会有去除泛型参数类型化的操作。但那是运行时,所以你说的运行没错。
但是  在编译时  ,就会报错。编译时和运行时  是不一样的。

回复 使用道具 举报
你上面的这个代码   List li=new ArrayList(); 这句话 没有指定List集合的具体类型换句话说你什么对象都可以向里面添加,例如 li.add("1"),li.add("abc").当你用for遍历的时候你却用Integer类型去遍历可这时候这个集合,可这个集合不能保证里面装的全是Integer类型.所以编译报错 在定义List<Integer> li = new ArrayList()就好了 或者你在遍历的时候 for(Object a : li)用Object代替Integer 这样也可以.
回复 使用道具 举报
import java.util.*;
public class Demo{
        public static void main(String[] args){

                         List li =new ArrayList();

                        li.add(1);
                        li.add(2);
                        li.add(3);
       
                        for(int i=Integer(Object obj) : li){
                        //        Integer i=(Integer)obj;
                                System.out.println(i);
                                }
        }
}

怎么不行啊
回复 使用道具 举报
Cheers_for_CRAZ 发表于 2013-12-28 00:17
你把集合加上一个泛型就可以了,实际上增强for循环遍历集合底层是用Itenter遍历的。用Iterator遍历的时候如 ...

增强for循环 不可以强转么
  1. import java.util.*;
  2. public class Demo{
  3.         public static void main(String[] args){

  4.                          List li =new ArrayList();

  5.                         li.add(1);
  6.                         li.add(2);
  7.                         li.add(3);
  8.        
  9.                         for(int i=Integer(Object obj) : li){
  10.                         //        Integer i=(Integer)obj;
  11.                                 System.out.println(i);
  12.                                 }
  13.         }
  14. }
复制代码
这个可以么
回复 使用道具 举报
wyf880204 发表于 2013-12-28 00:53
增强for循环 不可以强转么 这个可以么

首先,你要了解增强for循环的用法for(类型  名称xx:集合或数组){}   名称xx代表的是集合或者数组中的每一个元素,你这句是什么?--》i=Integer(Object obj),强转?i只是代表数组或集合中每一个元素,当遍历的时候,i指的是元素。
如果你想强转,那么这样写—》(integer)i,或者这样写—》(Object)i。这样写还情有可原。但是这样写也是错的,原因有:
首先,集合的底层实现是数组,你相当于遍历的是数组中的元素。那么我就要问了,你遍历的数组是什么类型呀?哦,Integer类型。给我一个能代表数组元素的名称呀,
哦,i。遍历的是哪一个数组呀?哦li。这样我才给你遍历。
但是你如果没有给我加泛型<Integer>,那我怎么知道你要遍历的是什么类型?你只是给我一个集合li,那我怎么给你遍历!
@其LovE斤 的解释也不错,你也可以参考一下他的
回复 使用道具 举报
Cheers_for_CRAZ 发表于 2013-12-28 02:20
首先,你要了解增强for循环的用法for(类型  名称xx:集合或数组){}   名称xx代表的是集合或者数组中的每 ...

for(int i=Integer(Object obj) : li)
哥们俺的意思是  容器了肯定是对象 所以先将Object obj出来 在将其转为Integer对象封装类型 因为我传的是 123 这样的对象封装类  然后在自动拆箱 成基本数据类型  System.out.println(i); 执行的时候 又执行了一次自动装箱 以字符串输出呢??
回复 使用道具 举报
李兴 中级黑马 2013-12-29 17:17:20
11#
你不使用泛型的话,List集合add()方法默认添加的时Object类型
可以使用这样的代码
  1. import java.util.*;
  2. public class Demo{
  3.         public static void main(String[] args){

  4.                 List li=new ArrayList();
  5.                 li.add(1);
  6.                 li.add(2);
  7.                 li.add(3);
  8.                 for(Object a : li){
  9.                         System.out.println(a);
  10.                 }
  11.         }
  12. }
复制代码


如果使用泛型那就可以添加指定的类型
代码如下
  1. import java.util.*;
  2. public class Demo{
  3.         public static void main(String[] args){

  4.                 List<Integer> li=new ArrayList<Integer>();
  5.                 li.add(1);
  6.                 li.add(2);
  7.                 li.add(3);
  8.                 for(Integer a : li){
  9.                         System.out.println(a);
  10.                 }
  11.         }
  12. }
复制代码
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马