Java IO流学习

本篇内容概述:
Java IO流【概念】【分类】【对象】
File类Reader类Writer类用法
用IO流和Swing制作简单记事本

目录:
1. 用IO流和Swing制作简单记事本
2.Java IO流详解
3.代码练习

Java流(Stream)概述

Java的IO流是实现输入/输出的基础,它可以方便地实现数据的输入/输出操作,在Java中把不同的输入/输出源抽象表述为”流”。流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。
流有输入和输出,输入时是流从数据源流向程序。输出时是流从程序传向数据源,而数据源可以是内存,文件,网络或程序等。

运用IO流和Swing实现简单记事本功能(打开、保存、退出)

实现思路与完整源码

Java IO流详解

Java流操作有关的类或接口:

Java流类图结构:

流的概念和作用

流是一组有顺序的,有起点和终点的字节集合,是对数据传输的总称或抽象。即数据在两设备间的传输称为流,流的本质是数据传输,根据数据传输特性将流抽象为各种类,方便更直观的进行数据操作。 

IO流的分类

  • 根据处理数据类型的不同分为:字符流和字节流
  • 根据数据流向不同分为:输入流和输出流

字符流和字节流

字符流的由来: 因为数据编码的不同,而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时,去查了指定的码表。 字节流和字符流的区别:

  • 读写单位不同:字节流以字节(8bit)为单位,字符流以字符为单位,根据码表映射字符,一次可能读多个字节。
  • 处理对象不同:字节流能处理所有类型的数据(如图片、avi等),而字符流只能处理字符类型的数据。

结论:只要是处理纯文本数据,就优先考虑使用字符流。 除此之外都使用字节流。

输入流和输出流

对输入流只能进行读操作,对输出流只能进行写操作,程序中需要根据待传输数据的不同特性而使用不同的流。  

Java IO流对象

1.输入字节流InputStreamIO 中输入字节流的继承图可见上图,可以看出:

  1. InputStream 是所有的输入字节流的父类,它是一个抽象类。
  2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流,它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据,与Piped 相关的知识后续单独介绍。
  3. ObjectInputStream 和所有FilterInputStream 的子类都是装饰流(装饰器模式的主角)。

2.输出字节流OutputStream

IO 中输出字节流的继承图可见上图,可以看出:

  1. OutputStream 是所有的输出字节流的父类,它是一个抽象类。
  2. ByteArrayOutputStream、FileOutputStream 是两种基本的介质流,它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据,
  3. ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

3.字节流的输入与输出的对应

图中蓝色的为主要的对应部分,红色的部分就是不对应部分。紫色的虚线部分代表这些流一般要搭配使用。从上面的图中可以看出Java IO 中的字节流是极其对称的。“存在及合理”我们看看这些字节流中不太对称的几个类吧!

  1. LineNumberInputStream 主要完成从流中读取数据时,会得到相应的行号,至于什么时候分行、在哪里分行是由改类主动确定的,并不是在原始中有这样一个行号。在输出部分没有对应的部分,我们完全可以自己建立一个LineNumberOutputStream,在最初写入时会有一个基准的行号,以后每次遇到换行时会在下一行添加一个行号,看起来也是可以的。好像更不入流了。
  2. PushbackInputStream 的功能是查看最后一个字节,不满意就放入缓冲区。主要用在编译器的语法、词法分析部分。输出部分的BufferedOutputStream 几乎实现相近的功能。
  3. StringBufferInputStream 已经被Deprecated,本身就不应该出现在InputStream 部分,主要因为String 应该属于字符流的范围。已经被废弃了,当然输出部分也没有必要需要它了!还允许它存在只是为了保持版本的向下兼容而已。
  4. SequenceInputStream 可以认为是一个工具类,将两个或者多个输入流当成一个输入流依次读取。完全可以从IO 包中去除,还完全不影响IO 包的结构,却让其更“纯洁”――纯洁的Decorator 模式。
  5. PrintStream 也可以认为是一个辅助工具。主要可以向其他输出流,或者FileInputStream 写入数据,本身内部实现还是带缓冲的。本质上是对其它流的综合运用的一个工具而已。一样可以踢出IO 包!System.out 和System.out 就是PrintStream 的实例!

