我的Java之路之IO

时间：2015-12-02 06:35:43 阅读：275 评论：0 收藏：0 [点我收藏+]

标签：

创建一个文件

import java.io.*;
public class IOTest1{
    public static void main(String[] args){
        String Filename = "D:" + File.separator + "h.xls";
        File f = new File(Filename);
        try{
            f.createNewFile();
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

　　以上程序创建了一个名字为h，文件格式为xls的文件，File.separator分隔符。"D:" + File.separator + "h.xls" == "D:\\h.xls"。请注意："D:" + File.separator + "h.xls"字符和符号直接不能有空格，如果有的话编译不会出错，运行时会出错。

　　如果是分号":"可以用File.pathSeparator代替。然而"D" + File.pathSeparator + File.separator + "h.xls"是错误的，运行时会出错。

删除一个文件

　　boolean exists(); 判断File对象所对应的文件或目录是否存在

import java.io.*;
public class IOTest1{
    public static void main(String[] args){
        String Filename = "D:"  + File.separator + "h.txt";
        File f = new File(Filename);
        if(f.exists()){
            f.delete();
                }else{
                System.out.println("别找了，杀死你的是影子！");
            }
        }
    }

创建一个文件夹

　　boolean mkdir(); 试图创建一个File对象所对应的目录，如果创建成果返回true，否则返回false。调用该方法时File对象必须对应一个路径，而不是一个文件。

import java.io.*;
public class IOTest1{
    public static void main(String[] args){
        String Filename = "D:"  + File.separator + "影流之主";
        File f = new File(Filename);
        f.mkdir();
        }
    }

　　创建一个叫做影流之主的文件夹。

列出指定文件的全部文件（包括隐藏文件）

　　String[] list(); 列出File对象的所有子文件名和路径名，返回String数组

import java.io.*;
public class IOTest1{
    public static void main(String[] args){
        String Filename = "D:"  + File.separator;
        File f = new File(Filename);
        String[] str = f.list();
        for(int i = 0; i < str.length; i++){
            System.out.println(str[i]);
            }
        }
    }

技术分享

　　list返回的是一个String数组，而不是列出完整路径，如果需要列出完整路径，需要使用listFile()方法

　　File[] listFiles();列出File对象的所有子文件和路径，返回File数组

import java.io.*;
public class IOTest1{
    public static void main(String[] args){
        String Filename = "D:"  + File.separator;
        File f = new File(Filename);
        File[] str = f.listFiles();
        for(int i = 0; i < str.length; i++){
            System.out.println(str[i]);
            }
        }
    }

输出如下：

技术分享

　　static File[] listRoots();列出系统所有的跟路径。这是一个静态方法，可以直接通过File类来调用。

import java.io.File;
public class IOTest1{
    public static void main(String[] args){
        File[] Str;
        try{
                Str = File.listRoots();
                for(File path:Str){
                    System.out.println(path);
                    }
            }catch(Exception e){
                e.printStackTrace();
                }
        }
    }

输出如下：

技术分享

判断一个路径是否为路径

　　Boolean isDirectory(); 判断File对象所对应的是否是目录，而不是文件（Directory 目录）

import java.io.*;
public class IOTest2{
    public static void main(String[] args){
        String name = "D:" + File.separator;
        File f = new File(name);
        if(f.isDirectory()){
            System.out.println("YES");
        }else{
            System.out.println("NO");
            }
        }
    }

　　输出：YES

import java.io.*;
public class IOTest2{
    public static void main(String[] args){
        String name = "D:" + File.separator + "hah.txt";
        File f = new File(name);
        if(f.isDirectory()){
            System.out.println("YES");
        }else{
            System.out.println("NO");
            }
        }
    }

　　输出：NO

import java.io.*;
public class IsDirectoryTest{
    public static void main(String[] args){
        String Str = "D:" + File.separator;
        File f = new File(Str);
        print(f);
        }
            public static void print(File f){
                if(f != null){
                    if(f.isDirectory()){
                        File[] pathArray = f.listFiles();
                        if(pathArray != null){
                            for(int i = 0; i < pathArray.length; i++){
                                print(pathArray[i]);
                                }
                            }
                        }else{
                            System.out.println(f);
                        }
                    }
                }
    } 
     //请注意这个程序输出了D盘下所有的目录，DOS已经疯了，请选择个目录比较少的文件

使用RandomAccessFile写入文件

　　1、" r " :以只读方式打开指定文件，如果试图对该文件执行写入方法，将抛出IOException异常
　　2、" rw ":以读、写的方式打开指定文件，如果该文件不存在，则尝试创建该文件
　　3、" rws ":以读、写方式打开指定文件，相对于“rw”模式，还要求对文件的内容或元数据的每个更新都同步写入到底的存储设备
　　4、" rwd ":以读、写方式打开指定文件，相对“rw”模式，还要求对文件内容的每个更新都同步到底层存储设备

import java.io.*;
public class RandomAccessFileTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "hah.txt";
        File f = new File(fileName);
        try{
            RandomAccessFile demo=new RandomAccessFile(f,"rw"); 
      　　　 demo.writeBytes("asdsad");
      　　　 demo.writeInt(12);
     　　　  demo.writeBoolean(true);
     　　　  demo.writeChar(‘A‘);
      　　　 demo.writeFloat(1.21f);
     　　　  demo.writeDouble(12.123);
      　　　 demo.close();   
        }catch(Exception e){
            e.printStackTrace(); //必须抛出异常，不然编译出错
            }
        }
    }

打开文档是乱码。如果没有找不到该文档会自动添加一个。

字节流

向文档中写入字符串

　　getBytes（）是将一个字符串转化为一个字节数组。String的getBytes()方法是得到一个系统默认的编码格式的字节数组。将一个 string类型的字符串中包含的字符转换成byte类型并且存入一个byte数组中。在java中的所有数据底层都是字节，字节数据可以存入到byte 数组。存储字符数据时(字符串就是字符数据)，会先进行查表，然后将查询的结果写入设备，读取时也是先查表，把查到的内容打印到显示设备上，getBytes()是使用默认的字符集进行转换，getBytes(“utf-8”)是使用UTF-8编码表进行转换。

import java.io.*;
public class OutPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            OutputStream out = new FileOutputStream(f);
            String str = "无形之刃，最为致命！";
            byte[] b = str.getBytes();
            out.write(b);
            out.close();
        }catch(Exception e){
            e.printStackTrace();  //要做异常处理
            }
        }
    }

