1.         public static void removeDir(File dir)
   
2. 
   
3.         {
   
4.                 File[] files=dir.listFiles();//获取目录列表
   
5.                 //遍历目录列表
   
6.                 //一般的for循环
   
7.                 /*
   
8.                 for (int x=0;x<files.length ;x++ )
   
9.                 {
   
10.                         if (files[x].isDirectory())
    
11.                         {
    
12.                                 removeDir(files[x]);
    
13.                         }
    
14.                         else//要加上else 否则会把目录作为文件再删一遍，降低效率，返回false
    
15.                                 System.out.println(files[x]+":-file-:"+files[x].delete());
    
16.                 }
    
17.                 */
    
18.                 //高级for循环
    
19.                 for (File file:files )
    
20.                 {
    
21.                         if (file.isDirectory())
    
22.                         {
    
23.                                 removeDir(file);
    
24.                         }
    
25.                         else
    
26.                                 System.out.println(file+":-file-:"+file.delete());
    
27.                 }
    
28. 
    
29. 
    
30.                         System.out.println(dir+":-dir-:"+dir.delete());//删除目录
    
31.                
    
32.         }

复制代码

在看删除目录的视频时，说这段代码的for循环也可以用高级循环，我想知道，一般的for循环语句都可以用高级for循环表示吗（或者高级for循环都可以写成一般循环的形式吗）？如果不是，那什么情况要用高级for循环呢？

package com.itheima;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/*
* 3、 一个ArrayList对象aList中存有若干个字符串元素，
*  现欲遍历该ArrayList对象，删除其中所有值为"abc"的字符串元素，
*  请用代码实现。
* */
@SuppressWarnings("unused")
public class Test3 {
        public static void main(String[] args) {
                List<String> aList = new ArrayList<String>();
                aList.add("CSDN社区");
                aList.add("abc");
                aList.add("黑马程序员");
                aList.add("黑马论坛");
                aList.add("黑马程序员——安卓");
                aList.add("黑马程序员——云计算");
                aList.add("abc");
                aList.add("我准备去黑马训练营了");
        //解决办法，通过传统for循环的角标删除对应的元素
                for(int i=0;i<aList.size();i++){
                        if(aList.get(i).equals("abc")){
                                aList.remove(i);
                        }
                }
                System.out.println(aList);
               
                /**
                 * 如果使用增强for循环，那么将会报告java.util.ConcurrentModificationException
                 * 为什么会报告这个错误呢？
                 * 增强for循环底层调用的是Iterator迭代器的hasNext方法和next方法，因为ArrayList本身是一个固定长度的集合，
                 * 如果在迭代的时候对数据进行增删操作，那么将会引发异常。这是为什么呢？
                 *
                 * 增强for循环和Iterator遍历的效果是一样的，
                 * 也就说增强for循环的内部也就是调用Iteratoer实现的，
                 * 但是增强for循环有些缺点，例如不能在增强循环里动态的删除集合内容。不能获取下标等。迭代器也是一样。
                 * */
               
       
                /*for(String str :aList){//aList的size现在是8
                        System.out.println(aList.size());
                        //第一次没有删除，size还是8，第二次打印的还是8。
                        if(str.equals("abc")){
                                //但是由于判断到了迭代到的元素是abc，那么删除。
                                aList.remove(str);//删除元素，这时就发生了java.util.ConcurrentModificationException
                        }
                }
                System.out.println(aList);*/
               
        //解决办法：创建一个新的集合，把要删除的元素存储进新的集合
                /*List <String> delList = new ArrayList();
                for(String str :aList){
                        if(str.equals("abc")){
                                delList.add(str);
                        }
                }
                System.out.println(aList);//原集合
                aList.removeAll(delList);
                System.out.println(aList);//删除后的集合*/               
       
        //下面迭代器其原理跟增强for循环一样
                //会发送java.util.ConcurrentModificationException异常
                /*Iterator<String> it = aList.iterator();
                while(it.hasNext()){
                        String str = it.next();
                        if(str.equals("abc")){
                                aList.remove(str);
                        }
                }
                System.out.println(aList);*/
               
                /*List<String> delList = new ArrayList<String>();
                Iterator<String> it = aList.iterator();
                while (it.hasNext()) {
                        String str = it.next();
                        if(str.equals("abc")){
                                delList.add(str);
                        }
                }
                System.out.println(aList);//原集合
                aList.removeAll(delList);
                System.out.println(aList);//删除后的集合*/               
        }
}

一般的For循环可以重复任何操作一定的次数。
在我的认知力，高级for循环有个事操作对象是必须的，那就是有一个集合或者数组来遍历。。。

学识有限，有不足的地方请指正，

      一般的for循环需要事先知道循环的次数，而高级for则不需要。（高级for出现于jdk1.5版本以后）
      另外高级一般的for循环用来遍历数组，而高级for可以遍历数组和集合等，当然遍历集合的时候你也可以用迭代器的方法，（其实高级for的底层原理就是Interator迭代器的迭代原理）不过，综合而言，如果你使用高级for的话会使你的代码短小精悍，优雅许多。如果没有特殊需求的情况下，一般推荐使用增强for。（另外，java版本的升级带来的新特性无非是从三方面入手：提高效率，简化书写，提高安全性。显然增强for就是为了简化书写嘛）
      当然，增强for也是有一些弊端的，例如，在循环中你无法知道当前元素的位置的。如果增强for用来遍历ArrayList集合中的元素，并在遍历中增删元素的话会发生异常的，所以ArrayList定义了自己的迭代器ListIterator来解决这个问题。
      

毕老师的基础视频：Day17-18中讲到二者区别，
大意是：与传统的for循环相比，高级for循环有一个局限性，就是必须有被遍历的目标：集合或者数组.
而且建议在遍历数据时，最好还是用传统的for循环，因为传统的for循环可以定义角标。

2L 有个观点我不敢苟同，就是在抛出java.util.ConcurrentModificationException这个异常的时候，
这个异常并不是在删除的时候抛出的，而是在删除一个元素后，继续遍历的过程中抛出的，具体是遍历到最后还是遍历到某个地方我没详细研究。你可以自己看下，下面是我测试的代码，

1. public void test(){
   
2.                 List<String> list = new ArrayList<String>();
   
3.                 list.add("abc");
   
4.                 list.add("def");
   
5.                 list.add("hig");
   
6.                 list.add("klm");
   
7.                 list.add("nop");
   
8.                 list.add("qrs");
   
9.                 for(String str : list){
   
10.                         if(str.equals("abc")){
    
11.                                 list.remove(str);
    
12.                                 break;
    
13.                         }
    
14.                 }
    
15.         }

复制代码

他的循环原理是什么