IO流

最新推荐文章于 2024-09-14 18:46:05 发布

weixin_30666943

最新推荐文章于 2024-09-14 18:46:05 发布

阅读量50

点赞数

文章标签： java 操作系统运维

原文链接：http://www.cnblogs.com/clever765/articles/7059499.html

版权

package zxd.work621;

import java.io.File;
--------------------------------File的方法-------------------------------------------
public class Text1 {
public static void main(String[] args) {
/*1,file.delete() 删除此抽象路径名表示的文件或目录(空文件)。
 *2,file.exists()测试此抽象路径名表示的文件或目录是否存在。
 *3,file.getAbsoluteFile() 返回此抽象路径名的绝对路径名形式。
 *4,file.getName() 返回由此抽象路径名表示的文件或目录的名称。
 *5,file.isFile() 测试此抽象路径名表示的文件是否是一个标准文件。
 *6,file.isDirectory() 测试此抽象路径名表示的文件是否是一个目录。
 *7,file.isHidden() 测试此抽象路径名指定的文件是否是一个隐藏文件。
 *8,file.length()返回由此抽象路径名表示的文件的长度。
 *9,String[] s = file.list()返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
 *10,file.mkdir() 创建此抽象路径名指定的目录。抽象目录不存在，不能创建目录，
 *11,file.mkdirs() 抽象目录不存在，按照目录创建文件夹，
 *12,file.createNewFile()当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
 *13,file.createTempFile(String prefix, String suffix, File directory) 
 *        在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。
 *14,file.lastModified()返回此抽象路径名表示的文件最后一次被修改的时间。
 *输入流：InputStream,输出流：OutPutStream
 *流的读入流程：建立联系，选择流，操作流，关闭资源；
 */
    File file = new File("F:\\workspace\\workspace\\src\\zxd\\work18");
    //或者File file = new File("F:/workspace/workspace/src//zxd/work18");
    File file1 = new File("F:\\workspace");
    
    
    
}
}
----------------------------------------------------------------------------------------

package zxd.work621;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
--------------------------------------文件里面没有汉字-----------------------------------
public class Text2 {
public static void main(String[] args) {
    //流的读入流程：
    InputStream in = null;
    //1建立联系，
        File file = new File("F:\\aaa\\123.txt");
        try {
            //2选择流，
            in = new FileInputStream(file);
            //3操作流，
            int ln = 0;
            while((ln = in.read()) != -1){
                System.out.print((char)ln);
            }
        } catch (FileNotFoundException e) {
            System.out.println("创建输入流失败");
            
        }catch(IOException e){    
            System.out.println("读取文件失败");
        }finally{
            try {
                in.close();
            } catch (IOException e) {
                System.out.println("关闭流失败");
            }            
        }
    //4关闭资源；
        
}
}

package zxd.work621;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
-------------------------------------文件里面有汉字-------------------------------------------
public class Text3 {
public static void main(String[] args) {
    //流的读入流程：
        InputStream in = null;
        //1建立联系，
            File file = new File("F:\\aaa\\123.txt");
            try {
                //2选择流，
                in = new FileInputStream(file);
                //3操作流，
                byte[] car = new byte[1024];
                int ln = 0;
                while((ln = in.read(car)) != -1){//如果到达流的末尾，则返回 -1。 
                /*    for (int i = 0; i < car.length; i++) {
                        System.out.print((char)car[i]);
                    }*/
                    String s = new String(car,0,ln);//数组转换成字符串；(数组，位置，读取长度)
                    System.out.println(s);
                }
            } catch (FileNotFoundException e) {
                System.out.println("创建输入流失败");
                
            }catch(IOException e){    
                System.out.println("读取文件失败");
            }finally{
                try {
                    in.close();
                } catch (IOException e) {
                    System.out.println("关闭流失败");
                }            
            }
        //4关闭资源；
}
}

package zxd.work621;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
-------------------------------------------写出流  ---------------------------------------------
public class Text4 {
public static void main(String[] args) {
/*流的写出过程
 * 
 */
    //建立联系
    File file = new File("F:\\aaa\\bb.txt");//首先bb不存在
    
    OutputStream out = null;
    //选择流
    try {
        //操作流
        out = new FileOutputStream(file,true);//true来追加
        String s = "泡妹纸";
        byte[] b = s.getBytes();
        out.write(b);
    } catch (FileNotFoundException e) {
        System.out.println("创建流失败");
                
    }catch(IOException e){
        System.out.println("写出失败");
    }finally{
        try {
            //关闭流
            out.close();
        } catch (IOException e) {
            System.out.println("关闭流失败");
        }
    }    
}
}