4.字符输入流Reader

在上面的继承关系图中可以看出:

  1. Reader 是所有的输入字符流的父类,它是一个抽象类。
  2. CharReader、StringReader 是两种基本的介质流,它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
  3. BufferedReader 很明显就是一个装饰器,它和其子类负责装饰其它Reader 对象。
  4. FilterReader 是所有自定义具体装饰流的父类,其子类PushbackReader 对Reader 对象进行装饰,会增加一个行号。
  5. InputStreamReader 是一个连接字节流和字符流的桥梁,它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类,在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。

5.字符输出流Writer

在上面的关系图中可以看出:

  1. Writer 是所有的输出字符流的父类,它是一个抽象类。
  2. CharArrayWriter、StringWriter 是两种基本的介质流,它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据,
  3. BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
  4. PrintWriter 和PrintStream 极其类似,功能和使用也非常相似。
  5. OutputStreamWriter 是OutputStream 到Writer 转换的桥梁,它的子类FileWriter 其实就是一个实现此功能的具体类(具体可以研究一SourceCode)。功能和使用和OutputStream 极其类似,后面会有它们的对应图。

6.字符流的输入与输出的对应

7.字符流与字节流转换

转换流的特点:

  1. 其是字符流和字节流之间的桥梁
  2. 可对读取到的字节数据经过指定编码转换成字符
  3. 可对读取到的字符数据经过指定编码转换成字节

何时使用转换流?

  1. 当字节和字符之间有转换动作时;
  2. 流操作的数据需要编码或解码时。

具体的对象体现:

  1. InputStreamReader:字节到字符的桥梁
  2. OutputStreamWriter:字符到字节的桥梁

这两个流对象是字符体系中的成员,它们有转换作用,本身又是字符流,所以在构造的时候需要传入字节流对象进来。

8.File类

File类是对文件系统中文件以及文件夹进行封装的对象,可以通过对象的思想来操作文件和文件夹。 File类保存文件或目录的各种元数据信息,包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名,判断指定文件是否存在、获得当前目录中的文件列表,创建、删除文件和目录等方法。  

9.RandomAccessFile类

该对象并不是流体系中的一员,其封装了字节流,同时还封装了一个缓冲区(字符数组),通过内部的指针来操作字符数组中的数据。 该对象特点:

  1. 该对象只能操作文件,所以构造函数接收两种类型的参数:a.字符串文件路径;b.File对象。
  2. 该对象既可以对文件进行读操作,也能进行写操作,在进行对象实例化时可指定操作模式(r,rw)

注意:该对象在实例化时,如果要操作的文件不存在,会自动创建;如果文件存在,写数据未指定位置,会从头开始写,即覆盖原有的内容。 可以用于多线程下载或多个线程同时写数据到文件。

代码练习

InputStream 和 OutputStream 用法的例子:

import java.io.*;
 
public class fileStreamTest {
    public static void main(String args[]) {
        try {
            byte bWrite[] = { 11, 21, 3, 40, 5 };
            OutputStream os = new FileOutputStream("test.txt");
            for (int x = 0; x < bWrite.length; x++) {
                os.write(bWrite[x]); // writes the bytes
            }
            os.close();
 
            InputStream is = new FileInputStream("test.txt");
            int size = is.available();
 
            for (int i = 0; i < size; i++) {
                System.out.print((char) is.read() + "  ");
            }
            is.close();
        } catch (IOException e) {
            System.out.print("Exception");
        }
    }
}

上面的程序首先创建文件test.txt,并把给定的数字以二进制形式写进该文件,同时输出到控制台上。

以上代码由于是二进制写入,可能存在乱码,你可以使用以下代码实例来解决乱码问题:

//文件名 :fileStreamTest2.java
import java.io.*;
 
public class fileStreamTest2 {
    public static void main(String[] args) throws IOException {
 
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建
 
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
 
        writer.append("中文输入");
        // 写入到缓冲区
 
        writer.append("\r\n");
        // 换行
 
        writer.append("English");
        // 刷新缓存冲,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
 
        writer.close();
        // 关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
 
        fop.close();
        // 关闭输出流,释放系统资源
 
        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象
 
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同
 
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
            sb.append((char) reader.read());
            // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流
 
        fip.close();
        // 关闭输入流,释放系统资源
 
    }
}