打开文档：无形之刃，最为致命！

当然也可以一个字节一个字节地读

import java.io.*;
public class OutPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            OutputStream out = new FileOutputStream(f);
            String str = "无形之刃，最为致命！";
            byte[] b = str.getBytes();
            for(int i = 0; i < b.length; i++){
                out.write(b[i]);
                }
            out.close();
        }catch(Exception e){
            e.printStackTrace();  //要做异常处理
            }
        }
    }

FileOutputStream(File file, boolean append)

file - 为了进行写入而打开的文件。

append - 如果为 true，则将字节写入文件末尾处，而不是写入文件开始处

import java.io.*;
public class OutPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            //OutputStream out = new FileOutputStream(f ,false);
            //false写入的数据会自动替换掉之前的数据，true代表写到文件末端
            OutputStream out = new FileOutputStream(f , true);
            String str = "均衡存乎暗影之中！";
            //String str = "\r\n均衡存乎暗影之中！"; 换行
            byte[] b = str.getBytes();
            for(int i = 0; i < b.length; i++){
                out.write(b[i]);
                }
            out.close();
        }catch(Exception e){
            e.printStackTrace();  //要做异常处理
            }
        }
    }

读取文件内容

import java.io.*;
public class InPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            InputStream ips = new FileInputStream(f);
            byte[] b = new byte[1024];
            ips.read(b);
            ips.close();
            System.out.println(new String(b));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

但是这样读取会有很多个aaaaa，可以利用ips.read(b)返回值来设计程序

技术分享

read(byte[] b, int off, int len)

b - 读入数据的缓冲区。 off - 数组 b 中将写入数据的初始偏移量。 len - 要读取的最大字节数。

import java.io.*;
public class InPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            InputStream ips = new FileInputStream(f);
            byte[] b = new byte[1024];
            int len = ips.read(b);
            ips.read(b);
            ips.close();
            System.out.println("读入数据长度为：" + len);
            System.out.println(new String(b , 0 ,len));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

输出：技术分享

从以上两个程序可以看到，我们预先申请一个空间，但是这个空间有时大有时小，该如何是好？