package zxd.work621;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
-------------------------创建并copy文件到另一个盘-----------
public class Text5 {
public static void main(String[] args) {
    File file1=new File("F:\\aaa\\123.txt");
    File file=new File("E:\\copy1");
    if (!file.exists()) {//如果没有copy1，就创建一个
        file.mkdirs();
    }
    File file2 = new File(file, file1.getName());
    InputStream in = null;
    OutputStream out = null;
    
    try {
        in = new FileInputStream(file1);
        out = new FileOutputStream(file2);
        byte[] b = new byte[1024];
        int ln = 0;
        while((ln= in.read(b)) != -1){
            out.write(b);
        }
    } catch (FileNotFoundException e) {
        System.out.println("创建流失败");
    }catch(IOException e){
        System.out.println("读取失败");
    }finally{
        try {
            in.close();
            out.close();
        } catch (IOException e) {
            System.out.println("关闭流失败");
        }
        
    }
    
    
    
    
}

}

File类：将文件系统中的文件和文件夹封装成了对象。提供了更多的属性和行为可以对这些文件
和文件夹进行操作。这些是流对象办不到的，因为流只操作数据。

File类常见方法：
1：创建。
boolean createNewFile()：在指定目录下创建文件，如果该文件已存在，则不创建。
而对操作文件的输出流而言，输出流对象已建立，就会创建文件，如果文件已存在，会覆盖。除非续写。
boolean mkdir()：创建此抽象路径名指定的目录。
boolean mkdirs()：创建多级目录。 
2：删除。
boolean delete()：删除此抽象路径名表示的文件或目录。
void deleteOnExit()：在虚拟机退出时删除。
注意：在删除文件夹时，必须保证这个文件夹中没有任何内容，才可以将该文件夹用delete删除。
window的删除动作，是从里往外删。注意：java删除文件不走回收站。要慎用。
3：获取.
long length()：获取文件大小。
String getName()：返回由此抽象路径名表示的文件或目录的名称。
String getPath()：将此抽象路径名转换为一个路径名字符串。
String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串。
String getParent()：返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目
录，则返回 null。
long lastModified()：返回此抽象路径名表示的文件最后一次被修改的时间。
File.pathSeparator：返回当前系统默认的路径分隔符，windows默认为 “；”。
File.Separator：返回当前系统默认的目录分隔符，windows默认为 “\”。
4：判断：
boolean exists()：判断文件或者文件夹是否存在。
boolean isDirectory()：测试此抽象路径名表示的文件是否是一个目录。
boolean isFile()：测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden()：测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean isAbsolute()：测试此抽象路径名是否为绝对路径名。
5：重命名。
boolean renameTo(File dest)：可以实现移动的效果。剪切+重命名。

String[] list()：列出指定目录下的当前的文件和文件夹的名称。包含隐藏文件。
如果调用list方法的File 对象中封装的是一个文件，那么list方法返回数组为null。如果封装的对象
不存在也会返回null。只有封装的对象存在并且是文件夹时，这个方法才有效。
------------------------------------------------------------------------------------------------
递归：就是函数自身调用自身。
什么时候用递归呢？
当一个功能被重复使用，而每一次使用该功能时的参数不确定，都由上次的功能元素结果来确定。
简单说：功能内部又用到该功能，但是传递的参数值不确定。(每次功能参与运算的未知内容不确定)。

递归的注意事项：
1：一定要定义递归的条件。
2：递归的次数不要过多。容易出现 StackOverflowError 栈内存溢出错误。
其实递归就是在栈内存中不断的加载同一个函数。

IO流：★★★★★，用于处理设备上数据。
流：可以理解数据的流动，就是一个数据流。IO流最终要以对象来体现，对象都存在IO包中。
流也进行分类：
1：输入流（读）和输出流（写）。
2：因为处理的数据不同，分为字节流和字符流。

字节流：处理字节数据的流对象。设备上的数据无论是图片或者dvd，文字，它们都以二进制存储的。
二进制的最终都是以一个8位为数据单元进行体现，所以计算机中的最小数据单元就是字节。意味着，
字节流可以处理设备上的所有数据，所以字节流一样可以处理字符数据。

