java IO体系结构

最新推荐文章于 2022-03-21 12:22:43 发布

etonZh

最新推荐文章于 2022-03-21 12:22:43 发布

阅读量666

点赞数

分类专栏：成长 Java 文章标签： java 文件

Java 同时被 2 个专栏收录

30 篇文章 0 订阅

订阅专栏

成长

14 篇文章 0 订阅

订阅专栏

1.流的概念

输入和输出的抽像，类似一个水管，从一个地方流入数据，从另外一个地方输出数据（我个人比喻为：从耳朵听进（从别人那得到信息），从嘴里说出（自己的想法））

2.流的分类
按方向分：输入流（InputStream）和输出流（OutputStream）
按性质分：
a.基础字节流（原始流）：（InputStream）和（OutputStream）是按最小单位读取（byte）,直接连接到输入流
b.过滤流（节点流）：BufferedInputStream 和BufferedOutputStream
c.基于具体数据类型的流：DateInputStream和 DateOutputStream
d.基于对象读写：ObjectOutputStream

3.InputStream是一个抽象类，不能直接实例化
FileInputStream是InputStream的子类
BufferedInputStream ，DateInputStream是FilterInputStream的子类

4.(1) InputStream中的重要方法
int available():读取的字节长度
void close（）：关闭输入流
int read():读取字节，虽然是int类型，但实际上读取的是byte

(2) OutputStreamde 调用方法
void close（）：关闭输出流
void flush（）：强制输出数据
void write（int b）：像流中写入一个byte值

5.（1）FileInputStream：从文件中读取数据
构造方法：
FileInputStream(File file) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String name) 通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

