转载Java File操作汇总

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了转载Java File操作汇总相关的知识，希望对你有一定的参考价值。

转载自博客：https://passport.cnblogs.com/user/signin?ReturnUrl=https%3A%2F%2Fwww.cnblogs.com%2F

本文通过大量的示例，介绍和讲解了Java File操作。

1）创建文件 2）删除文件 3）判断文件是否存在 4）创建文件夹 5）文件类型判断 6）获取文件信息

7）获取目录下文件名 8）递归打印所有文件名 9）递归删除整个文件夹 10）Properties类

11）SequenceInputStream类：连接多个流 12）对象序列化实现Serializable接口 13）管道流

14）RandomAccessFile类 15）DataStream类 16)ByteArrayStream类

1、创建文件

1）boolean java.io.File.createNewFile() throws IOException用来创建文件，如果文件存在，创建失败，返回false；

2）new File("a.txt");并不创建文件实体，只是创建一个指向“a.txt”的引用。

3）路径分隔符：File.separator

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  
    //new File()就相当于是C语言中定义一个指向“a.txt”的文件指针   
    File f1 = new File("a.txt");  
    try   
    {  
        //创建文件:boolean java.io.File.createNewFile() throws IOException   
        boolean b = f1.createNewFile();  
        //第二次将会创建失败false，这里和流不一样   
        System.out.println(b);  
    }   
    catch (Exception e)   
    {  
        // TODO: handle exception   
    }  
    //目录分隔符：File.separator，相当于“\\\\”跨平台。   
    //File f2 = new File("E:\\\\tmp","b.txt");   
    File f2 = new File("E:"+File.separator+"tmp","b.txt");  
    System.out.println(f2);  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {
    //new File()就相当于是C语言中定义一个指向“a.txt”的文件指针
    File f1 = new File("a.txt");
    try 
    {
        //创建文件:boolean java.io.File.createNewFile() throws IOException
        boolean b = f1.createNewFile();
        //第二次将会创建失败false，这里和流不一样
        System.out.println(b);
    } 
    catch (Exception e) 
    {
        // TODO: handle exception
    }
    //目录分隔符：File.separator，相当于“\\\\”跨平台。
    //File f2 = new File("E:\\\\tmp","b.txt");
    File f2 = new File("E:"+File.separator+"tmp","b.txt");
    System.out.println(f2);
}

}

2、删除文件

1）delete()：删除文件成功返回true，删除失败返回false（ boolean java.io.File.delete() ）

2）deleteOnExit()：程序退出时，自动删除文件。一般用于对程序创建的临时文件进行操作，退出时删除。（ void java.io.File.deleteOnExit() ）

[java] view plain copy print?package file.dol.sn;

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File f1 = new File("a.txt");  
    try   
    {  
        boolean b = f1.createNewFile();  
        //删除文件：boolean java.io.File.delete()   
        f1.delete();  
        //程序退出时，自动删除：void java.io.File.deleteOnExit()   
        //f1.deleteOnExit();   
    }   
    catch (Exception e)   
    {  
        // TODO: handle exception   
    }  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File f1 = new File("a.txt");
    try 
    {
        boolean b = f1.createNewFile();
        //删除文件：boolean java.io.File.delete()
        f1.delete();
        //程序退出时，自动删除：void java.io.File.deleteOnExit()
        //f1.deleteOnExit();
    } 
    catch (Exception e) 
    {
        // TODO: handle exception
    }
}

}3、判断文件是否存在

exists()：判断文件是否存在（ boolean java.io.File.exists() ）

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File f1 = new File("not.txt");  
    //判断文件是否存在：boolean java.io.File.exists()   
    boolean b = f1.exists();  
    System.out.println(b);  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File f1 = new File("not.txt");
    //判断文件是否存在：boolean java.io.File.exists()
    boolean b = f1.exists();
    System.out.println(b);
}

}4、创建文件夹

1）mkdir()：只能创建“一级目录”（boolean java.io.File.mkdir()）；