那么为什么要有字符流呢？因为字符每个国家都不一样，所以涉及到了字符编码问题，那么GBK编码的
中文用unicode编码解析是有问题的，所以需要获取中文字节数据的同时+ 指定的编码表才
可以解析正确数据。为了方便于文字的解析，所以将字节流和编码表封装成对象，这个对象
就是字符流。只要操作字符数据，优先考虑使用字符流体系。

注意：流的操作只有两种：读和写。

流的体系因为功能不同，但是有共性内容，不断抽取，形成继承体系。该体系一共有四个基类，而且都是抽象类。

字节流：InputStream OutputStream
字符流：Reader Writer

在这四个系统中，它们的子类，都有一个共性特点：子类名后缀都是父类名，前缀名都是这个子类的功能名称。
--------------------------------------------------------------------------------------------------------------------
public static void main(String[] args) throws IOException { //读、写都会发生IO异常
/*
1：创建一个字符输出流对象，用于操作文件。该对象一建立，就必须明确数据存储位置，是一个文件。
2：对象产生后，会在堆内存中有一个实体，同时也调用了系统底层资源，在指定的位置创建了一个存
储数据的文件。
3：如果指定位置，出现了同名文件，文件会被覆盖。
*/
FileWriter fw = new FileWriter("demo.txt"); // FileNotFoundException
/*
调用Writer类中的write方法写入字符串。字符串并未直接写入到目的地中，而是写入到了流中，(其
实是写入到内存缓冲区中)。怎么把数据弄到文件中？
*/
fw.write("abcde");
fw.flush(); // 刷新缓冲区，将缓冲区中的数据刷到目的地文件中。
fw.close(); // 关闭流，其实关闭的就是java调用的系统底层资源。在关闭前，会先刷新该流。
}

close()和flush()的区别：
flush()：将缓冲区的数据刷到目的地中后，流可以使用。
close()：将缓冲区的数据刷到目的地中后，流就关闭了，该方法主要用于结束调用的底层资源。这个动作一定做。
--------------------------------------------------------------------------------------------------------------------
io异常的处理方式：io一定要写finally；


字符流：
Reader：用于读取字符流的抽象类。子类必须实现的方法只有 read(char[], int, int) 和 close()。
|---BufferedReader：从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。
|---LineNumberReader：跟踪行号的缓冲字符输入流。此类定义了方法 setLineNumber(int) 和 getLineNumber()，它们可分别用于设置和获取当前行号。
|---InputStreamReader：是字节流通向字符流的桥梁：它使用指定的 charset 读取字节并将其解码为字符。它使用的字符集可以由名称指定或显式给定，或者可以接受平台默认的字符集。
|---FileReader：用来读取字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是适当的。要自己指定这些值，可以先在 FileInputStream 上构造一个 InputStreamReader。
|---CharArrayReader：
|---StringReader：
-------------------------------------------------
Writer：写入字符流的抽象类。子类必须实现的方法仅有 write(char[], int, int)、flush() 和 close()。
|---BufferedWriter：将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
|---OutputStreamWriter：是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
|---FileWriter：用来写入字符文件的便捷类。此类的构造方法假定默认字符编码和默认字节缓冲区大小都是可接受的。要自己指定这些值，可以先在 FileOutputStream 上构造一个 OutputStreamWriter。
|---PrintWriter：
|---CharArrayWriter：
|---StringWriter：
BufferedWriter：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。
FileWriter fw = new FileWriter("bufdemo.txt");
BufferedWriter bufw = new BufferedWriter(fw);//让缓冲区和指定流相关联。
for(int x=0; x<4; x++){
bufw.write(x+"abc");
bufw.newLine(); //写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。
bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。
}
bufw.close();//关闭缓冲区，其实就是在关闭具体的流。
-----------------------------
BufferedReader：
FileReader fr = new FileReader("bufdemo.txt");
BufferedReader bufr = new BufferedReader(fr);
String line = null;
while((line=bufr.readLine())!=null){ //readLine方法返回的时候是不带换行符的。
System.out.println(line);
}
bufr.close();
转换流特有功能：转换流可以将字节转成字符，原因在于，将获取到的字节通过查编码表获取到指定对应字符。

转换流的最强功能就是基于 字节流 + 编码表 。没有转换，没有字符流。

发现转换流有一个子类就是操作文件的字符流对象：
InputStreamReader
|--FileReader
OutputStreamWriter
|--FileWrier

