IO流
字节流 字符流
字节输入流 字节输出流 字符输入流 字符输出流
InputStream OutputStream Reader Writer (抽象类)
FileInputStream FileOutputStream FileReader FileWriter(实现类)
BufferedInputStream BufferedOutputStream BufferedReader BufferedWriter(实现类，缓冲流)
InputStreamReader OutputStreamWriter
ObjectInputStream ObjectOutputStream
> - Windows系统里，每行结尾是 `回车+换行` ，即`\r\n`；
> - Unix系统里，每行结尾只有 `换行` ，即`\n`；
> - Mac系统里，每行结尾是 `回车` ，即`\r`。从 Mac OS X开始与Linux统一。
字节输出流【OutputStream】：
- `public void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
- `public void flush() ` ：刷新此输出流并强制任何缓冲的输出字节被写出。
- `public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
- `public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
- `public abstract void write(int b)` ：将指定的字节输出流。
- `public FileOutputStream(File file)`：创建文件输出流以写入由指定的 File对象表示的文件。
- `public FileOutputStream(String name)`： 创建文件输出流以指定的名称写入文件。
这两个构造方法，参数中都需要传入一个boolean类型的值，`true` 表示追加数据，`false`
复制文件夹
ublic class TestCopyDirDemo1 { public static void main(String[] args) throws IOException { File file1 = new File("D:\\qq\\I18N"); File file2 = new File("D:\\qq\\new"); copyDir(file1,file2); } private static void copyDir(File file1,File file2) throws IOException { if (file1.isDirectory()&&file1!=null){ file2.mkdirs(); File[] files = file1.listFiles(); for (File file : files) { if(file.isFile()){ copy(file,new File(file2,file.getName())); }else { copyDir(file,new File(file2,file.getName())); } } } } private static void copy(File file, File file1) throws IOException { BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file)); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file1)); byte[] bytes = new byte[1024]; int len; while ((len=bis.read(bytes))!=-1){ bos.write(bytes,0,len); } } }
public class FileOutputStreamDemo2 { public static void main(String[] args) throws IOException { OutputStream os=new FileOutputStream("d.txt");//追加数据管道 os.write('a'); os.write(98); byte[] bytes={99,112,111,116,106}; os.write(bytes); os.write("\n".getBytes()); byte[] bytes1="我的名字很拽\r\n".getBytes(); System.out.println(bytes1.length); os.write(bytes1); byte[] bytes3="abcde".getBytes(); os.write(bytes3,0,3); //abcpotj os.close(); //我的名字很拽 //abc } }
字节输入流【InputStream】：
- `public void close()` ：关闭此输入流并释放与此流相关联的任何系统资源。
- `public abstract int read()`： 从输入流读取数据的下一个字节。
- `public int read(byte[] b)`： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。
- `FileInputStream(File file)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的 File对象 file命名。
- `FileInputStream(String name)`： 通过打开与实际文件的连接来创建一个 FileInputStream ，该文件由文件系统中的路径名 name命名。
public class FileInputStreamDemo2 { public static void main(String[] args) throws IOException { // File file = new File("b.txt"); // file.createNewFile(); // // InputStream is=new FileInputStream(file); // byte[] buffer=new byte[3]; // int read = is.read(buffer); // System.out.println(read); // String s=new String(buffer); // System.out.println(s); // // int read1 = is.read(buffer); // System.out.println(read1); // String s1 = new String(buffer); // System.out.println(s1); // // int read2 = is.read(buffer); // System.out.println(read2); // String s2 = new String(buffer); // System.out.println(s2); InputStream is= new FileInputStream("b.txt"); byte[] buffer=new byte[3]; int len=0; while((len=is.read(buffer))!=-1){ String s=new String(buffer,0,len); System.out.print(s); }
is.close(); } }
字符输入流【Reader】:
- `public void close()` ：关闭此流并释放与此流相关联的任何系统资源。
- `public int read()`： 从输入流读取一个字符。
- `public int read(char[] cbuf)`： 从输入流中读取一些字符，并将它们存储到字符数组 cbuf中 。
- `FileReader(File file)`： 创建一个新的 FileReader ，给定要读取的File对象。
- `FileReader(String fileName)`： 创建一个新的 FileReader ，给定要读取的文件的名称。
public class FileReaderDemo2 { public static void main(String[] args) throws IOException { // Reader fr=new FileReader("bb.txt"); // char[] buffer=new char[3]; // int len = fr.read(buffer); // String s=new String(buffer); // System.out.println(s); Reader fr = new FileReader("bb.txt"); char[] buffer=new char[1024]; int len; while ((len=fr.read(buffer))!=-1){ System.out.println(new String(buffer,0,len)); } fr.close(); } }
字符输出流【Writer】:
- `public abstract void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。
- `public abstract void flush() ` ：刷新此输出流并强制任何缓冲的输出字符被写出。
- `public void write(int c)` ：写出一个字符。
- `public void write(char[] cbuf)`：将 b.length字符从指定的字符数组写出此输出流。
- `public abstract void write(char[] b, int off, int len)` ：从指定的字符数组写出 len字符，从偏移量 off开始输出到此输出流。
- `public void write(String str)` ：写出一个字符串。
- `FileWriter(File file)`： 创建一个新的 FileWriter，给定要读取的File对象。
- `FileWriter(String fileName)`： 创建一个新的 FileWriter，给定要读取的文件的名称
**写出字符数组** ：`write(char[] cbuf)` 和 `write(char[] cbuf, int off, int len)`
public class FileWriterDemo2 { public static void main(String[] args) throws IOException { FileWriter fw = new FileWriter("www.txt"); fw.write("我"); fw.flush(); fw.write("爱"); fw.flush(); fw.write("中"); fw.close(); fw.write("国"); fw.close(); //报错 java.io.IOException: Stream closed } }
public class FileWriterDemo3 { public static void main(String[] args) throws IOException { FileWriter fw1 = new FileWriter("www.txt"); char[] ch="我爱中国".toCharArray(); fw1.write(ch,1,2); //爱中 fw1.write("\r\n"); String s="喜羊羊与灰太狼"; fw1.write(s,1,5); //羊羊与灰太 fw1.close(); } }
字节缓冲流：
* `public BufferedInputStream(InputStream in)` ：创建一个 新的缓冲输入流。
* `public BufferedOutputStream(OutputStream out)`： 创建一个新的缓冲输出流。
// 创建字节缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("bis.txt"));
// 创建字节缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bos.txt"));
public class BufferedStreamDemo1 { public static void main(String[] args) { long start=System.currentTimeMillis(); try(BufferedInputStream bis = new BufferedInputStream( new FileInputStream("E:\\素材\\鬼灭之刃-栗花落香奈乎（包含图片素材）\\tsy.mp4")); BufferedOutputStream bos=new BufferedOutputStream( new FileOutputStream("E:\\素材\\鬼灭之刃-栗花落香奈乎（包含图片素材）\\缓冲速度.mp4")); ) { byte[] bytes = new byte[8*1024]; int len; while ((len=bis.read(bytes))!=-1){ bos.write(bytes,0,len); } } catch (FileNotFoundException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } long end=System.currentTimeMillis(); System.out.println(end-start); //108 } }
字符缓冲流
* `public BufferedReader(Reader in)` ：创建一个 新的缓冲输入流。
* `public BufferedWriter(Writer out)`： 创建一个新的缓冲输出流。
// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("br.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("bw.txt"));
* BufferedReader：`public String readLine()`: 读一行文字。
* BufferedWriter：`public void newLine()`: 写一行行分隔符,由系统属性定义符号。
public class BufferedWriterDemo1 { public static void main(String[] args) throws IOException{ BufferedWriter bw = new BufferedWriter(new FileWriter("缓冲字符流.txt")); bw.write("我爱中国"); bw.newLine(); bw.write("我和他他他"); bw.write("\r\n"); bw.write("我们之间的距离"); bw.newLine(); bw.close(); BufferedReader bd = new BufferedReader(new FileReader("缓冲字符流.txt")); // int len; // while ((len=bd.read())!=-1){ // System.out.print((char) len); // } String line; while ((line=bd.readLine())!=null){ System.out.println(line); //我爱中国 //我和他他他 //我们之间的距离 } bd.close();
转换流
InputStreamReader类
* `InputStreamReader(InputStream in)`: 创建一个使用默认字符集的字符流。
* `InputStreamReader(InputStream in, String charsetName)`: 创建一个指定字符集的字符流。
InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");
public class InputStreamReaderDemo1 { public static void main(String[] args) throws IOException { InputStreamReader isr = new InputStreamReader(new FileInputStream("d.txt")); int len; while ((len=isr.read())!=-1){ System.out.print((char)len); //�ҵ����ֺ�ק }
isr.close(); InputStreamReader isr2 = new InputStreamReader(new FileInputStream("d.txt"),"GBK"); int len2; while ((len2=isr2.read())!=-1){ System.out.print((char)len2); //我的名字很拽 }
isr2.close(); } }
OutputStreamWriter类
- `OutputStreamWriter(OutputStream in)`: 创建一个使用默认字符集的字符流。
- `OutputStreamWriter(OutputStream in, String charsetName)`: 创建一个指定字符集的字符流。
OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("out.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("out.txt") , "GBK");
public class OutputStreamWriterDemo1 { public static void main(String[] args) throws IOException { OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("转换流的写入.txt")); osw.write("我和大家都在一起"); //UTF-8 osw.close(); OutputStreamWriter osw2 = new OutputStreamWriter(new FileOutputStream("转换流的写入2.txt"),"GBK"); osw2.write("我和大家都在一起"); osw2.close(); //GBK } }
序列化：就是把Java对象数据直接存储到文件中去。 对象 => 文件中
反序列化：把Java对象的文件数据恢复到Java对象中。 文件中 => 对象
1一个对象要想序列化，必须满足两个条件:
* 该类必须实现`java.io.Serializable ` 接口，`Serializable` 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException` 。
* 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient` 关键字修饰。
-- 构造器：public ObjectInputStream(InputStream is)
-- 方法：public final Object readObject()
public class SerializeDemo1 { public static void main(String[] args) throws IOException { ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("obj.txt")); Student student = new Student("猪猪侠",16,98); oos.writeObject(student); oos.close(); } } class Student implements Serializable { private static final long serialVersionUID = 1L; //序列版本号 private String name; private int age; private transient int score;//transient修饰的成员变量将不参与序列化
public class SerializeDemo2 { public static void main(String[] args) throws IOException, ClassNotFoundException { ObjectInputStream ois = new ObjectInputStream(new FileInputStream("obj.txt")); Student student=(Student) ois.readObject(); System.out.println(student); //需要重写toString方法 ois.close(); } }
打印流：PrintStream / PrintWriter.
打印流的构造器：
public PrintStream(OutputStream os):
public PrintStream(String filepath):
打印流可以方便，且高效的打印各种数据。
PrintStream不光可以打印数据，还可以写"字节数据"出去。
PrintWriter不光可以打印数据，还可以写"字符数据"出去
public class PrintStreamDemo1 { public static void main(String[] args) throws IOException { // PrintStream ps = new PrintStream(new FileOutputStream("打印流.txt")); PrintStream ps = new PrintStream("打印流.txt"); ps.println(true); ps.println("我爱你"); ps.println('s'); ps.println(95); ps.println(15.26); ps.close(); } }
public static void setOut(PrintStream out) :让系统的输出流向打印流。
public class PrintStreamDemo2 { public static void main(String[] args) throws IOException { PrintStream ps = new PrintStream("打印流2.txt"); System.setOut(ps); System.out.println(123); System.out.println("四五六"); System.out.println('7'); } }