File类文件操作大全

//1.创建文件夹   
//import java.io.*;   
File myFolderPath = new File(str1);   
try {   
    if (!myFolderPath.exists()) {   
       myFolderPath.mkdir();   
    }   
}   
catch (Exception e) {   
    System.out.println("新建目录操作出错");   
    e.printStackTrace();   
}    
  
//2.创建文件   
//import java.io.*;   
File myFilePath = new File(str1);   
try {   
    if (!myFilePath.exists()) {   
        myFilePath.createNewFile();   
    }   
    FileWriter resultFile = new FileWriter(myFilePath);   
    PrintWriter myFile = new PrintWriter(resultFile);   
    myFile.println(str2);   
    resultFile.close();   
}   
catch (Exception e) {   
    System.out.println("新建文件操作出错");   
    e.printStackTrace();   
}    
  
//3.删除文件   
//import java.io.*;   
File myDelFile = new File(str1);   
try {   
    myDelFile.delete();   
}   
catch (Exception e) {   
    System.out.println("删除文件操作出错");   
    e.printStackTrace();   
}    
  
//4.删除文件夹   
//import java.io.*;   
File delFolderPath = new File(str1);   
try {   
    delFolderPath.delete(); //删除空文件夹   
}   
catch (Exception e) {   
    System.out.println("删除文件夹操作出错");   
    e.printStackTrace();   
}    
  
//5.删除一个文件下夹所有的文件夹   
//import java.io.*;   
File delfile=new File(str1);   
File[] files=delfile.listFiles();   
for(int i=0;i<files.length;i++){   
    if(files[i].isDirectory()){   
        files[i].delete();   
    }   
}     
   
//6.清空文件夹   
//import java.io.*;   
File delfilefolder=new File(str1);   
try {   
    if (!delfilefolder.exists()) {   
        delfilefolder.delete();   
    }   
    delfilefolder.mkdir();   
}   
catch (Exception e) {   
    System.out.println("清空目录操作出错");   
    e.printStackTrace();   
}    
  
//7.读取文件   
//import java.io.*;   
// 逐行读取数据   
FileReader fr = new FileReader(str1);   
BufferedReader br = new BufferedReader(fr);   
String str2 = br.readLine();   
while (str2 != null) {   
    str3   
    str2 = br.readLine();   
}   
br.close();   
fr.close();    
  
//8.写入文件   
//import java.io.*;   
// 将数据写入文件   
try {   
    FileWriter fw = new FileWriter(str1);   
    fw.write(str2);   
    fw.flush();   
    fw.close();    
} catch (IOException e) {   
    e.printStackTrace();   
}   
  
//9.写入随机文件   
//import java.io.*;   
try {   
    RandomAcessFile logFile=new RandomAcessFile(str1,"rw");   
    long lg=logFile.length();   
    logFile.seek(str2);   
    logFile.writeByte(str3);   
}catch(IOException ioe){   
    System.out.println("无法写入文件:"+ioe.getMessage());   
}    
  
//10.读取文件属性   
//import java.io.*;   
// 文件属性的取得   
File f = new File(str1);   
if (af.exists()) {   
    System.out.println(f.getName() + "的属性如下: 文件长度为:" + f.length());   
    System.out.println(f.isFile() ? "是文件" : "不是文件");   
    System.out.println(f.isDirectory() ? "是目录" : "不是目录");   
    System.out.println(f.canRead() ? "可读取" : "不");   
    System.out.println(f.canWrite() ? "是隐藏文件" : "");   
    System.out.println("文件夹的最后修改日期为:" + new Date(f.lastModified()));   
    } else {   
    System.out.println(f.getName() + "的属性如下:");   
    System.out.println(f.isFile() ? "是文件" : "不是文件");   
    System.out.println(f.isDirectory() ? "是目录" : "不是目录");   
    System.out.println(f.canRead() ? "可读取" : "不");   
    System.out.println(f.canWrite() ? "是隐藏文件" : "");   
    System.out.println("文件的最后修改日期为:" + new Date(f.lastModified()));   
}   
if(f.canRead()){   
    str2   
}   
if(f.canWrite()){   
    str3   
}   
  