想要操作文本文件，必须要进行编码转换，而编码转换动作转换流都完成了。所以操作文件的流对象只要继承自转换流就可以读取一个字符了。

但是子类有一个局限性，就是子类中使用的编码是固定的，是本机默认的编码表，对于简体中文版的系统默认码表是GBK。
FileReader fr = new FileReader("a.txt");
InputStreamReader isr = new InputStreamReader(new FileInputStream("a.txt"),"gbk");
以上两句代码功能一致，
如果仅仅使用平台默认码表，就使用FileReader fr = new FileReader("a.txt"); //因为简化。

如果需要制定码表，必须用转换流。
转换流 = 字节流+编码表。
转换流的子类File = 字节流 + 默认编码表。

凡是操作设备上的文本数据，涉及编码转换，必须使用转换流。

 

对象的序列化：目的：将一个具体的对象进行持久化，写入到硬盘上。
注意：静态数据不能被序列化，因为静态数据不在堆内存中，是存储在静态方法区中。

如何将非静态的数据不进行序列化？用transient 关键字修饰此变量即可。

Serializable：用于启动对象的序列化功能，可以强制让指定类具备序列化功能，该接口中没有成员，这是一个标记接口。这个标记接口用于给序列化类提供UID。

　　这个uid是依据类中的成员的数字签名进行运行获取的。如果不需要自动获取一个uid，可以在类中，手动指定一个名称为serialVersionUID id号。

　　依据编译器的不同，或者对信息的高度敏感性。最好每一个序列化的类都进行手动显示的UID的指定。

import java.io.*;
class ObjectStreamDemo {
public static void main(String[] args) throws Exception{
writeObj();
readObj();
}
public static void readObj()throws Exception{
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt"));
Object obj = ois.readObject();//读取一个对象。
System.out.println(obj.toString());
}
public static void writeObj()throws IOException{
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt"));
oos.writeObject(new Person("lisi",25)); //写入一个对象。
oos.close();
}
}
class Person implements Serializable{
private static final long serialVersionUID = 42L;
private transient String name;//用transient修饰后name将不会进行序列化
public int age;
Person(String name,int age){
this.name = name;
this.age = age;
}
public String toString(){
return name+"::"+age;
}
}
-----------------------------------------------------------------------------------------------
DataOutputStream、DataInputStream：专门用于操作基本数据类型数据的对象。
DataOutputStream dos = new DataOutputStream(new FileOutputStream("data.txt"));
dos.writeInt(256);
dos.close();

DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));
int num = dis.readInt();
System.out.println(num);
dis.close();
-----------------------------------------------------------------------------------------------
ByteArrayInputStream：源：内存 
ByteArrayOutputStream：目的：内存。 
这两个流对象不涉及底层资源调用，操作的都是内存中数组，所以不需要关闭。
直接操作字节数组就可以了，为什么还要把数组封装到流对象中呢？因为数组本身没有方法，只有一个length属性。为了便于数组的操作，将数组进行封装，对外提供方法操作数组中的元素。

对于数组元素操作无非两种操作：设置（写）和获取（读），而这两操作正好对应流的读写操作。这两个对象就是使用了流的读写思想来操作数组。
//创建源：
ByteArrayInputStream bis = new ByteArrayInputStream("abcdef".getBytes());
//创建目的：
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int ch = 0;
while((ch=bis.read())!=-1){
bos.write(ch);
}
System.out.println(bos.toString());

package zxd.work621;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class Test9 {
public static void main(String[] args) {
    /**
     * 2.把e:\\xxx.jpg内容复制到当前项目目录下的mn.jpg中
     * 用管道流
     */
    File file = new File("F:\\aaa\\cfmv.jpg");
    File file1 = new File("E:\\copy\\mvxz.jpg");
    InputStream in = null;
    BufferedInputStream bi = null;
    OutputStream out =null;
    BufferedOutputStream bo = null;
    try {
        in = new FileInputStream(file);
        bi = new BufferedInputStream(in);
        out = new FileOutputStream(file1);
        bo = new BufferedOutputStream(out);
        byte[] by = new byte[1024];
        int ln = 0;
        while((ln = bi.read(by)) != -1){
            bo.write(by);
            bo.flush();
        }
        
    } catch (FileNotFoundException e) {
        System.out.println("创建失败");
    }catch(IOException e){
        System.out.println("创建失败");
    }finally{
        try {
            bo.close();
            bi.close();
        } catch (IOException e) {
            System.out.println("关闭失败");
        }
    }
}
}