示例代码：

 
  Java代码   
  package IO体系结构;     
      
  import java.io.FileInputStream;     
  import java.io.IOException;     
  import java.io.InputStream;     
      
  public class BaseIO {     
      
      public String readFile2String(String filename)throws java.io.IOException{     
          //构造输入流对象，作为一个Inputstream对象使用     
          InputStream ins = new FileInputStream(filename);     
          //通过文件对象创建输入流     
          //File srcFile = new File(filename);     
          //inputStream ins = new FileInputStream(srcFile);     
               
          //根据流中的字节长度，创建一个byte数组，保存读到的数据     
          byte[] contentByte = new byte[ins.available()];     
          //将流中的数据读到数组中     
          ins.read(contentByte);     
          //还可以用循环读取     
          //int i,j=0     
          //while((i=ins.read())!=-1){     
          //contentByte[j]=(byte)j;     
          //j++;     
          //}     
          //将byte数组转为字符串     
          String s = new String(contentByte);     
               
          return s;     
               
      }     
           
           
      /**   
       * @param args   
       * @throws IOException    
       */    
      public static void main(String[] args) throws IOException {     
          BaseIO bi = new BaseIO();     
          //读取我们正在编写的着个java文件     
          String filename="src\\IO体系结构";     
          String result=bi.readFile2String(filename);     
          System.out.println(result);     
      }     
      
  }    
  package IO体系结构;  
    
  import java.io.FileInputStream;  
  import java.io.IOException;  
  import java.io.InputStream;  
    
  public class BaseIO {  
    
   public String readFile2String(String filename)throws java.io.IOException{  
    //构造输入流对象，作为一个Inputstream对象使用  
    InputStream ins = new FileInputStream(filename);  
    //通过文件对象创建输入流  
    //File srcFile = new File(filename);  
    //inputStream ins = new FileInputStream(srcFile);  
      
    //根据流中的字节长度，创建一个byte数组，保存读到的数据  
    byte[] contentByte = new byte[ins.available()];  
    //将流中的数据读到数组中  
    ins.read(contentByte);  
    //还可以用循环读取  
    //int i,j=0  
    //while((i=ins.read())!=-1){  
    //contentByte[j]=(byte)j;  
    //j++;  
    //}  
    //将byte数组转为字符串  
    String s = new String(contentByte);  
      
    return s;  
      
   }  
     
     
   /** 
    * @param args 
    * @throws IOException  
    */  
   public static void main(String[] args) throws IOException {  
    BaseIO bi = new BaseIO();  
    //读取我们正在编写的着个java文件  
    String filename="src\\IO体系结构";  
    String result=bi.readFile2String(filename);  
       System.out.println(result);  
   }  
    
  }  
    
    
    （2）FileOutputStream 写数据到文件  
    
         构造方法：   
               FileOutputStream(File file) 创建一个向指定 File 对象表示的文件中写入数据的文件输出流。   
                 
               FileOutputStream(File file, boolean append)创建一个向指定 File 对象表示的文件中写入数据的文件输出流。  
    
               FileOutputStream(String name) 创建一个向具有指定名称的文件中写入数据的输出文件流。  
    
               FileOutputStream(String name, boolean append) 创建一个向具有指定 name 的文件中写入数据的输出文件流。   
  示例代码：  
    
     
    
  Java代码   
  package IO体系结构;     
      
  import java.io.FileInputStream;     
  import java.io.FileOutputStream;     
  import java.io.IOException;     
  import java.io.InputStream;     
  import java.io.OutputStream;     
      
  public class BaseIOcopy {     
      
      public boolean copyfile(String srcFile,String destFlie)throws IOException{     
          //创建从源文件来的输入流     
          InputStream ins = new FileInputStream(srcFile);     
          //缓冲输入流对象：如果文件中已有内容则覆盖原来内容     
          OutputStream out = new FileOutputStream(destFlie);     
          int i=0;     
          //从输入流中读取一个字节     
          while((i=ins.read())!=-1){     
              //将这个字节写到输入流     
              out.write(i);     
          }     
          ins.close();     
          //清空输入流的缓存并关闭     
          out.flush();     
          out.close();     
               
          return true;     
               
      }     
           
      /**   
       * @param args   
       * @throws IOException    
       */    
      public static void main(String[] args) throws IOException {     
          BaseIOcopy bic = new BaseIOcopy();     
          //读取我们正在写的这个java源文件     
          String srcName="G:\\蓝杰·java\\jdk1.6.CHM";     
          //要复制到的目标文件     
          String bakName="E:\\123.CHM";     
          boolean result=bic.copyfile(srcName, bakName);     
          System.out.println(result);     
      
      }     
      
  }    
  package IO体系结构;  
    
  import java.io.FileInputStream;  
  import java.io.FileOutputStream;  
  import java.io.IOException;  
  import java.io.InputStream;  
  import java.io.OutputStream;  
    
  public class BaseIOcopy {  
    
   public boolean copyfile(String srcFile,String destFlie)throws IOException{  
    //创建从源文件来的输入流  
    InputStream ins = new FileInputStream(srcFile);  
    //缓冲输入流对象：如果文件中已有内容则覆盖原来内容  
    OutputStream out = new FileOutputStream(destFlie);  
    int i=0;  
    //从输入流中读取一个字节  
    while((i=ins.read())!=-1){  
     //将这个字节写到输入流  
     out.write(i);  
    }  
    ins.close();  
    //清空输入流的缓存并关闭  
    out.flush();  
    out.close();  
      
    return true;  
      
   }  
     
   /** 
    * @param args 
    * @throws IOException  
    */  
   public static void main(String[] args) throws IOException {  
    BaseIOcopy bic = new BaseIOcopy();  
    //读取我们正在写的这个java源文件  
    String srcName="G:\\蓝杰·java\\jdk1.6.CHM";  
    //要复制到的目标文件  
    String bakName="E:\\123.CHM";  
    boolean result=bic.copyfile(srcName, bakName);  
    System.out.println(result);  
    
   }  
    
  }  
    
    
  6.缓冲流：BufferedInputStream 和BufferedOutputStream   
    缓冲区：默认大小8192K  
    
    优点：实用缓冲流相比原始流可以节省巨大的时间（试了一下，效果真的很显著！ ）   
  示例代码：  
    
    
  Java代码   
  package IO体系结构;     
      
  import java.io.BufferedInputStream;     
  import java.io.BufferedOutputStream;     
  import java.io.File;     
  import java.io.FileInputStream;     
  import java.io.FileOutputStream;     
  import java.io.IOException;     
  import java.io.InputStream;     
  import java.io.OutputStream;     
      
  public class BaseIOhpw {     
      
      public boolean bufferedcopyfile(String srcFile,String destFlie)throws IOException{     
          File src = new File(srcFile);     
          File dest = new File(destFlie);     
               
          //创建从源文件来的输入流     
          InputStream ins = new FileInputStream(src);      
          //构造输入缓冲流     
          BufferedInputStream bis = new BufferedInputStream(ins);     
          //缓冲输入流对象：如果文件中已有内容则覆盖原来内容     
          OutputStream out = new FileOutputStream(dest);     
          BufferedOutputStream bos = new BufferedOutputStream(out);     
          int i=0;     
          //从输入流中读取一个字节     
          while((i=ins.read())!=-1){     
              //将这个字节写到输入流     
              out.write(i);     
          }     
          ins.close();     
          //清空输入流的缓存并关闭     
          out.flush();     
          out.close();     
               
          return true;     
               
      }     
           
      /**   
       * @param args   
       * @throws IOException    
       */    
      public static void main(String[] args) throws IOException {     
          BaseIOhpw bic = new BaseIOhpw();     
          //读取我们正在写的这个java源文件     
          String srcName="G:\\蓝杰·java\\jdk1.6.CHM";     
          //要复制到的目标文件     
          String bakName="E:\\456.CHM";     
          boolean result=bic.bufferedcopyfile(srcName, bakName);     
          System.out.println(result);     
      
      }     
      
  }    
  package IO体系结构;  
    
  import java.io.BufferedInputStream;  
  import java.io.BufferedOutputStream;  
  import java.io.File;  
  import java.io.FileInputStream;  
  import java.io.FileOutputStream;  
  import java.io.IOException;  
  import java.io.InputStream;  
  import java.io.OutputStream;  
    
  public class BaseIOhpw {  
    
   public boolean bufferedcopyfile(String srcFile,String destFlie)throws IOException{  
    File src = new File(srcFile);  
    File dest = new File(destFlie);  
      
    //创建从源文件来的输入流  
    InputStream ins = new FileInputStream(src);   
    //构造输入缓冲流  
    BufferedInputStream bis = new BufferedInputStream(ins);  
    //缓冲输入流对象：如果文件中已有内容则覆盖原来内容  
    OutputStream out = new FileOutputStream(dest);  
    BufferedOutputStream bos = new BufferedOutputStream(out);  
    int i=0;  
    //从输入流中读取一个字节  
    while((i=ins.read())!=-1){  
     //将这个字节写到输入流  
     out.write(i);  
    }  
    ins.close();  
    //清空输入流的缓存并关闭  
    out.flush();  
    out.close();  
      
    return true;  
      
   }  
     
   /** 
    * @param args 
    * @throws IOException  
    */  
   public static void main(String[] args) throws IOException {  
    BaseIOhpw bic = new BaseIOhpw();  
    //读取我们正在写的这个java源文件  
    String srcName="G:\\蓝杰·java\\jdk1.6.CHM";  
    //要复制到的目标文件  
    String bakName="E:\\456.CHM";  
    boolean result=bic.bufferedcopyfile(srcName, bakName);  
    System.out.println(result);  
    
   }  
    
  }  
    
  1.File类的用途   
     1.File可以帮助我来操作系统中的文件，对文件进行新建删除，修改，查找  
    
     2.文件：相对路径和绝对路径   
      相对路径：new ImageIcon(“images/1.jpg”);  与src是同级的目录   
      绝对路径：只要带上盘符   
  （尽量用相对路径）   
     3.不同操作系统的分隔符会不同，实用通用的常量来实现  
    
  2.File类常用的方法和常量   
  .File类在java.io的包下，   
  Boolean exsits()：判断文件是否存在   
  String getame()：得到文件名字   
  Boolean isDirectory()：判断是否为文件目录   
  Boolean isFile()：判断是否为文件   
  Boolean delete()  删除此抽象路径名表示的文件或目录   
  File getAbsolutePath()：得到路径名   
  File[] listFiles()：得到一个路径名数组   
  Boolean creatNewFile()：创建一个新的文件  
    
  3.得到电脑的根目录：   
  File[] fl = File.listRoots();   
  fl[i]. getAbsolutePath();   
  fl.lenth//目录的个数  
    
  4.递归：自身调用自身的方法  
    
  5.File类的常用方法测试  
    
  Java代码   
  package FileSearch;     
      
  import java.io.File;     
      
  public class FileTest {     
      
      //列出机器上的根目录     
      public void listRoots(){     
          //直接调用File类的static方法     
          File[] lf = File.listRoots();     
          System.out.println("磁盘上的目录个数是："+lf.length);     
          for(int i=0;i<lf.length;i++){     
              System.out.println("第"+i+"个目录："+lf[i].getAbsolutePath());     
          }     
      }     
           
      //测试文件创建与delete     
      public void testCreatAndDelete(String fileName){     
          //通过传入的名字构造File对象     
          File temFile = new File(fileName);     
          //判断文件是否存在     
          if(temFile.exists()){     
              //如果是一个目录     
              if(temFile.isDirectory()){     
                  System.out.println("这是一个目录："+temFile.getAbsolutePath());     
              }     
              //如果是一个文件     
              if(temFile.isFile()){     
                  System.out.println("文件长度是："+temFile.length());     
                  //删除文件     
                  temFile.delete();     
                  String theName=temFile.getName();     
                  String absPath=temFile.getAbsolutePath();     
                  System.out.println("文件已删除，名字是"+theName+"绝对路径是："+absPath);     
              }     
          }     
          else{     
              try{     
                  temFile.createNewFile();     
                  System.out.println("文件已创建！"+temFile.getAbsolutePath());     
                  //打印出文件长度     
                  System.out.println("文件长度是："+temFile.length());     
              }     
              catch(Exception ef){     
                  System.out.println("创建文件失败！");     
              }     
          }     
           
      }     
           
      /**   
       * @param args   
       */    
      public static void main(String[] args) {     
          FileTest ft = new FileTest();     
          ft.listRoots();     
          ft.testCreatAndDelete("测试文件");     
      
      }     
      
  }    
  package FileSearch;  
    
  import java.io.File;  
    
  public class FileTest {  
    
   //列出机器上的根目录  
   public void listRoots(){  
    //直接调用File类的static方法  
    File[] lf = File.listRoots();  
    System.out.println("磁盘上的目录个数是："+lf.length);  
    for(int i=0;i<lf.length;i++){  
     System.out.println("第"+i+"个目录："+lf[i].getAbsolutePath());  
    }  
   }  
     
   //测试文件创建与delete  
   public void testCreatAndDelete(String fileName){  
    //通过传入的名字构造File对象  
    File temFile = new File(fileName);  
    //判断文件是否存在  
    if(temFile.exists()){  
     //如果是一个目录  
     if(temFile.isDirectory()){  
      System.out.println("这是一个目录："+temFile.getAbsolutePath());  
     }  
     //如果是一个文件  
     if(temFile.isFile()){  
      System.out.println("文件长度是："+temFile.length());  
      //删除文件  
      temFile.delete();  
      String theName=temFile.getName();  
      String absPath=temFile.getAbsolutePath();  
      System.out.println("文件已删除，名字是"+theName+"绝对路径是："+absPath);  
     }  
    }  
    else{  
     try{  
      temFile.createNewFile();  
      System.out.println("文件已创建！"+temFile.getAbsolutePath());  
      //打印出文件长度  
      System.out.println("文件长度是："+temFile.length());  
     }  
     catch(Exception ef){  
      System.out.println("创建文件失败！");  
     }  
    }  
     
   }  
     
   /** 
    * @param args 
    */  
   public static void main(String[] args) {  
    FileTest ft = new FileTest();  
    ft.listRoots();  
    ft.testCreatAndDelete("测试文件");  
    
   }  
    
  }  
 