2）mkdirs()：可以创建多级目录（boolean java.io.File.mkdirs()）。

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File dir1 = new File("abc");  
    File dir2 = new File("a\\\\b\\\\c\\\\d");  
    try   
    {  
        //创建文件目录(即文件夹)：boolean java.io.File.mkdir()   
        //该方法只能创建“一级”目录   
        boolean b =  dir1.mkdir();  
        System.out.println(b);  
        //创建多级文件夹：boolean java.io.File.mkdirs()   
        b =  dir2.mkdirs();  
        System.out.println(b);  
    }   
    catch (Exception e)   
    {  
        System.out.println(e.toString());  
    }  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File dir1 = new File("abc");
    File dir2 = new File("a\\\\b\\\\c\\\\d");
    try 
    {
        //创建文件目录(即文件夹)：boolean java.io.File.mkdir()
        //该方法只能创建“一级”目录
        boolean b =  dir1.mkdir();
        System.out.println(b);
        //创建多级文件夹：boolean java.io.File.mkdirs()
        b =  dir2.mkdirs();
        System.out.println(b);
    } 
    catch (Exception e) 
    {
        System.out.println(e.toString());
    }
}

}5、文件类型判断

1）exists()：判断文件是否存在，注意：一定要先判断这个；

2）isDirectory()：判断是否为文件夹；

3）isFile()：判断是否为文件；

4）isHidden()：判断是否为隐藏文件；

5）isAbsolute()：判断是否为绝对路径，这里不管文件是否存在都能判断。

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File f = new File("C:\\\\abc.txt");  
    try   
    {  
        //判断文件是否存在   
        if (f.exists())  
        {  
            //判断文件是否是文件夹   
            if (f.isDirectory())  
            {  
                System.out.println("文件夹");  
            }  
            //判断文件是否是文件   
            if (f.isFile())  
            {  
                System.out.println("文件");  
            }  
            //判断是否为隐藏文件   
            if (f.isHidden())  
            {  
                System.out.println("隐藏文件");  
            }  
        }  
        else   
        {  
            System.out.println("文件不存在");  
        }  
        //判断是否为绝对路径，不管文件是否存在   
        if (f.isAbsolute())  
        {  
            System.out.println("是绝对路径");  
        }  
    }   
    catch (Exception e)   
    {  
        System.out.println(e.toString());  
    }  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File f = new File("C:\\\\abc.txt");
    try 
    {
        //判断文件是否存在
        if (f.exists())
        {
            //判断文件是否是文件夹
            if (f.isDirectory())
            {
                System.out.println("文件夹");
            }
            //判断文件是否是文件
            if (f.isFile())
            {
                System.out.println("文件");
            }
            //判断是否为隐藏文件
            if (f.isHidden())
            {
                System.out.println("隐藏文件");
            }
        }
        else 
        {
            System.out.println("文件不存在");
        }
        //判断是否为绝对路径，不管文件是否存在
        if (f.isAbsolute())
        {
            System.out.println("是绝对路径");
        }
    } 
    catch (Exception e) 
    {
        System.out.println(e.toString());
    }
}

}6、获取文件信息

1）getName()：获取文件名；

2）getParent()：获取文件父目录；

3）getPath()：获取文件路径；

4）getAbsolutePath()：获取文件绝对路径；

5）lastModified()：获得文件最后一次被修改的时间；

6）length()：获取文件大小；

7）renameTo()：文件剪切，将文件f1剪切然后粘贴到f2（相当于右键f1->剪切->粘贴->f2所在目录）

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File f1 = new File("abc.txt");  
    File f2 = new File("E:\\\\Java\\\\test.txt");  
    try   
    {  
        //获得文件名   
        System.out.println(f1.getName());  
        //获得绝对路径中的父目录，如：File("abc.txt")则该返回为null   
        System.out.println(f1.getParent());  
        //获得相对路径   
        System.out.println(f1.getPath());  
        //获得绝对路径   
        System.out.println(f1.getAbsolutePath());  
        //获得文件最后一次被修改的时间   
        System.out.println(f1.lastModified());  
        //获得文件大小   
        System.out.println(f1.length());  
        //文件剪切，将文件f1剪切然后粘贴到f2（相当于右键f1->剪切->粘贴->f2所在目录）   
        f1.renameTo(f2);  
    }   
    catch (Exception e)   
    {  
        System.out.println(e.toString());  
    }  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File f1 = new File("abc.txt");
    File f2 = new File("E:\\\\Java\\\\test.txt");
    try 
    {
        //获得文件名
        System.out.println(f1.getName());
        //获得绝对路径中的父目录，如：File("abc.txt")则该返回为null
        System.out.println(f1.getParent());
        //获得相对路径
        System.out.println(f1.getPath());
        //获得绝对路径
        System.out.println(f1.getAbsolutePath());
        //获得文件最后一次被修改的时间
        System.out.println(f1.lastModified());
        //获得文件大小
        System.out.println(f1.length());
        //文件剪切，将文件f1剪切然后粘贴到f2（相当于右键f1->剪切->粘贴->f2所在目录）
        f1.renameTo(f2);
    } 
    catch (Exception e) 
    {
        System.out.println(e.toString());
    }
}

}7、获取目录下文件名