//11.写入属性   
//import java.io.*;   
File filereadonly=new File(str1);   
try {   
    boolean b=filereadonly.setReadOnly();   
}   
catch (Exception e) {   
    System.out.println("拒绝写访问:"+e.printStackTrace());   
}    
  
//12.枚举一个文件夹中的所有文件   
//import java.io.*;   
//import java.util.*;   
LinkedList<String> folderList = new LinkedList<String>();   
folderList.add(str1);   
while (folderList.size() > 0) {   
    File file = new File(folderList.peek());   
    folderList.removeLast();   
    File[] files = file.listFiles();   
    ArrayList<File> fileList = new ArrayList<File>();   
    for (int i = 0; i < files.length; i++) {   
        if (files[i].isDirectory()) {   
            folderList.add(files[i].getPath());   
        } else {   
            fileList.add(files[i]);   
        }   
    }   
    for (File f : fileList) {   
        str2=f.getAbsoluteFile();   
        str3   
    }   
}   
  
//13.复制文件夹    
//import java.io.*;   
//import java.util.*;   
LinkedList<String> folderList = new LinkedList<String>();   
folderList.add(str1);   
LinkedList<String> folderList2 = new LinkedList<String>();   
folderList2.add(str2+ str1.substring(str1.lastIndexOf("\\")));   
while (folderList.size() > 0) {   
    (new File(folderList2.peek())).mkdirs(); // 如果文件夹不存在 则建立新文件夹   
    File folders = new File(folderList.peek());   
    String[] file = folders.list();   
    File temp = null;   
    try {   
        for (int i = 0; i < file.length; i++) {   
            if (folderList.peek().endsWith(File.separator)) {   
                temp = new File(folderList.peek() + File.separator   
                + file[i]);   
            } else {   
                temp = new File(folderList.peek() + File.separator + file[i]);   
            }   
            if (temp.isFile()) {   
                FileInputStream input = new FileInputStream(temp);   
                FileOutputStream output = new FileOutputStream(   
                folderList2.peek() + File.separator + (temp.getName()).toString());   
                byte[] b = new byte[5120];   
                int len;   
                while ((len = input.read(b)) != -1) {   
                    output.write(b, 0, len);   
                }   
                output.flush();   
                output.close();   
                input.close();   
            }   
            if (temp.isDirectory()) {// 如果是子文件夹   
                for (File f : temp.listFiles()) {   
                    if (f.isDirectory()) {   
                        folderList.add(f.getPath());   
                        folderList2.add(folderList2.peek()   
                        + File.separator + f.getName());   
                    }   
                }   
            }   
        }   
    } catch (Exception e) {   
    //System.out.println("复制整个文件夹内容操作出错");   
        e.printStackTrace();   
    }   
    folderList.removeFirst();   
    folderList2.removeFirst();   
}   
  
