一：
import java.io.*;

class FileDemo
{
        public static void main(String[] args)
        {
                File f = new File("d:\\java0420");

                method_1(f);
        }

        public static void method_1(File dir)
        {
                File[] files = dir.listFiles();

                for(File f : files)
                {
                        System.out.println(files[f]);//这里报错，怎么定义角标阿，为什么会报错呢？
                }
        }
}


二：

import java.io.*;
import java.util.*;

class SplitFile
{
        public static void main(String[] args) throws IOException
        {
                merge();
        }


        public static void merge()throws IOException
        {
                ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();

                for(int x=1; x<=3; x++)
                {
                        al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
                }

                final Iterator<FileInputStream> it = al.iterator();//这里为什么用迭代啊，还加个final？？？

                Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()//为什么要用Vector里面的Enumeration？？
                {
                        public boolean hasMoreElements()
                        {
                                return it.hasNext();
                        }
                        public FileInputStream nextElement()
                        {
                                return it.next();
                        }
                };

                SequenceInputStream sis = new SequenceInputStream(en);


                FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");

                byte[] buf = new byte[1024];

                int len = 0;

                while((len=sis.read(buf))!=-1)
                {
                        fos.write(buf,0,len);
                }

                fos.close();
                sis.close();
        }

        public static void splitFile()throws IOException
        {
                FileInputStream fis =  new FileInputStream("c:\\1.bmp");

                FileOutputStream fos = null;//为什么在这里建立个引用呢？


                byte[] buf = new byte[1024*1024];

                int len = 0;
                int count = 1;
                while((len=fis.read(buf))!=-1)
                {
                        fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
                        fos.write(buf,0,len);
                        fos.close();
                }
               
                fis.close();
               
        }
}

一：
  for(File f : files)
                {
                        System.out.println(files[f]);//这里报错，怎么定义角标阿，为什么会报错呢？
                }

这是一个 增强for 循环 意思是对应于 每一个 files 中的元素 f 一一操作， 具体看视频  或者百度下
System.out.println(f）  这里直接打 f 就可以了

1. import java.io.*;
   
2. 
   
3. class FileDemo
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 File f = new File("d:\\java0420");
   
8. 
   
9.                 method_1(f);
   
10.         }
    
11. 
    
12.         public static void method_1(File dir)
    
13.         {
    
14.                 File[] files = dir.listFiles();
    
15. 
    
16.                 for(File f : files)
    
17.                 {
    
18.                         System.out.println(files[f]);//这里报错，怎么定义角标阿，为什么会报错呢？
    
19.                 //这里你的f是一个文件，这里直接打印f就可以了，他就会自动调用f.toString（）方法。
    
20.                 }
    
21.         }
    
22. }

复制代码

1. import java.io.*;
   
2. import java.util.*;
   
3. 
   
4. class SplitFile
   
5. {
   
6.         public static void main(String[] args) throws IOException
   
7.         {
   
8.                 merge();
   
9.         }
   
10. 
    
11. 
    
12.         public static void merge()throws IOException
    
13.         {
    
14.                 ArrayList<FileInputStream> al = new ArrayList<FileInputStream>();
    
15. 
    
16.                 for(int x=1; x<=3; x++)
    
17.                 {
    
18.                         al.add(new FileInputStream("c:\\splitfiles\\"+x+".part"));
    
19.                 }
    
20. 
    
21.                 final Iterator<FileInputStream> it = al.iterator();//这里为什么用迭代啊，还加个final？？？
    
22.              // 这里的it要在匿名内部类中访问，所以要加final.
    
23.                 Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()//为什么要用Vector里面的Enumeration？？
    
24.                  //Vector比较低效，因为他是同步的。所以效率比较低。
    
25.                 {
    
26.                         public boolean hasMoreElements()
    
27.                         {
    
28.                                 return it.hasNext();
    
29.                         }
    
30.                         public FileInputStream nextElement()
    
31.                         {
    
32.                                 return it.next();
    
33.                         }
    
34.                 };
    
35. 
    
36.                 SequenceInputStream sis = new SequenceInputStream(en);
    
37. 
    
38. 
    
39.                 FileOutputStream fos = new FileOutputStream("c:\\splitfiles\\0.bmp");
    
40. 
    
41.                 byte[] buf = new byte[1024];
    
42. 
    
43.                 int len = 0;
    
44. 
    
45.                 while((len=sis.read(buf))!=-1)
    
46.                 {
    
47.                         fos.write(buf,0,len);
    
48.                 }
    
49. 
    
50.                 fos.close();
    
51.                 sis.close();
    
52.         }
    
53. 
    
54.         public static void splitFile()throws IOException
    
55.         {
    
56.                 FileInputStream fis =  new FileInputStream("c:\\1.bmp");
    
57. 
    
58.                 FileOutputStream fos = null;//为什么在这里建立个引用呢？
    
59. //这个我觉得没有引用也可以吧。你可以取消一下看看是否有报错。
    
60. 
    
61.                 byte[] buf = new byte[1024*1024];
    
62. 
    
63.                 int len = 0;
    
64.                 int count = 1;
    
65.                 while((len=fis.read(buf))!=-1)
    
66.                 {
    
67.                         fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
    
68.                         fos.write(buf,0,len);
    
69.                         fos.close();
    
70.                 }
    
71.                
    
72.                 fis.close();
    
73.                
    
74.         }
    
75. }

复制代码

System.out.println(files[f]);//这里报错，怎么定义角标阿，为什么会报错呢？
//增强for循环操作的时候只能对 ：前的变量进行操作，也就是只能对f进行各种操作，你那个格式是错误的，你可以直接输出f

final Iterator<FileInputStream> it = al.iterator();//这里为什么用迭代啊，还加个final？？？
//用迭代是为了获取集合al中的元素，加final是因为在下面 Enumeration的匿名内部类中只能访问用final修饰的局部成员

Enumeration<FileInputStream> en = new Enumeration<FileInputStream>()//为什么要用Vector里面的Enumeration？？
//这里用Enumeration是因为SequenceInputStream 中传入的参数只能是Enumeration类型，而Enumeration只有Vector集合中有

FileOutputStream fos = null;//为什么在这里建立个引用呢？
//这里可以取消，但是取消后下面while循环中的fos前加上FileOutputStream
//即变成如下的样子
while((len=fis.read(buf))!=-1)
{
            FileOutputStream  fos = new FileOutputStream("c:\\splitfiles\\"+(count++)+".part");
            fos.write(buf,0,len);
            fos.close();
}