1）listRoots()：获取系统盘符；

2）list()：获取“X:\\”目录下的所有文件名，包括隐藏文件和文件夹（调用list()方法时，必须先封装一个目录，且必须存在的目录。）

3）list(FilenameFilter filter)：列出文件名的时候，可以进行过滤操作（如：列出后缀名为.txt的文件）。

4）listFiles()：列出目录下文件名，不包括文件夹。

import java.io.File;
import java.io.FilenameFilter;

public class FileDemo {

public static void main(String[] args) {  
    //1.获得系统有效盘符   
    File[] files = File.listRoots();  
    for (File f : files)  
        System.out.println(f.toString());  
    System.out.println("——————————————————————");  
    //2.获得C:\\\\目录下的所有文件名，包括隐藏文件和文件夹   
    //调用list()方法时，必须先封装一个目录，且必须存在的目录。   
    File fnFile = new File("C:\\\\");  
    String[] strings = fnFile.list();  
    for (String s : strings)  
        System.out.println(s);  
    System.out.println("——————————————————————");  
    //3.调用list()方法，列出后缀名为.txt的文件   
    strings = fnFile.list(new FilenameFilter() {  
          
        @Override  
        public boolean accept(File dir, String name) {  
            //找出后缀名为.txt的文件名   
            return name.endsWith(".txt");  
        }  
    });  
    for (String s : strings)  
        System.out.println(s);  
    System.out.println("——————————————————————");  
    //4.获取C:\\\\目录下的文件夹，不包括文件夹   
    files = fnFile.listFiles();  
    for (File f : files)  
        System.out.println(f.toString());  
}

}

import java.io.File;
import java.io.FilenameFilter;

public class FileDemo {

public static void main(String[] args) {
    //1.获得系统有效盘符
    File[] files = File.listRoots();
    for (File f : files)
        System.out.println(f.toString());
    System.out.println("——————————————————————");
    //2.获得C:\\\\目录下的所有文件名，包括隐藏文件和文件夹
    //调用list()方法时，必须先封装一个目录，且必须存在的目录。
    File fnFile = new File("C:\\\\");
    String[] strings = fnFile.list();
    for (String s : strings)
        System.out.println(s);
    System.out.println("——————————————————————");
    //3.调用list()方法，列出后缀名为.txt的文件
    strings = fnFile.list(new FilenameFilter() {
        
        @Override
        public boolean accept(File dir, String name) {
            //找出后缀名为.txt的文件名
            return name.endsWith(".txt");
        }
    });
    for (String s : strings)
        System.out.println(s);
    System.out.println("——————————————————————");
    //4.获取C:\\\\目录下的文件夹，不包括文件夹
    files = fnFile.listFiles();
    for (File f : files)
        System.out.println(f.toString());
}

}8、递归打印所有文件名