//14.复制一个文件夹下所有的文件夹到另一个文件夹下   
//import java.io.*;   
//import java.util.*;   
File copyfolders=new File(str1);   
File[] copyfoldersList=copyfolders.listFiles();   
for(int k=0;k<copyfoldersList.length;k++){   
    if(copyfoldersList[k].isDirectory()){   
        ArrayList<String>folderList=new ArrayList<String>();   
        folderList.add(copyfoldersList[k].getPath());   
        ArrayList<String>folderList2=new ArrayList<String>();   
        folderList2.add(str2+"/"+copyfoldersList[k].getName());   
        for(int j=0;j<folderList.length;j++){   
             (new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在 则建立新文件夹   
             File folders=new File(folderList.get(j));   
             String[] file=folders.list();   
             File temp=null;   
             try {   
                 for (int i = 0; i < file.length; i++) {   
                     if(folderList.get(j).endsWith(File.separator)){   
                         temp=new File(folderList.get(j)+"/"+file[i]);   
                     } else {   
                         temp=new File(folderList.get(j)+"/"+File.separator+file[i]);   
                     }   
                     FileInputStream input = new FileInputStream(temp);   
                     if(temp.isFile()){   
                         FileInputStream input = new FileInputStream(temp);   
                         FileOutputStream output = new FileOutputStream(folderList2.get(j) + "/" + (temp.getName()).toString());   
                         byte[] b = new byte[5120];   
                         int len;   
                         while ( (len = input.read(b)) != -1) {   
                             output.write(b, 0, len);   
                         }   
                         output.flush();   
                         output.close();   
                         input.close();   
                     }   
                     if(temp.isDirectory()){//如果是子文件夹   
                         folderList.add(folderList.get(j)+"/"+file[i]);   
                         folderList2.add(folderList2.get(j)+"/"+file[i]);   
                     }   
                 }   
             }   
             catch (Exception e) {   
                 System.out.println("复制整个文件夹内容操作出错");   
                 e.printStackTrace();   
             }   
        }   
    }   
}   
  
//15.移动文件夹   
//import java.io.*;   
//import java.util.*;   
LinkedList<String> folderList = new LinkedList<String>();   
folderList.add(str1);   
LinkedList<String> folderList2 = new LinkedList<String>();   
folderList2.add(str2 + str1.substring(str1.lastIndexOf("\\")));   
while (folderList.size() > 0) {   
    (new File(folderList2.peek())).mkdirs(); // 如果文件夹不存在 则建立新文件夹   
    File folders = new File(folderList.peek());   
    String[] file = folders.list();   
    File temp = null;   
    try {   
        for (int i = 0; i < file.length; i++) {   
            if (folderList.peek().endsWith(File.separator)) {   
                temp = new File(folderList.peek() + File.separator + file[i]);   
            } else {   
                temp = new File(folderList.peek() + File.separator + file[i]);   
            }   
            if (temp.isFile()) {   
                FileInputStream input = new FileInputStream(temp);   
                FileOutputStream output = new FileOutputStream(   
                folderList2.peek() + File.separator + (temp.getName()).toString());   
                byte[] b = new byte[5120];   
                int len;   
                while ((len = input.read(b)) != -1) {   
                    output.write(b, 0, len);   
                }   
                output.flush();   
                output.close();   
                input.close();   
                if (!temp.delete())   
                System.out.println("删除单个文件操作出错!");   
            }   
            if (temp.isDirectory()) {// 如果是子文件夹   
                for (File f : temp.listFiles()) {   
                    if (f.isDirectory()) {   
                        folderList.add(f.getPath());   
                        folderList2.add(folderList2.peek() + File.separator + f.getName());   
                    }   
                }   
            }   
        }   
    } catch (Exception e) {   
        // System.out.println("复制整个文件夹内容操作出错");   
        e.printStackTrace();   
    }   
    folderList.removeFirst();   
    folderList2.removeFirst();   
}   
File f = new File(str1);   
if (!f.delete()) {   
    for (File file : f.listFiles()) {   
        if (file.list().length == 0) {   
            System.out.println(file.getPath());   
            file.delete();   
        }   
    }   
}   
//16.移动一个文件夹下所有的文件夹到另一个目录下   
//import java.io.*;   
//import java.util.*;   
File movefolders=new File(str1);   
File[] movefoldersList=movefolders.listFiles();   
for(int k=0;k<movefoldersList.length;k++){   
    if(movefoldersList[k].isDirectory()){   
        ArrayList<String>folderList=new ArrayList<String>();   
        folderList.add(movefoldersList[k].getPath());   
        ArrayList<String>folderList2=new ArrayList<String>();   
        folderList2.add(str2+"/"+movefoldersList[k].getName());   
        for(int j=0;j<folderList.length;j++){   
             (new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在 则建立新文件夹   
             File folders=new File(folderList.get(j));   
             String[] file=folders.list();   
             File temp=null;   
             try {   
                 for (int i = 0; i < file.length; i++) {   
                     if(folderList.get(j).endsWith(File.separator)){   
                         temp=new File(folderList.get(j)+"/"+file[i]);   
                     }   
                     else{   
                         temp=new File(folderList.get(j)+"/"+File.separator+file[i]);   
                     }   
                     FileInputStream input = new FileInputStream(temp);   
                     if(temp.isFile()){   
                         FileInputStream input = new FileInputStream(temp);   
                         FileOutputStream output = new FileOutputStream(folderList2.get(j) + "/" + (temp.getName()).toString());   
                         byte[] b = new byte[5120];   
                         int len;   
                         while ( (len = input.read(b)) != -1) {   
                             output.write(b, 0, len);   
                         }   
                         output.flush();   
                         output.close();   
                         input.close();   
                         temp.delete();   
                     }   
                     if(temp.isDirectory()){//如果是子文件夹   
                         folderList.add(folderList.get(j)+"/"+file[i]);   
                         folderList2.add(folderList2.get(j)+"/"+file[i]);   
                     }   
                 }   
             }   
             catch (Exception e) {   
                 System.out.println("复制整个文件夹内容操作出错");   
                 e.printStackTrace();   
             }   
        }   
        movefoldersList[k].delete();   
    }   
}   
  
//17.以一个文件夹的框架在另一个目录创建文件夹和空文件   
//import java.io.*;   
//import java.util.*;   
boolean b=false;//不创建空文件   
ArrayList<String>folderList=new ArrayList<String>();   
folderList.add(str1);   
ArrayList<String>folderList2=new ArrayList<String>();   
folderList2.add(str2);   
for(int j=0;j<folderList.length;j++){   
    (new File(folderList2.get(j))).mkdirs(); //如果文件夹不存在 则建立新文件夹   
    File folders=new File(folderList.get(j));   
    String[] file=folders.list();   
    File temp=null;   
    try {   
        for (int i = 0; i < file.length; i++) {   
            if(folderList.get(j).endsWith(File.separator)){   
                temp=new File(folderList.get(j)+"/"+file[i]);   
            }   
            else{   
                temp=new File(folderList.get(j)+"/"+File.separator+file[i]);   
            }   
            FileInputStream input = new FileInputStream(temp);   
            if(temp.isFile()){   
                if (b) temp.createNewFile();   
            }   
            if(temp.isDirectory()){//如果是子文件夹   
                folderList.add(folderList.get(j)+"/"+file[i]);   
                folderList2.add(folderList2.get(j)+"/"+file[i]);   
            }   
        }   
    }   
    catch (Exception e) {   
        System.out.println("复制整个文件夹内容操作出错");   
        e.printStackTrace();   
    }   
}   
  
//18.复制文件   
//import java.io.*;   
 int bytesum = 0;   
 int byteread = 0;   
 File oldfile = new File(str1);   
 try {   
 if (oldfile.exists()) { //文件存在时   
 FileInputStream inStream = new FileInputStream(oldfile); //读入原文件   
 FileOutputStream fs = new FileOutputStream(new File(str2,oldfile.getName()));   
 byte[] buffer = new byte[5120];   
 int length;   
 while ( (byteread = inStream.read(buffer)) != -1) {   
 bytesum += byteread; //字节数 文件大小   
 System.out.println(bytesum);   
 fs.write(buffer, 0, byteread);   
 }   
 inStream.close();   
 }   
 }   
 catch (Exception e) {   
 System.out.println("复制单个文件操作出错");   
 e.printStackTrace();   
 }    
  
//19.复制一个文件夹下所有的文件到另一个目录   
//import java.io.*;   
File copyfiles=new File(str1);   
File[] files=copyfiles.listFiles();   
for(int i=0;i<files.length;i++){   
    if(!files[i].isDirectory()){   
        int bytesum = 0;   
        int byteread = 0;   
        try {   
            InputStream inStream = new FileInputStream(files[i]); //读入原文件   
            FileOutputStream fs = new FileOutputStream(new File(str2,files[i].getName());   
            byte[] buffer = new byte[5120];   
            int length;   
            while ( (byteread = inStream.read(buffer)) != -1) {   
                bytesum += byteread; //字节数 文件大小   
                System.out.println(bytesum);   
                fs.write(buffer, 0, byteread);   
            }   
            inStream.close();   
        } catch (Exception e) {   
            System.out.println("复制单个文件操作出错");   
            e.printStackTrace();   
        }   
    }   
}    
  
//提取扩展名   
String str2=str1.substring(str1.lastIndexOf(".")+1);

[记事本] 实现思路及步骤

1.在构造函数中画出操作界面

//创建jta
        jta = new JTextArea();
        jmb = new JMenuBar();
        jml = new JMenu("菜单(M)");
        //设置助记符
        jml.setMnemonic('M');

        //打开按钮
        jmi1 = new JMenuItem("打开", new ImageIcon("edit.gif"));
        //添加图标的第二种方法
        //ImageIcon ic = new ImageIcon("edit.gif");
        //jmi1.setIcon(ic);
        //保存按钮
        jmi2 = new JMenuItem("保存");
        //退出按钮
        jmi3 = new JMenuItem("退出");

        //放入控件
        this.setJMenuBar(jmb);
        //把JMenu放入到JMenuBar
        jmb.add(jml);
        //把item放入到Menu中去
        jml.add(jmi1);
        jml.add(jmi2);
        jml.add(jmi3);

        //放入到JFrame里
        this.add(jta);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 300);
        this.setVisible(true);

2.注册监听事件(判断点了哪个按钮)

//进行注册监听
        //打开
        jmi1.addActionListener(this);
        jmi1.setActionCommand("open");
        //保存
        jmi2.addActionListener(this);
        jmi2.setActionCommand("save");
        //退出
        jmi3.addActionListener(this);
        jmi3.setActionCommand("quit");

3.根据事件反馈判断要进行的操作(根据点击的按钮来判断要做什么事)

①打开

if (e.getActionCommand().equals("open")) {
            //JFileChooser文件选择组件
            JFileChooser jfc1 = new JFileChooser();
            //设置名字
            jfc1.setDialogTitle("请选择文件...");

            jfc1.showOpenDialog(null);
            //显示
            jfc1.setVisible(true);

            String file = null;
            try {
                //得到用户选择的文件绝对(全)路径
                file = jfc1.getSelectedFile().getAbsolutePath();

                //System.out.println(filename);
                FileReader fr = null;
                BufferedReader br = null;
                try {
                    fr = new FileReader(file);
                    br = new BufferedReader(fr);
                    //从文件中读取信息并显示到jta
                    String s = "";
                    String allCon = "";
                    while ((s = br.readLine()) != null) {
                        allCon += s + "\r\n";
                    }

                    //放置到jta即可
                    jta.setText(allCon);

                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    try {
                        if (br != null && fr != null) {
                            br.close();
                            fr.close();
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            } catch (Exception ex) {
                System.out.println("未选中文件");
                //ex.printStackTrace();
            }
        }

②保存

if (e.getActionCommand().equals("save")) {
            //出现保存对话框
            JFileChooser jfc = new JFileChooser();
            jfc.setDialogTitle("另存为...");
            //按默认的方式显示
            jfc.showSaveDialog(null);
            jfc.setVisible(true);

            String file = null;
            try {
                //得到用户希望把文件保存到的地址(文件绝对路径)
                file = jfc.getSelectedFile().getAbsolutePath();

                //写入到指定文件
                FileWriter fw = null;
                BufferedWriter bw = null;
                try {
                    fw = new FileWriter(file);
                    bw = new BufferedWriter(fw);

                    bw.write(this.jta.getText());
                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    try {
                        //bw和fw的关闭顺序不能写反,否则会报错
                        if (bw != null && fw != null) {
                            bw.close();
                            fw.close();
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            } catch (Exception ex) {
                System.out.println("未选中文件");
                //ex.printStackTrace();
                //System.out.println(ex.getMessage());
            }
        }

③退出

if (e.getActionCommand().equals("quit")) {
       System.exit(0);
}

附上完整代码:

/**
 * 我的记事本(界面+功能)
 */
package com.test3;

import javax.swing.*;
import java.awt.event.*;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;

public class NotePad extends JFrame implements ActionListener {
    //定义需要的组件
    JTextArea jta = null;

    //菜单条
    JMenuBar jmb = null;

    //定义JMenu(菜单栏按钮)
    JMenu jml = null;

    //定义JMenuItem(功能按钮)
    JMenuItem jmi1 = null;
    JMenuItem jmi2 = null;
    JMenuItem jmi3 = null;

    public static void main(String[] args) {
        NotePad notePad = new NotePad();
    }

    //构造函数
    public NotePad() {
        //创建jta
        jta = new JTextArea();
        jmb = new JMenuBar();
        jml = new JMenu("菜单(M)");
        //设置助记符
        jml.setMnemonic('M');

        //打开按钮
        jmi1 = new JMenuItem("打开", new ImageIcon("edit.gif"));
        //添加图标的第二种方法
        //ImageIcon ic = new ImageIcon("edit.gif");
        //jmi1.setIcon(ic);
        //保存按钮
        jmi2 = new JMenuItem("保存");
        //退出按钮
        jmi3 = new JMenuItem("退出");

        Listen();

        //放入控件
        this.setJMenuBar(jmb);
        //把JMenu放入到JMenuBar
        jmb.add(jml);
        //把item放入到Menu中去
        jml.add(jmi1);
        jml.add(jmi2);
        jml.add(jmi3);

        //放入到JFrame里
        this.add(jta);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setSize(400, 300);
        this.setVisible(true);
    }

    //监听事件
    public void Listen()
    {
        //进行注册监听
        //打开
        jmi1.addActionListener(this);
        jmi1.setActionCommand("open");
        //保存
        jmi2.addActionListener(this);
        jmi2.setActionCommand("save");
        //退出
        jmi3.addActionListener(this);
        jmi3.setActionCommand("quit");
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        //判断触发了哪个功能按钮
        //打开
        if (e.getActionCommand().equals("open")) {
            //JFileChooser文件选择组件
            JFileChooser jfc1 = new JFileChooser();
            //设置名字
            jfc1.setDialogTitle("请选择文件...");

            jfc1.showOpenDialog(null);
            //显示
            jfc1.setVisible(true);

            String file = null;
            try {
                //得到用户选择的文件绝对(全)路径
                file = jfc1.getSelectedFile().getAbsolutePath();

                //System.out.println(filename);
                FileReader fr = null;
                BufferedReader br = null;
                try {
                    fr = new FileReader(file);
                    br = new BufferedReader(fr);
                    //从文件中读取信息并显示到jta
                    String s = "";
                    String allCon = "";
                    while ((s = br.readLine()) != null) {
                        allCon += s + "\r\n";
                    }

                    //放置到jta即可
                    jta.setText(allCon);

                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    try {
                        if (br != null && fr != null) {
                            br.close();
                            fr.close();
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            } catch (Exception ex) {
                System.out.println("未选中文件");
                //ex.printStackTrace();
            }
        }
        //保存
        else if (e.getActionCommand().equals("save")) {
            //出现保存对话框
            JFileChooser jfc = new JFileChooser();
            jfc.setDialogTitle("另存为...");
            //按默认的方式显示
            jfc.showSaveDialog(null);
            jfc.setVisible(true);

            String file = null;
            try {
                //得到用户希望把文件保存到的地址(文件绝对路径)
                file = jfc.getSelectedFile().getAbsolutePath();

                //写入到指定文件
                FileWriter fw = null;
                BufferedWriter bw = null;
                try {
                    fw = new FileWriter(file);
                    bw = new BufferedWriter(fw);

                    bw.write(this.jta.getText());
                } catch (Exception ex) {
                    ex.printStackTrace();
                } finally {
                    try {
                        //bw和fw的关闭顺序不能写反,否则会报错
                        if (bw != null && fw != null) {
                            bw.close();
                            fw.close();
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }
            } catch (Exception ex) {
                System.out.println("未选中文件");
                //ex.printStackTrace();
                //System.out.println(ex.getMessage());
            }
        }
        //退出
        else if (e.getActionCommand().equals("quit")) {
            System.exit(0);
        }
    }
}

作者:

喜欢围棋和编程。

 
发布于 分类 编程标签

发表回复

您的电子邮箱地址不会被公开。 必填项已用 * 标注