import java.io.*;
public class InPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            InputStream ips = new FileInputStream(f);
            byte[] b = new byte[(int)f.length()];
            //int len = ips.read(b);
            ips.read(b);
            ips.close(); //f.length()表示文件的长度
            System.out.println("读入数据长度为：" + f.length());
            System.out.println(new String(b));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

一个字节一个字节地读

import java.io.*;
public class InPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            InputStream ips = new FileInputStream(f);
            byte[] b = new byte[(int)f.length()];
            //int len = ips.read(b);
            for(int i = 0; i < b.length; i++){
                    b[i] = (byte)ips.read();
                }
            ips.close(); //f.length()表示文件的长度
            System.out.println("读入数据长度为：" + f.length());
            System.out.println(new String(b));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

如果不知道文件大小，如何判定文件到达末尾？

import java.io.*;
public class InPutStreamTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            InputStream ips = new FileInputStream(f);
            byte[] b = new byte[1024];
            int i = 0;
            int j = 0;
          while((i = ips.read()) != (-1)){
              b[j++] = (byte)i;
              }
            ips.close();
            System.out.println(new String(b));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

当读到文件末尾返回-1.正常情况下不会返回-1.

字符流

import java.io.*;
public class WriteTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            Writer out = new FileWriter(f);
            String str = "无形装逼，最为致命!";
            out.write(str);
            out.close();
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

输出：无形装逼，最为致命！

当你想在文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：

Writer out =new FileWriter(f,true);

如果想在文件中换行的话，需要使用“\r\n”

比如将str变为String str="\r\n无形装逼，最为致命！";

这样文件追加的str的内容就会换行了。

import java.io.*;
public class WriteTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            char[] ch = new char[100];
            Reader read = new FileReader(f);
            int i = read.read(ch);
            read.close();
            System.out.println("读入长度为：" + i);
            System.out.println("内容为：" + new String(ch , 0 , i));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

最好采用循环读取的方式，因为我们不知道文件有多大

import java.io.*;
public class WriteTest{
    public static void main(String[] args){
        String fileName = "D:" + File.separator + "影流之主.txt";
        File f = new File(fileName);
        try{
            char[] ch = new char[100];
            Reader read = new FileReader(f);
            int i = 0;
            int j = 0;
            while((i = read.read()) != (-1)){
                ch[j++] = (char)i;
                }
            read.close();
            System.out.println("内容为：" + new String(ch , 0 , j));
        }catch(Exception e){
            e.printStackTrace();
            }
        }
    }

关于字节流和字符流的区别

实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。

读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。

使用字节流好还是字符流好呢？

答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。

复制一个文件，从一个文件中读取，然后边读边写入另一个文件中

import java.io.*;
public class CopyTest{
    public static void main(String[] args){
        if(args.length != 2){
            System.out.println("参数输入有误！");
            System.exit(1);
            }
            File f1 = new File(args[0]);
            File f2 = new File(args[1]);
            if(!f1.exists()){
                System.out.println("可复制文件不存在");
                System.exit(1);
                }
            try{
                InputStream intp = new FileInputStream(args[0]);
                OutputStream outp = new FileOutputStream(args[1]);
                if(intp != null && outp != null){
                int temp = 0;
                while((temp = intp.read()) != (-1)){
                    outp.write(temp);
                    }
                }
                outp.close();
                intp.close();
            }catch(Exception e){
                e.printStackTrace();
                }
        }
    }
//命令行：javac CopyTest.java
//运行：java CopyTest d:\影流之主.txt d:\hah.txt

OutputStreramWriter 和InputStreamReader类

整个IO类中除了字节流和字符流还包括字节和字符转换流。

OutputStreramWriter将输出的字符流转化为字节流

InputStreamReader将输入的字节流转换为字符流

但是不管如何操作，最后都是以字节的形式保存在文件中的。

将字节输出流转换为字符输出流

格式： Reader read=new InputStreamReader(new FileInputStream(file));

　　　　 Writer out=new OutputStreamWriter(new FileOutputStream(file));

以内存输入输出为目的，使用内存操作流

ByteArrayInputStream 主要将内容写入内存

ByteArrayOutputStream 主要将内容从内存输出

我的Java之路之IO

标签：

原文地址：http://www.cnblogs.com/changzuidaerguai/p/5011808.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行