注意：测试中，有些隐藏文件名不能访问还是其他的原因，当在打印根目录（如："C:\\"）下的所有文件名时，会有个叫“System Volume Information”的隐藏文件夹，访问失败，所以以下代码中，不访问隐藏文件。

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File dirFile = new File("E:\\\\Dol");  
    showDir(dirFile,0);  
}  
public static void showDir(File dir,int level)  
{  
    System.out.println(printSpace(level)+"文件夹："+dir.getName());  
    level += 4;  
    File[] file = dir.listFiles();  
    for (File f : file)  
    {  
        //递归进入所有非隐藏文件夹   
        if (f.isDirectory() && !f.isHidden())  
            showDir(f,level);  
        //打印文件名   
        else  
            System.out.println(printSpace(level)+f.getName());  
    }  
}  
//实现分层次打印，补充空格   
public static StringBuffer printSpace(int level)  
{  
    StringBuffer space = new StringBuffer();  
    for (int i = 0; i < level; ++i)  
    {  
        space.append("  ");  
    }  
    return space;  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File dirFile = new File("E:\\\\Dol");
    showDir(dirFile,0);
}
public static void showDir(File dir,int level)
{
    System.out.println(printSpace(level)+"文件夹："+dir.getName());
    level += 4;
    File[] file = dir.listFiles();
    for (File f : file)
    {
        //递归进入所有非隐藏文件夹
        if (f.isDirectory() && !f.isHidden())
            showDir(f,level);
        //打印文件名
        else
            System.out.println(printSpace(level)+f.getName());
    }
}
//实现分层次打印，补充空格
public static StringBuffer printSpace(int level)
{
    StringBuffer space = new StringBuffer();
    for (int i = 0; i < level; ++i)
    {
        space.append("  ");
    }
    return space;
}

}9、递归删除整个文件夹

import java.io.File;

public class FileDemo {

public static void main(String[] args) {  

    File dirFile = new File("E:\\\\Dol");  
    deleteDir(dirFile,0);  
}  
public static void deleteDir(File dir,int level)  
{  
    File[] file = dir.listFiles();  
    //循环递归删除文件夹里面的所有内容   
    for (File f : file)  
    {  
        //递归进入所有非隐藏文件夹   
        if (f.isDirectory() && !f.isHidden())  
            deleteDir(f,level);  
        //删除文件   
        else  
        {  
            f.delete();  
            System.out.println(f.getName()+"——已删除");  
        }  
    }  
    //删除该文件夹   
    dir.delete();  
    System.out.println(dir.getName()+"——已删除");  
}

}

import java.io.File;

public class FileDemo {

public static void main(String[] args) {

    File dirFile = new File("E:\\\\Dol");
    deleteDir(dirFile,0);
}
public static void deleteDir(File dir,int level)
{
    File[] file = dir.listFiles();
    //循环递归删除文件夹里面的所有内容
    for (File f : file)
    {
        //递归进入所有非隐藏文件夹
        if (f.isDirectory() && !f.isHidden())
            deleteDir(f,level);
        //删除文件
        else
        {
            f.delete();
            System.out.println(f.getName()+"——已删除");
        }
    }
    //删除该文件夹
    dir.delete();
    System.out.println(dir.getName()+"——已删除");
}

}10、Properties类

1）常用的基本操作，设置键值，获取值。

import java.util.Properties;
import java.util.Set;

public class FileDemo {

public static void main(String[] args) {  
    //Properties是HashTable的子类，里面存放的都是键值对的字符串   
    Properties prop = new Properties();  
    //设置键值   
    prop.setProperty("Dolphin", "海豚");  
    prop.setProperty("Dol", "CSDN");  
    //获取   
    String value = prop.getProperty("Dolphin");  
    System.out.println("@@@@[email protected]@@@"+value);  
      
    //返回一个集合   
    Set<String> nameSet = prop.stringPropertyNames();  
    for (String s : nameSet)  
    {  
        System.out.println(s+":"+prop.getProperty(s));  
    }  
}

}

import java.util.Properties;
import java.util.Set;

public class FileDemo {

public static void main(String[] args) {
    //Properties是HashTable的子类，里面存放的都是键值对的字符串
    Properties prop = new Properties();
    //设置键值
    prop.setProperty("Dolphin", "海豚");
    prop.setProperty("Dol", "CSDN");
    //获取
    String value = prop.getProperty("Dolphin");
    System.out.println("@@@@[email protected]@@@"+value);
    
    //返回一个集合
    Set<String> nameSet = prop.stringPropertyNames();
    for (String s : nameSet)
    {
        System.out.println(s+":"+prop.getProperty(s));
    }
}

}
2）读取配置文件

