1. package cn.java.day01;
   
2. 
   
3. import java.util.HashSet;
   
4. import java.util.Set;
   
5. 
   
6. public class Demo1 {
   
7.         
   
8.         public static void main(String[] args){
   
9.                 test1();
   
10.                 test2();
    
11.         }
    
12.         public static void test1(){
    
13.                int arr[]={1};
    
14.                 for(Object obj:arr){
    
15.                         obj=10;        
    
16.                 }
    
17.                 System.out.println(arr[0]);
    
18.         }
    
19.         public static void test2(){
    
20.                 int arr[]={1};
    
21.                 for(int i=0;i<arr.length;i++){
    
22.                         arr[i]=10;
    
23.                 }
    
24.                 System.out.println(arr[0]);
    
25.         }
    
26. }
    

复制代码

问什么test1输出结果为1，而test2输出结果为10.

这里体现的问题不是循环，而且一个循环遍历的是集合，一个循环遍历的数组。
test1中只是将10赋给了obj。set集合没有改变什么，输出时打印了set的元素[1]
test2中将arr=10,打印arr[0]当然是打这个0下标的值了。如果楼主连这都看不懂，真要好好补补了。

package cn.java.day01;

import java.util.HashSet;
import java.util.Set;

public class Demo1 {
        
        public static void main(String[] args){
                test1();
                test2();
        }
        public static void test1(){
                Set set=new HashSet();
                set.add(1);
                for(Object obj:set){
                        obj=10;        //这里obj = 10 ;    obj 是10 ;
                }
                System.out.println(set);  //可你打印的是set集合里面的， set集合里面存储的还是1
        }
        public static void test2(){
                int arr[]={1};
                for(int i=0;i<arr.length;i++){
                        arr[i]=10;  //而数组，这里， 你却给arr[0] = 10;
                }
                System.out.println(arr[0]);  //所以打印的是10
        }
}

1. 
   
2. for(Object obj:set){
   
3.                         obj=10; //这里只是将obj对象的值更改为10，但是没有对set集合做任何操作      
   
4.                 }
   
5.                 System.out.println(set);//因此你输出set集合的值的时候依然是1
   
6. 
   
7. 
   
8. for(int i=0;i<arr.length;i++){
   
9.                         arr[i]=10;//arr[i]=10实际上就是arr[0]=10;这一步完成后数组就变成了int arr[]={10};
   
10. 
    
11.                 }

复制代码

第二个普通for循环，循环遍历数组中的所有元素，实际上是根据数组中的下标来遍历。有多少个元素就有多少个下标，就遍历多少次。
int arr[]={1}; 数组中只有一个元素，所以数组的下标是0。arr中i的值是0，arr就相当于arr[0]，所以 System.out.println(arr[0])的值是10；

你们再看下，结果还是没变。

1. public static void test1(){
   
2.                  int arr[]={1};
   
3.                
   
4.                 for(Object obj:arr){
   
5.                     obj=10; //在增强for循环中，obj只是一个参数，这里只是将obj对象的值更改为10，   
   
6.                         //arr[0]=10; 如果你想对数组的值进行操作，就直接通过数组下标来实现      
   
7.                 }
   
8.                 System.out.println(arr[0]);//因此你输出值依然是1
   
9.         }

复制代码

在增强for循环中，for(Object obj:arr){
                    obj=10; //在增强for循环中，obj只是一个参数，这里你无论将obj的值修改成什么，本身对数组都没有任何影响。因为你修改的只是参数，而不是数组本身。最后数组输出的时候永远都是原始的值   
                               }


如果你要在增强for循环中修改数组

就for(Object obj:arr){
                   // obj=10; //在增强for循环中，obj只是一个参数，这里只是将obj对象的值更改为10，   
                        arr[0]=10; //如果你想对数组的值进行操作，就直接通过数组下标来实现      
                }
                System.out.println(arr[0]);//这样你输出值是10

test1()中的Object obj属于for循环内的局部变量，使用增强for实现了将数组arr中的对象赋值给obj对象，也就是开始的时候obj值为1，经过obj=10的操作之后，obj的值变为10，而数组arr[0]的值仍然没有改变，所以test1()输出了1。
test2()中的遍历数组的同时将当前数组角标为i的值通过arr[i]=10修改为10，所以结果输出了10。