[java]view plaincopy 
   
 6.用递归法搜索文件  
    
  Java代码   
  package FileSearch;     
    
  import java.io.File;     
    
  public class FileDisplay {     
    
     //打印某个目录下的文件名字，并返回文件个数     
     public int printDir(String dirName){     
         int filecount=0;     
         File dirFile = new File(dirName);     
         File[] subFile = dirFile.listFiles();//列表目录     
    
         if(null==subFile||subFile.length==0){//是空目录或者文件     
             return 0;     
         }     
         //遍历一级子目录     
         for(int i=0;i<subFile.length;i++){     
             if(subFile[i].isDirectory()){     
                 String subDir=subFile[i].getAbsolutePath();     
                 System.out.println("目录:"+subDir);     
                 filecount+=printDir(subDir);     
             }     
             if(subFile[i].isFile()){     
                 filecount++;     
                 String FileName=subFile[i].getAbsolutePath();     
                 System.out.println("文件："+FileName);     
             }     
         }     
         return filecount;     
     }     
    
     /**   
      * @param args   
      */    
     public static void main(String[] args) {     
         FileDisplay fd= new FileDisplay();     
         String dirName = "src";     
         int count=fd.printDir("src");     
         System.out.println(dirName+"目录下共找到文件个数是:"+count);     
    
     }     
    
  }     
    
  7.     
  实现文件选择器     
  //实例化一个文件选择器     
  JFileChooser chooser = new JFileChooser();     
  //设置为打开方式的文件选择器     
  chooser.setDialogType(JFileChooser.OPEN_DIALOG);     
  //设置只能打开文件目录     
  chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);     
  //获取文件选择其中按钮的信息     
  int t=chooser.showOpenDialog(null);     
  //当用户点击打开时,获得要搜索的文件名     
  if(t==chooser.APPROVE_OPTION){     
     path=chooser.getSelectedFile().getAbsolutePath();     
     tex.setText(path);     
  }    
  package FileSearch;  
    
  import java.io.File;  
    
  public class FileDisplay {  
    
     //打印某个目录下的文件名字，并返回文件个数  
     public int printDir(String dirName){  
         int filecount=0;  
         File dirFile = new File(dirName);  
         File[] subFile = dirFile.listFiles();//列表目录  
    
         if(null==subFile||subFile.length==0){//是空目录或者文件  
             return 0;  
         }  
         //遍历一级子目录  
         for(int i=0;i<subFile.length;i++){  
             if(subFile[i].isDirectory()){  
                 String subDir=subFile[i].getAbsolutePath();  
                 System.out.println("目录:"+subDir);  
                 filecount+=printDir(subDir);  
             }  
             if(subFile[i].isFile()){  
                 filecount++;  
                 String FileName=subFile[i].getAbsolutePath();  
                 System.out.println("文件："+FileName);  
             }  
         }  
         return filecount;  
     }  
    
     /** 
      * @param args 
      */  
     public static void main(String[] args) {  
         FileDisplay fd= new FileDisplay();  
         String dirName = "src";  
         int count=fd.printDir("src");  
         System.out.println(dirName+"目录下共找到文件个数是:"+count);  
    
     }  
    
  }  
    
  7.  
  实现文件选择器  
  //实例化一个文件选择器  
  JFileChooser chooser = new JFileChooser();  
  //设置为打开方式的文件选择器  
  chooser.setDialogType(JFileChooser.OPEN_DIALOG);  
  //设置只能打开文件目录  
  chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);  
  //获取文件选择其中按钮的信息  
  int t=chooser.showOpenDialog(null);  
  //当用户点击打开时,获得要搜索的文件名  
  if(t==chooser.APPROVE_OPTION){  
     path=chooser.getSelectedFile().getAbsolutePath();  
     tex.setText(path);  
  }  
    
  8.文件搜索器   
  文件搜索器的功能要能是要根据相应的路径或者关键字找到相应的文件名，功能更强大一点的话，还能够根据关键字找到跟文件内容相关的文件。其实就是上面6,7两端代码的组合，再弄个界面，添加上监听器就行了。   
  相关代码如下：  
    
    
  Java代码   
  package FileSeacher1;     
    
  import javax.swing.JButton;     
  import javax.swing.JFrame;     
  import javax.swing.JScrollPane;     
  import javax.swing.JTextArea;     
  import javax.swing.JTextField;     
    
  public class FileSeacher extends JFrame {     
    
     //添加图片     
     java.net.URL seach = FileSeacher.class.getResource("1.jpg");     
     javax.swing.ImageIcon seacher = new javax.swing.ImageIcon(seach);     
    
     java.net.URL open = FileSeacher.class.getResource("2.jpg");     
     javax.swing.ImageIcon opener = new javax.swing.ImageIcon(open);     
    
     public void showUI(){     
         this.setSize(600,600);     
         this.setTitle("文件搜索器");     
         this.setDefaultCloseOperation(3);     
         this.setLocationRelativeTo(null);     
         this.setResizable(false);     
         this.setLayout(null);     
    
         //文件选择器的相关文本域和按钮     
         JTextField tex = new JTextField(20);     
         tex.setBounds(140, 20, 300, 30);     
         this.add(tex);     
    
         JButton but = new JButton("打开");     
         but.setBounds(60, 20, 75, 28);     
         but.setIcon(opener);     
         this.add(but);     
    
         JButton bu = new JButton("搜索");     
         bu.setBounds(450, 20, 60, 29);     
         bu.setIcon(seacher);     
         this.add(bu);     
    
         //文本域     
         JTextArea area=new JTextArea();     
         //area.setBounds(30,130,500,350);     
         //this.add(area);     
    
         //滚动面板     
         JScrollPane sp=new JScrollPane(area);     
         sp.setBounds(20,100,550,440);     
         //this.add(sp);     
         this.getContentPane().add(sp);     
    
         //文件选择器的监听器     
         FileOpenListener fo=new FileOpenListener(tex);     
         but.addActionListener(fo);     
    
         //文件搜索器的监听器     
         FileSearchListener fl=new FileSearchListener(tex,area);     
         bu.addActionListener(fl);     
    
    
    
         this.setVisible(true);     
     }     
    
     public static void main(String[] args) {     
         FileSeacher fs = new FileSeacher();     
         fs.showUI();     
    
     }     
    
  }    
  package FileSeacher1;  
    
  import javax.swing.JButton;  
  import javax.swing.JFrame;  
  import javax.swing.JScrollPane;  
  import javax.swing.JTextArea;  
  import javax.swing.JTextField;  
    
  public class FileSeacher extends JFrame {  
    
     //添加图片  
     java.net.URL seach = FileSeacher.class.getResource("1.jpg");  
     javax.swing.ImageIcon seacher = new javax.swing.ImageIcon(seach);  
    
     java.net.URL open = FileSeacher.class.getResource("2.jpg");  
     javax.swing.ImageIcon opener = new javax.swing.ImageIcon(open);  
    
     public void showUI(){  
         this.setSize(600,600);  
         this.setTitle("文件搜索器");  
         this.setDefaultCloseOperation(3);  
         this.setLocationRelativeTo(null);  
         this.setResizable(false);  
         this.setLayout(null);  
    
         //文件选择器的相关文本域和按钮  
         JTextField tex = new JTextField(20);  
         tex.setBounds(140, 20, 300, 30);  
         this.add(tex);  
    
         JButton but = new JButton("打开");  
         but.setBounds(60, 20, 75, 28);  
         but.setIcon(opener);  
         this.add(but);  
    
         JButton bu = new JButton("搜索");  
         bu.setBounds(450, 20, 60, 29);  
         bu.setIcon(seacher);  
         this.add(bu);  
    
         //文本域  
         JTextArea area=new JTextArea();  
         //area.setBounds(30,130,500,350);  
         //this.add(area);  
    
         //滚动面板  
         JScrollPane sp=new JScrollPane(area);  
         sp.setBounds(20,100,550,440);  
         //this.add(sp);  
         this.getContentPane().add(sp);  
    
         //文件选择器的监听器  
         FileOpenListener fo=new FileOpenListener(tex);  
         but.addActionListener(fo);  
    
         //文件搜索器的监听器  
         FileSearchListener fl=new FileSearchListener(tex,area);  
         bu.addActionListener(fl);  
    
    
    
         this.setVisible(true);  
     }  
    
     public static void main(String[] args) {  
         FileSeacher fs = new FileSeacher();  
         fs.showUI();  
    
     }  
    
  }  
    
    
    
  Java代码   
  package FileSeacher1;     
    
  import java.awt.event.ActionEvent;     
  import java.awt.event.ActionListener;     
  import java.io.File;     
    
  import javax.swing.JTextArea;     
  import javax.swing.JTextField;     
    
  public class FileSearchListener implements ActionListener{     
    
     private JTextField tex;     
     private JTextArea area;     
    
     public FileSearchListener(JTextField tex,JTextArea area){     
         this.tex=tex;     
         this.area=area;     
     }     
    
     //打印某个目录下的文件名字，并返回文件个数     
     public int printDir(String dirName){     
         int filecount=0;     
         File dirFile = new File(dirName);     
         File[] subFile = dirFile.listFiles();//列表目录     
    
         if(null==subFile||subFile.length==0){//是空目录或者文件     
             return 0;     
         }     
         //遍历一级子目录     
         for(int i=0;i<subFile.length;i++){     
             if(subFile[i].isDirectory()){     
                 String subDir=subFile[i].getAbsolutePath();     
                 area.append("目录:"+subDir+"\n");     
                 //System.out.println("目录:"+subDir);     
                 filecount+=printDir(subDir);     
             }     
             if(subFile[i].isFile()){     
                 filecount++;     
                 String FileName=subFile[i].getAbsolutePath();     
                 area.append("文件："+FileName+"\n");     
                 //System.out.println("文件："+FileName);     
             }     
         }     
         return filecount;     
     }     
    
     @Override    
     public void actionPerformed(ActionEvent e) {     
         String str=tex.getText();     
         //printDir(str);     
         area.append(str+"目录下共找到文件个数是:"+printDir(str)+"\n");     
         //System.out.println(str+"目录下共找到文件个数是:"+printDir(str));     
    
     }     
    
  }    
  package FileSeacher1;  
    
  import java.awt.event.ActionEvent;  
  import java.awt.event.ActionListener;  
  import java.io.File;  
    
  import javax.swing.JTextArea;  
  import javax.swing.JTextField;  
    
  public class FileSearchListener implements ActionListener{  
    
     private JTextField tex;  
     private JTextArea area;  
    
     public FileSearchListener(JTextField tex,JTextArea area){  
         this.tex=tex;  
         this.area=area;  
     }  
    
     //打印某个目录下的文件名字，并返回文件个数  
     public int printDir(String dirName){  
         int filecount=0;  
         File dirFile = new File(dirName);  
         File[] subFile = dirFile.listFiles();//列表目录  
    
         if(null==subFile||subFile.length==0){//是空目录或者文件  
             return 0;  
         }  
         //遍历一级子目录  
         for(int i=0;i<subFile.length;i++){  
             if(subFile[i].isDirectory()){  
                 String subDir=subFile[i].getAbsolutePath();  
                 area.append("目录:"+subDir+"\n");  
                 //System.out.println("目录:"+subDir);  
                 filecount+=printDir(subDir);  
             }  
             if(subFile[i].isFile()){  
                 filecount++;  
                 String FileName=subFile[i].getAbsolutePath();  
                 area.append("文件："+FileName+"\n");  
                 //System.out.println("文件："+FileName);  
             }  
         }  
         return filecount;  
     }  
    
     @Override  
     public void actionPerformed(ActionEvent e) {  
         String str=tex.getText();  
         //printDir(str);  
         area.append(str+"目录下共找到文件个数是:"+printDir(str)+"\n");  
         //System.out.println(str+"目录下共找到文件个数是:"+printDir(str));  
    
     }  
    
  }  
    
    
    
  Java代码   
  package FileSeacher1;     
    
  import java.awt.event.ActionEvent;     
  import java.awt.event.ActionListener;     
    
  import javax.swing.JFileChooser;     
  import javax.swing.JTextField;     
    
  public class FileOpenListener implements ActionListener{     
    
     private JTextField tex;     
     private String path;     
    
     public FileOpenListener(JTextField tex){     
         this.tex=tex;     
     }     
    
     public void actionPerformed(ActionEvent e) {     
         //实例化一个文件选择器     
         JFileChooser chooser = new JFileChooser();     
         //设置为打开方式的文件选择器     
         chooser.setDialogType(JFileChooser.OPEN_DIALOG);     
         //设置只能打开文件目录     
         chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);     
         //获取文件选择其中按钮的信息     
         int t=chooser.showOpenDialog(null);     
         //当用户点击确定时,获得要搜索的文件名     
         if(t==chooser.APPROVE_OPTION){     
             path=chooser.getSelectedFile().getAbsolutePath();     
             tex.setText(path);     
             //System.out.println("要搜索的文件名是:"+tex);     
         }     
     }     
    
  }    
  package FileSeacher1;  
    
  import java.awt.event.ActionEvent;  
  import java.awt.event.ActionListener;  
    
  import javax.swing.JFileChooser;  
  import javax.swing.JTextField;  
    
  public class FileOpenListener implements ActionListener{  
    
     private JTextField tex;  
     private String path;  
    
     public FileOpenListener(JTextField tex){  
         this.tex=tex;  
     }  
    
     public void actionPerformed(ActionEvent e) {  
         //实例化一个文件选择器  
         JFileChooser chooser = new JFileChooser();  
         //设置为打开方式的文件选择器  
         chooser.setDialogType(JFileChooser.OPEN_DIALOG);  
         //设置只能打开文件目录  
         chooser.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);  
         //获取文件选择其中按钮的信息  
         int t=chooser.showOpenDialog(null);  
         //当用户点击确定时,获得要搜索的文件名  
         if(t==chooser.APPROVE_OPTION){  
             path=chooser.getSelectedFile().getAbsolutePath();  
             tex.setText(path);  
             //System.out.println("要搜索的文件名是:"+tex);  
         }  
     }  
    
  }  
    
    
    
  Int：用来定义一个整形变量  
    
  Float：用来定义一个浮点数变量   
  double ：双精度浮点值   
  boolean布尔类型，只有true或者false   
  byte ：字节型   
  char：用来定义一个字符类型，初始值是“/0”   
  long ：长整型，可以储存64位带符号的整数   
  short ：短整型，可以储存16位带符号的整数   
  null ：空；java的基本数据类型不能赋null，只能赋给引用类型   
  true 真   
  false 假  
    
  ===========================================================   
     2. 访问修饰符:  
         private 私有的，用在方法或属性中。表示这个方法或属性只能被这个类的其它元素所访问。子类不能访问父类的private方法。   
         protected 受保护的，在方法和属性中使用，它表示这个方法或属性只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。子类可以继承。   
         public 公共的，是公开性最高的，可以被其他包中的类调用   
         例：   
         Public class Test{   
     Private class A{}   
     Protected class B{}      内部类   
  }   
  Class C{   
  }                              在类外边不用任何修饰，默认是protected  
    
  ===========================================================   
     3. 循环语句  
     break 跳出本层循环   
     continue 打断当前循环过程   
     return 返回，用来结束一个方法的执行，传递与返回类型匹配的值   
     do  声明一个循环，并且至少循环一次，条件表达式后必有分号。   
     While 声明一个循环，循环的退出条件是while语句的一部分。   
     For 声明一个循环，可以指定要循环的语句，循环条件和初始化变量。   
     If  生成一个条件测试，如果条件为真，就执行if下的语句。   
     else 如果if语句的条件不满足就会执行该语句。   
     instanceof 实例，用来测试第一个参数的运行时类型是否和第二个参数兼容。   
     switch是一个选择语句，与case，default，break一起使用。   
     Case  定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。   
     default  case中没有找到匹配的值时，则输出或者为default后面的语句。  
    
     ===========================================================   
         4. 变量引用  
         this 表示当前对象，可以用来访问变量和方法。   
         例：   
         Public A(String name){   
         This.name=name;   
     }   
  Public A(){   
     This(“A”); //调用上面字符串类型的构造器   
  }   
  super 超类，指当前类的父类对象，可用于调用父类的方法名   
  public class A{   
     public A(String name){   
         This.name=name;   
     }   
  }  
    
  Public class B extends A{   
     Public B(String str ,int i){   
         Super(str);//调用父类的   
         This.i=i;   
     }   
  }   
  void 无返回值  
    
  ===========================================================   
     5. 类、方法和变量修饰符  
     abstract  可以修改类或方法，可以增加子类，但不能被实例化，方法在其子类中实现，不能用于static，private，final的方法中，因为这些方法不能被重写，也不能在子类中实现。   
     class 类   
     extends 扩允,继承   
     implements实现接口的关键字，用来指明当前类实现的接口。   
     interface 定义接口的关键字，用来定义一系列的方法和常量   
     native 本地   
     new用来创建一个新的对象   
     static 使用static限定的方法称为静态方法或类方法，非static方法的调用要通过创建类的对象，而static的方法则直接用 类名.静态方法名（）调用（五子棋里有应用）。当类的某一个对象的static属性值改变后，这个类所有对象的static属性值都会被改变   
     例：   
     Public class A{   
     Public  static void work(){   
     }   
     Public void play(){   
     }   
     Public static void mian（String args[ ]）{   
         A. work();   
         A a = new A();   
         a.play();   
     }   
  }   
  final 终极,不可改变的，final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值，放在属性前，属性的值就是常量，即这个属性的值不可改变。   
  strictfp 严格,精准   
  synchronized 线程,同步   
  transient用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的   
  volatile （易失）用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。  
    
  ===========================================================   
     6. 包相关  
     Import  引用的一个类或整个包（快捷键：ctrl+shift+O）   
     package 定义类的存放位置，即包  
    
     ===========================================================   
         7. 错误处理  
         catch 处理异常，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。   
         finally 有没有异常都执行   
         throw 抛出一个异常对象   
         throws 声明一个异常可能被抛出   
         try用来定义一个可能抛出异常语句块   
         =========================================  