读取配置文件，并对配置文件进行修改，修改后再保存。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class FileDemo {

public static void main(String[] args) throws IOException{  

    Properties prop = new Properties();  
    //Properties加载的文件必须为键值对，#注释的不会被加载   
    FileInputStream fis = new FileInputStream("pz.txt");  
    prop.load(fis);  
    //添加一个键值对   
    prop.setProperty("Dol", "123");  
    //对键值对进行修改   
    prop.setProperty("Dol", "321");  
    FileOutputStream fos = new FileOutputStream("pz.txt");  
    //保存配置文件   
    //void java.util.Properties.store(OutputStream arg0, String arg1) throws IOException   
    //第二个参数为注释，可写可不写，写入时会自动添加#   
    prop.store(fos, "comment");  
      
    prop.list(System.out);  
    fis.close();  
    fos.close();  
}

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class FileDemo {

public static void main(String[] args) throws IOException{

    Properties prop = new Properties();
    //Properties加载的文件必须为键值对，#注释的不会被加载
    FileInputStream fis = new FileInputStream("pz.txt");
    prop.load(fis);
    //添加一个键值对
    prop.setProperty("Dol", "123");
    //对键值对进行修改
    prop.setProperty("Dol", "321");
    FileOutputStream fos = new FileOutputStream("pz.txt");
    //保存配置文件
    //void java.util.Properties.store(OutputStream arg0, String arg1) throws IOException
    //第二个参数为注释，可写可不写，写入时会自动添加#
    prop.store(fos, "comment");
    
    prop.list(System.out);
    fis.close();
    fos.close();
}

}
11、SequenceInputStream类：连接多个流

说明：Enumeration（列举）
public interface Enumeration

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class FileDemo {

public static void main(String[] args) throws IOException {  

    //将多个流加入集合   
    Vector<FileInputStream> vector = new Vector<FileInputStream>();  
    vector.add(new FileInputStream("E:\\\\1.txt"));  
    vector.add(new FileInputStream("E:\\\\2.txt"));  
    vector.add(new FileInputStream("E:\\\\3.txt"));  

    //java.util.Enumeration<FileInputStream>用法见说明   
    Enumeration<FileInputStream> en = vector.elements();  
    //连接多个流   
    SequenceInputStream sis = new SequenceInputStream(en);  
    //启动输出流   
    FileOutputStream fos = new FileOutputStream("E:\\\\4.txt");  
    //开始文件拷贝   
    byte[] buf = new byte[1024];  
    int len = 0;  
    while ((len=sis.read(buf))!=-1)  
        fos.write(buf,0,len);  
    //关闭资源   
    fos.close();  
    sis.close();  
}

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream;
import java.util.Enumeration;
import java.util.Vector;

public class FileDemo {

public static void main(String[] args) throws IOException {

    //将多个流加入集合
    Vector<FileInputStream> vector = new Vector<FileInputStream>();
    vector.add(new FileInputStream("E:\\\\1.txt"));
    vector.add(new FileInputStream("E:\\\\2.txt"));
    vector.add(new FileInputStream("E:\\\\3.txt"));

    //java.util.Enumeration<FileInputStream>用法见说明
    Enumeration<FileInputStream> en = vector.elements();
    //连接多个流
    SequenceInputStream sis = new SequenceInputStream(en);
    //启动输出流
    FileOutputStream fos = new FileOutputStream("E:\\\\4.txt");
    //开始文件拷贝
    byte[] buf = new byte[1024];
    int len = 0;
    while ((len=sis.read(buf))!=-1)
        fos.write(buf,0,len);
    //关闭资源
    fos.close();
    sis.close();
}

}12、对象序列化实现Serializable接口

1）添加序列号；

2）静态成员变量不可序列化；

3）堆内存变量要想不被序列化，可以加transient关键字。

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

//序列化，必须实现Serializable接口，该接口不需要覆盖方法
class Person implements Serializable
{
//记得添加序列化号
public static final long serialVersionUID = 42L;

//堆内存变量可序列化   
private String name;  
private int age;  
//如果不想将堆内存里面的变量序列化，如下声明就可以了   
//transient int age;   
//注意，静态成员变量不可序列化   
private static String sex = "male";  
public Person(String n, int a, String s)  
{  
    name = n;  
    age = a;  
    sex = s;  
}  
//覆盖toString()方便println()打印   
public String toString()  
{  
    return name+":"+age+":"+sex;  
}

}
public class FileDemo {

public static void WriteOut() throws IOException  
{  
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));  
    oos.writeObject(new Person("Dolphin", 20,"female"));  
    oos.close();  
}  
public static void ReadIn() throws Exception  
{  
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));  
    Person p = (Person)ois.readObject();  
    ois.close();  
    System.out.println(p);  
}  
//这里直接抛出一个较大的异常Exception（IOException的基类）   
public static void main(String[] args) throws Exception {  
    //注意：以下函数需要分两次运行，每次只运行一个，方便观察运行效果   
    //WriteOut();   
    ReadIn();  
}

}

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

//序列化，必须实现Serializable接口，该接口不需要覆盖方法
class Person implements Serializable
{
//记得添加序列化号
public static final long serialVersionUID = 42L;

//堆内存变量可序列化
private String name;
private int age;
//如果不想将堆内存里面的变量序列化，如下声明就可以了
//transient int age;
//注意，静态成员变量不可序列化
private static String sex = "male";
public Person(String n, int a, String s)
{
    name = n;
    age = a;
    sex = s;
}
//覆盖toString()方便println()打印
public String toString()
{
    return name+":"+age+":"+sex;
}

}
public class FileDemo {

public static void WriteOut() throws IOException
{
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
    oos.writeObject(new Person("Dolphin", 20,"female"));
    oos.close();
}
public static void ReadIn() throws Exception
{
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
    Person p = (Person)ois.readObject();
    ois.close();
    System.out.println(p);
}
//这里直接抛出一个较大的异常Exception（IOException的基类）
public static void main(String[] args) throws Exception {
    //注意：以下函数需要分两次运行，每次只运行一个，方便观察运行效果
    //WriteOut();
    ReadIn();
}

}13、管道流

1）平时两个流读写都是通过内存变量，进行数据操作的；

2）这里引入管道流，开启两个线程，一个读取流，一个写入流，直接将两个流对接上。

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
//实现Runnable方法，多线程
class Read implements Runnable
{
private PipedInputStream in;
public Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try {
byte[] buf = new byte[1024];
int len = 0;
//如果流中无数据，read()进入等待状态
while ((len=in.read(buf))!=-1)
{
System.out.println(buf);
}
in.close();
} catch (Exception e) {
throw new RuntimeException("管道流读取失败");
}
}
}

class Write implements Runnable
{
private PipedOutputStream out;
public Write(PipedOutputStream in)
{
this.out = out;
}
public void run()
{
try {
out.write("Piped lai la...".getBytes());
out.close();
} catch (Exception e) {
throw new RuntimeException("管道流输出失败");
}
}
}

public class PipedStreamDemo {

public static void main(String[] args) {  
      
    PipedInputStream in = new PipedInputStream();  
    PipedOutputStream out = new PipedOutputStream();  
      
    Read r = new Read(in);  
    Write w = new Write(out);  
    //开启两线程   
    new Thread(r).start();  
    new Thread(w).start();  
}

}

import java.io.PipedInputStream;
import java.io.PipedOutputStream;
//实现Runnable方法，多线程
class Read implements Runnable
{
private PipedInputStream in;
public Read(PipedInputStream in)
{
this.in = in;
}
public void run()
{
try {
byte[] buf = new byte[1024];
int len = 0;
//如果流中无数据，read()进入等待状态
while ((len=in.read(buf))!=-1)
{
System.out.println(buf);
}
in.close();
} catch (Exception e) {
throw new RuntimeException("管道流读取失败");
}
}
}

class Write implements Runnable
{
private PipedOutputStream out;
public Write(PipedOutputStream in)
{
this.out = out;
}
public void run()
{
try {
out.write("Piped lai la...".getBytes());
out.close();
} catch (Exception e) {
throw new RuntimeException("管道流输出失败");
}
}
}

public class PipedStreamDemo {

public static void main(String[] args) {
    
    PipedInputStream in = new PipedInputStream();
    PipedOutputStream out = new PipedOutputStream();
    
    Read r = new Read(in);
    Write w = new Write(out);
    //开启两线程
    new Thread(r).start();
    new Thread(w).start();
}

}
14、RandomAccessFile类

import java.io.IOException;
import java.io.RandomAccessFile;

public class RafDemo {

public static void Read() throws IOException  
{  
    RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");  
    byte[] buf= new byte[4];  
    raf.read(buf);  
    String name = new String(buf);  
    int age;  
    age = raf.readInt();  
      
    raf.close();  
      
    System.out.println("网名："+name);  
    System.out.println("年龄："+age);  
}  
public static void Write() throws IOException  
{  
    RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");  
    raf.write("海豚".getBytes());  
    raf.writeInt(20);  
    raf.close();  
}  
public static void main(String[] args) throws IOException {  
      
    Write();  
    Read();  
    //调整指针位置   
    //raf.seek(pos);   
    //跳过字节数   
    //raf.skipBytes(n);   
}

}

import java.io.IOException;
import java.io.RandomAccessFile;

public class RafDemo {

public static void Read() throws IOException
{
    RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
    byte[] buf= new byte[4];
    raf.read(buf);
    String name = new String(buf);
    int age;
    age = raf.readInt();
    
    raf.close();
    
    System.out.println("网名："+name);
    System.out.println("年龄："+age);
}
public static void Write() throws IOException
{
    RandomAccessFile raf = new RandomAccessFile("raf.txt", "rw");
    raf.write("海豚".getBytes());
    raf.writeInt(20);
    raf.close();
}
public static void main(String[] args) throws IOException {
    
    Write();
    Read();
    //调整指针位置
    //raf.seek(pos);
    //跳过字节数
    //raf.skipBytes(n);
}

}
15、DataStream类

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamDemo {

public static void main(String[] args) throws IOException {  
    //写数据   
    DataOutputStream out = new DataOutputStream(new FileOutputStream("data.txt"));  
      
    out.writeInt(123);  
    out.writeDouble(56.88);  
    out.writeBoolean(true);  
    out.close();  
    //读数据   
    DataInputStream in = new DataInputStream(new FileInputStream("data.txt"));  
    int nInt = in.readInt();  
    double nDou = in.readDouble();  
    boolean b = in.readBoolean();  
    in.close();  
    //显示   
    System.out.println("nInt:"+nInt);  
    System.out.println("nDou:"+nDou);  
    System.out.println("b:"+b);  
}

}

import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class DataStreamDemo {

public static void main(String[] args) throws IOException {
    //写数据
    DataOutputStream out = new DataOutputStream(new FileOutputStream("data.txt"));
    
    out.writeInt(123);
    out.writeDouble(56.88);
    out.writeBoolean(true);
    out.close();
    //读数据
    DataInputStream in = new DataInputStream(new FileInputStream("data.txt"));
    int nInt = in.readInt();
    double nDou = in.readDouble();
    boolean b = in.readBoolean();
    in.close();
    //显示
    System.out.println("nInt:"+nInt);
    System.out.println("nDou:"+nDou);
    System.out.println("b:"+b);
}

}
16、ByteArrayStream类

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

import javax.print.attribute.standard.Sides;

public class ByteArrayStreamDemo {

public static void main(String[] args) {  

    ByteArrayInputStream in = new ByteArrayInputStream("Dolphin".getBytes());  
    ByteArrayOutputStream out = new ByteArrayOutputStream();  
      
    int len = 0;  
    // int java.io.ByteArrayInputStream.read() 从此输入流中读取下一个数据字节   
    while ((len=in.read())!=-1)  
    {  
        out.write(len);  
    }  
    System.out.println(out.size());  
}

}












































































































































以上是关于转载Java File操作汇总的主要内容，如果未能解决你的问题，请参考以下文章

Java File IO学习笔记

solr分布式索引实战分片配置读取：工具类configUtil.java，读取配置代码片段，配置实例

EassyUI内置方法与属性

精心收集的 48 个 JavaScript 代码片段，仅需 30 秒就可理解!（转载）

Java的IO的类都有哪些？都有啥用？

Python文件操作汇总