IO是指输入(Input)、输出(Output)

  1. String str1 = System.getProperty("user.dir"); 
  2. // 获取项目位置
  3. String str2 = System.getProperty("sun.java.command").replaceAll("[.]", "\\\\"); 
  4. // 获取运行路径
  5. // 当前类文件改txt文件

流

在计算机中，所有的文件都是由二进制组成，二进制数据从一个点流向另一个点的过程与结果

文件

file

  1. // 文件对象创建
  2. File new File(String pathname); // 相对路径 / 绝对路径
  3. File new File(File parent, String child); // 父路径+子路径
  4. File new File(String parent, String child); // 父路径+子路径
  6. // 创建一个临时文件并返回Filf对象
  7. // prefix(长度大于3)开头 + 19位随机数 + 后缀suffix(.tmp)
  8. static File File.createTempFile(String prefix, String suffix); // 系统临时文件位置
  9. static File File.createTempFile(String prefix, String suffix, File directory); // 自定义位置
  10. File createTempFile()
  12. // 增、改
  13. createNewFile(); // 创建文件
  14. // 文件不存在并被成功创建返回true，文件存在返回false，文件目录不能存在会报错
  15. boolean mkdir(); // 创建file对象目录
  16. boolean mkdirs();// 可创建多层目录
  17. boolean renameTo(File dest); //  重命名对象
  18. boolean setLastModified(long time); // 设置文件目录最后修改时间
  20. // 删
  21. boolean delete(); // 删除文件
  22. // 文件存在并被删除返回true，文件或目录不存在返回false
  24. // 判断
  25. boolean exists(); // 查看此抽象路径的文件或目录是否存在。
  26. boolean isFile(); // 它是不是文件
  27. boolean isHidden();// 它是隐藏文件吗
  28. boolean isDirectory(); // 它是不是目录
  29. boolean equals(); // 两个文件对象是否相等
  30. boolean isAbsolute(); // 路径名是否是绝对的
  32. // 查
  33. String getPath(); // 返回路径(相对 或 绝对)
  34. String getAbsolutePath(); // 返回绝对路径
  35. String getName(); // 返回文件名，没有文件返回目录名
  36. String getParent();// 返回父目录字符串
  37. File getParentFile(); // 返回父目录对象
  38. String[] list(); // 返回当前目录下的所有文件和目录名
  39. String[] list(FilenameFilter filter); // 过滤规则
  40. File[] listFiles(); // 返回当前目录下的所有file对象
  41. File[] listFiles(FilenameFilter filter); // 过滤规则
  42. File[] listFiles(FileFilter filter); // 过滤规则
  43. static File[] listRoots(); // 可用的文件系统根

过滤器

  1. new FilenameFilter() {
  2.     @Override
  3.     public boolean accept(File dir, String name) {
  4.         return false;
  5.     }
  6. }
  8. new FileFilter() {
  9.     @Override
  10.     public boolean accept(File pathname) {
  11.         return false;
  12.     }
  13. }
  15. (dir, name) -> {
  16.     if(name.endsWith(".txt")){
  17.         return true;
  18.     }return false;
  19. }

path

Properties类

Java 语言的配置文件所使用的类 java中一种数据存储容量，key和value字符字符串数据

  1. new Properties(); // 创建一个没有默认值的空属性列表
  2. new Properties(Properties defaults)；
  4. // 输出流中加载数据
  5. void load(InputStream inStream);
  6. void load(Reader reader);
  7. // 数据打印到指定的输出流
  8. void list(PrintStream out);
  9. void list(PrintWriter out);
  10. // 从Properties中的键搜索值
  11. String getProperty(String key);
  12. String getProperty(String key, String defaultValue);
  13. // 增加或修改Properties(需要保存生效)
  14. void store(Writer writer, String comments)
  16. setProperty(String key, String value);
  17. setProperty()

字节流

FileStream文件流

FileOutputStream / FileInputStream
用于写入或读取原始字节流

  1. /* FileOutputStream */
  2. FileOutputStream new FileOutputStream(File file);
  3. FileOutputStream new FileOutputStream(File file, boolean append);
  4. FileOutputStream new FileOutputStream(String path);
  5. FileOutputStream new FileOutputStream(String path, boolean append);
  6. FileOutputStream new FileOutputStream(FileDescriptor fdObj);
  7. FileOutputStream new FileOutputStream(FileDescriptor fdObj, boolean append);
  8. // 创建字节输出流
  9. // append默认为false，会覆盖原有数据，false则尾部添加
  10. void writer(int b);// 写入一个ASCII码字符
  11. void writer(byte[] bytes);// 写入一串char型数组
  12. void writer(byte[] bytes, off int, len int);// 数组切分并写入一串数组(off位置， len长度)
  13. FileOutputStream.close();
  14. // 关闭资源  原则: 先开的后关,后开的先关
  16. // 创建byte数组
  17. byte[] new byte[]{'h', 'e', 'l', 'l', 'o'};
  18. byte[] "hello".getBytes();
  20. /* FileInputStream; */
  21. FileInputStream new FileInputStream(File file);
  22. FileInputStream new FileInputStream(String pathname);
  23. int read();// 读取一个字符并返回ASCII码
  24. int read(byte[] bytes);// 覆盖bytes数组，读取数量为数组长度，返回读取长度
  25. int read(byte[] bytes, off int, len int); // 偏移量+长度>=数组长度会报错(索引越界)
  26. void close(); // 关闭此文件输入流并释放与流相关联的任何系统资源。
  27. long skip(long n);// 跳过n个字节

ObjectStream对象流

ObjectOutStream / ObjectInputStream

ObjectOutputStream和ObjectInputStream可以分别为与 FileOutputStream和FileInputStream一起使用的对象图提供持久性存储的应用程序。

ObjectOutStream用于将一个对象写入流中，任何对象，包括字符串和数组，都是用writeObject编写的 ObjectInputStream用于恢复先前序列化的对象。 其他用途包括套接字流在主机之间传递对象，或者在远程通信系统中进行封送和解组参数和参数。

序列化：将原始数据(对象、字符串、数组) 转化为 文件 反序列化：将 文件 转化为 原始数据

DataOutput可以将原始数据写入流中，字符串可以使用writeUTF DataInput可以中流中获取原始数据

1：永久性保存对象，保存对象的字节序列到本地文件或者数据库中 2：通过序列化以字节流的形式使对象在网络中进行传递和接收； 3：通过序列化在进程间传递对象。 

  1. /* ObjectOutputStream */
  2. ObjectOutputStream new ObjectOutputStream();
  3. ObjectOutputStream new ObjectOutputStream(OutputStream out);
  5. void writeByte(int val);void writeShort(int val);void writeInt(int val);
  6. void writeLong(long val);void writeFloat(float);void writeDouble(double val);
  7. void writeChar(int val);void write(boolean val);
  8. // 写入byte、short、int、long、float、double、char、boolean
  9. void write(int val); // 写入一个字节
  10. void write(byte[] buf); // 写入一个字节数组
  11. void write(byte[] buf, int off, int lne);
  12. void writeBytes(String str); // 写入一个字符串作为字节序列
  13. void writeChars(String str); // 写入一个字符串作为字符序列
  14. void writeObject(Object obj); // 将指定的对象写入ObjectOutputStream
  16. // 基本操作
  17. FileOutputStream fos = new FileOutputStream(path);
  18. ObjectOutputStream oos = new ObjectOutputStream(fos);
  19. oos.writeObject(data);
  20. oos.close(); fos.close(); // 先开的后关,后开的先关
  22. /* ObjectInputStream */
  23. ObjectInputStream new ObjectInputStream();
  24. ObjectInputStream new ObjectInputStream(InputStream in);
  26. byte readByte();short readShort();int readInt();long readLong();
  27. float readFloat();double readDouble();char readChar();boolean readBoolean();
  28. // 读取byte、short、int、long、float、double、char、boolean
  29. int read(); // 读取一个字节数据
  30. int read(byte[] buf, int off, int len); // 读取一个字节数组
  31. void readFully(byte[] buf); // 读取直接，阻塞直到读取所有字节
  32. void readFully(byte[] buf, int off, int lne);
  33. Object readObject(); // ObjectInputStream读取一个对象
  35. // 基本操作
  36. FileInputStream fis = new FileInputStream(path);
  37. ObjectInputStream ois = new ObjectInputStream(fis);
  38. Object data = ois.readObject();
  39. ois.close(); fis.close(); // 先开的后关,后开的先关

byteArrayStream

ByteArrayOutputStream / ByteArrayInputStream

将数据（写入/读取）字节数组的输出流 字节数组输入流是在内存中创建一个字节数组缓冲区，读取或写入缓冲区。

缓冲区是一块特定的内存区域，其目的是通过缓解应用程序上下层之间的性能差异，减少上层对下层的等待时间，以此提高系统性能

  1. /* ByteArrayOutputStream */
  2. ByteArrayOutputStream new ByteArrayOutputStream();
  3. ByteArrayOutputStream new ByteArrayOutputStream(int size); // 指定缓存区容量
  5. int size(); //返回当前缓冲区大小 
  6. byte[] toByteArray(); // 创建一个新分配的字节数组
  7. String toString(); // 将缓冲区内容转换为字符串解码字节
  8. String toString(String charsetName); // 使用charset解码字节
  9. void write(byte[] b); // 写入一串字节数组
  10. void write(byte[] b, int off, int len); // 特定的字节数组
  12. /* ByteArrayInputStream */
  13. ByteArrayInputStream new ByteArrayInputStream(byte[] buf);
  14. ByteArrayInputStream new ByteArrayInputStream(byte[] buf, int off, int len);
  15. int available(); // 输入缓冲区读取的剩余字节数
  16. int read(); //输入流中读取下一个数据字节
  17. int read(byte[] b, int off, int len); // 将len长度的字节写入字节数值中

filterStream

filterOutputStream / filterInputStream

（过滤输出流/过滤输入流）的所有超类

  1. /* filterOutputStream */
  2. void flush(); //刷新此输入流，并强制将任何缓冲的输出字节写入流
  3. void write(int b);
  4. void write(byte[] b);
  5. void write(byte[] b, int off, int len);
  7. /* filterInputStream*/
  8. int read();
  9. int read(byte[] b);
  10. int read(byte[] b, int off, int lne);

BufferedStream

BufferedOutputStream / BufferedInputStream

（缓冲输出流/缓冲输入流）

应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

  1. /* BufferedOutputStream */
  2. BufferedOutputStream new BufferedOutputStream(OutputStream out); // 将数据写入特定的底层输入流
  3. BufferedOutputStream new BufferedOutputStream(OutputStream out, int size); 
  4. // 指定缓存区大小
  7. /* BufferedInputStream */
  8. BufferedInputStream new BufferedInputStream(InputStream in);// 保存其参数，输入流 in ，供以后使用
  9. BufferedInputStream new BufferedInputStream(InputStream in, int size);
  10. // 指定缓冲区大小

DataStream

DataOutputStream / DataInputStream

（数据输出流 / 数据输入流） 使应用程序以便携式的将原始java数据类型写入输出流，然后程序可以使用数据输入流来读取数据 运行程序以独立于机器的方式从底层输入流读取原始java数据类型，然后程序可读取数据输入流中的数据

  1. /* DataOutputStream */
  2. DataOutputStream new DataOutputStream(OutputStream out);// 创建一个数据输入流，以将数据写入指定的底层输入流
  4. void write(int b); // 写入8字节值
  5. void wreateBoolean(boolean v); // 写入1字节值
  6. void writeByte(int v); // 写入1字节
  7. void writeeChar(int c); // 写入2字节值
  8. void wreatBytes(String s); // 写入作为字节序列的字符串
  9. void wreatChars(String s); // 写入作为字符序列的字符串
  10. void wreatDouble(double v); // 写入8字节
  11. void wreatFile(float v); // 写入4字节
  12. void writeInt(int v); // 写入4字节
  13. void wreatLong(long v); // 写入8字节
  14. void wreatShort(int v); // 写入2字节
  15. void write(byte[] b, int off, int len); // 指定字节数组
  17. /* DataInputStream */
  18. DataInputStream new DataInputStream(InputStream in);// 创建使用指定的底层InputStream的DataInputStream
  20. int read(byte[] b); // 写入字节数，返回长度
  21. int read(byte[] b, int off, int len); // 偏移量
  22. byte readByte();short readShort();int readInt();long readLong();
  23. float readFloat();double readDouble();char readChar();boolean readBoolean();
  24. // 读取byte、short、int、long、float、double、char、boolean
  25. // 读取byte、int、float、double、char、boolean
  26. void readFully(byte[] buf); // 读取直接，阻塞直到读取所有字节
  27. void readFully(byte[] buf, int off, int lne);

PrintStream

继承于FilterOutputStream的打印流 能够方便地打印各种数据值的表示

  1. new PrintStream(File file);
  2. // 使用指定文件创建一个新的打印流，不需要自动换行
  3. new PrintStream(FIle file, String csn); 
  4. // 自定字符集
  5. new PrintStream(OutputStream out); // 创建新的打印流
  6. new PrintStream(OutputStream out, boolean autoFlush); // 创建并刷新流
  7. new printStream(OutputStream out, boolean autoFlush, String encoding); // 修改编码格式
  8. new PrintStream(String fileName); //指定文件创建打印流
  9. new PrintStream(String fileName, String csn); // 指定文件和字符集

字符流

Buffered

BufferedWriter BufferedReader -> LineNumberReader

BufferedWriter： 将文本写入字符输出流，缓冲字符，以提供单个字符、数组和字符串的高效写入。 BufferedReader： 从字符输入流读取文本，缓冲字符，以提供字符、数组和字符串行的高效读取 LineNumberReader： BufferedReader的子类，缓冲字符输入流，跟踪和设置行号 定义setLineNumber(int)/getLineNumber()分别设置和获取当前行号

  1. /* BufferedWriter */
  2. new BufferedWriter(Writer out); // 创建默认大小的输出缓冲区的缓冲字符输出流
  3. new BufferedWriter(Writer out, int sz); // 给定输出缓冲区大小
  5. void flush(); // 刷新流
  6. void newLine(); // 写一行行分隔符
  7. void write(int c); // 写一个字符
  8. void write(String s, int off, len);
  9. void write(char[] cbuf, int off, len);
  11. /* BufferedReadeer */
  12. new BufferedReader(Reader in);
  13. new BufferedReader(Reader in, int sz);
  15. Stream<String> lines();// 返回一个Stream，其元素是从BufferedReader读取的行
  16. int read(); // 读一个字符
  17. int read(char[] cbuf, int off, int lne);
  18. String readLine(); // 读一行文字
  19. boolean ready(); // 这个流是否准备好被读取(缓冲区不为空11)
  20. long skip(long n); // 跳过字符，返回实际跳过的字符数
  22. /* LineNumberReader */
  23. new LineNumberReader(Reader in); // 创建一个行号阅读器
  24. new LineNumberReader(Reader in, int sz); // 给定缓冲区大小
  26. int getLineNumber(); // 获取当前行号
  27. int setLineNumber(int lineNumber); // 设置当前行号

CharArray

CharArrayWriter：数据写入流时，缓冲区会自动增长 CharArrayReader：实现了一个字符缓冲区，可以用作字符输入流。

  1. /* CharArrayWriter */
  2. new CharArrayWriter();
  3. new CharArrayWriter(int initialSize); // 指定初始大小
  5. void reset(); // 重置缓冲区
  6. void flush(); // 冲洗流
  7. int size(); // 返回缓冲区大小
  8. char[] toCharArray(); // 返回输入数据的副本
  9. String toString(); // 将输入数据转换为字符串
  10. void write(char[] b, int off, int lne);
  12. /* CharArrayWriter */
  13. new CharArrayWriter(char[] buf); // 指定字符数组创建CharArrayWriter
  14. new CharArrayWriter(char[] buf, int offset, int length);
  16. int read(); // 读一个字符
  17. int read(char[] b, int off, int len); // 读入数组部分
  18. boolean ready(); // 是否准备好被读取
  19. long skip(long n); // 跳过字符，返回跳过长度

Filter

FilterWriter：过滤后的字符流 FilterReader：读取过滤后的字符流 PushbackReader：继承FilterReader，字符流读取器，允许将字符推回流中

  1. /* FilterWriter */
  2. new FilterWriter(Writer out); // 创建过滤输出流
  3. void flush(); // 刷新流
  4. void writer(int c); // 写一个字符
  5. void writer(char[] cbuf);
  6. void writer(char[] cbuf, int off, int len); // 写入字符数组部分
  7. void writer(String str);
  8. void writer(String str, int off, int lne); // 写入字符串部分
  10. /* FilterReader */
  11. new FilterReader(Reader in); //  创建过滤阅读器
  12. int read(); // 读一个字符
  13. int read(char[] cbuf, int off, int len);
  14. boolean ready(); // 是否准备好被读取
  15. void reset(); // 重置流
  16. long skip(long n); // 跳过字符
  18. /* PushbackReader */
  19. new PushbackReader(Reader in); 
  20. // 用一个字符的后置缓冲区创建一个新的推回阅读器
  21. new PushbackReader(Reader in, int size);
  23. // 继承父类
  24. void unread(char[] cbuf); // 将一个字符数组复制推回缓冲区的前端
  25. void unread(int c); // 将单个字符复制回推回缓冲区的前端

FileStream

OutputStreamWriter：桥梁流，把字符流转换为字节流 FileWriter：OutputStreamWriter的子类，写入字符文件的方便类 InputStreamReader：桥梁流，把字节流转向字符流 FileReader：InputStreamReader的子类， 阅读字符文件的方便类

  1. /* OutputStreamWriter */
  2. new OutputStreamWriter(OutputStream out);// 以默认编码进行创建
  3. new OutputStreamWriter(OutputStream out, Charset cs);// 指定字符集
  4. new OutputStreamWriter(OutputStream out, CharsetEncoder, enc);// 指定字符集编码器
  5. new OutputStreamWriter(OutputStream out, String, charsetName);// 使用命名字符集
  7. void flush();
  8. String getEncoding(); // 获取使用的字符集
  9. void write(char[] cbuf, int off, int len);
  10. void write(int c);
  11. void write(String str, int off, int len);
  13. /* FileWriter */
  14. new FileWriter(File file); //给一个file对象创建的FIleWriter
  15. new FileWriter(File file boolean append); // 是否追加
  16. new FileWriter(FileDescriptor fd); // 构造与文件描述符关联的FileWriter
  17. new FileWriter(String fileName); // 构造一个给定文件名的FIleWriter
  18. new FileWriter(String fileName, boolean append); // 是否追加
  19. // 继承OutputStreamWriter
  22. /* InputStreamReader */
  23. new InputStreamReader(InputStream in); // 默认字符集创建对象
  24. new InputStreamReader(InputStream in, Charset cs); // 指定字符集创建对象
  25. new InputStreamReader(InputStream in, CharsetDecoder dec); // 指定字符解码器创建对象
  26. new InputStreamReader(InputStream in, String charsetName); // 使用命名字符集创建对象
  27. String getEncoding(); // 返回字符编码名称
  28. int read(); // 读一个字符
  29. int read(char[] cbuf, int offset, int length); // 将length个字符写入数组中
  30. boolean ready(); // 流是否准备好被读取
  32. /* FileReader */
  33. new FileReader(File file); // 给出file创建对象
  34. new FileReader(FileDescriptor fd); // 给定FIleDescriptor创建对象
  35. new FileReader(String fileName); // 给定文件名创建对象
  36. // 继承InputStreamReader

Piped

PipedWriter：字符管道输出流 PipedReader：字符管道输入流

  1. /* PipedWriter */
  2. new PipedReader(); // 未connected的对象
  3. new PipedReader(int pipSize); // 自定大小未connected的对象
  4. new PipedReader(PipedWriter src); // 创建连接src管道写入器的对象
  5. new PipedReader(PipedWriter src, int pipSize); // 创建自定大小连接src管道写入器的对象
  6. void connect(PipedWriter src); // 管道读取器连接到管道写入器
  7. int read(); // 读取下一个数据字符
  8. int read(char[] cbuf, int off, int len); // 读取len字符到数组中
  9. boolean ready(); // 准备好被阅读
  11. /* PipedReader */
  12. new PipedWriter();
  13. new PipedWriter(PipedReader snk);
  14. void connect(PipedReader snk); // 管道写入器连接到接收器
  15. void flush(); // 刷新此输出流并强制任何缓冲的输出字符被写出。
  16. void write(char[] cbuf, int off, int len);
  17. void write(int c);

Print

PrintWriter：文本打印流

  1. new PrintWriter(File file);
  2. new PrintWriter(File file, String csn);
  3. new PrintWriter(OutputStream out);
  4. new PrintWriter(OutputStream out, boolean autoFlush);
  5. new PrintWriter(String fileName);
  6. new PrintWriter(String fileName, String csn);
  7. new PrintWriter(Writer out);
  8. new PrintWriter(Writer out, boolean autoFlush);
  10. void print(boolean b);void print(char c);void print(char[] s);
  11. // 打印布尔值、字符、字符数组
  12. void print(double d);void print(float f);void print(int i);
  13. // 打印双精度浮点数、浮点数、整数
  14. void print(leng l);void print(Object obj);void print(String s);
  15. // 打印长整数、对象、字符串
  16. // 还有println方法与上面方法相同，打印后再带换行
  17. void writer(char[] buf); // 写入字符数组
  18. void writer(char[] buf, int off, int lne);// 部分字符数组
  19. void writer(int c); // 写入一个字符
  20. void writer(String s); // 写入字符串
  21. void writer(String s, int off, int lne); // 部分字符串

String

StringWriter：字符串写入器 StringReader：字符串读取器

  1. /* StringWriter */
  2. new StringWriter();// 创建写入器
  3. new StringWriter(int initial); // 指定写入器大小
  4. StringBuffer getBuffer();
  5. String toString();
  6. void writer(char[]cbuf, int off, int len);
  7. void writer(int c);
  8. void writer(String str);
  9. void writer(String str, int off, int len);
  11. /* StringReader */
  12. new StringReader(String s); // 字符串阅读器
  13. int read();
  14. int read(char[]cbuf, int off, int len);
  15. boolean ready();
  16. void reset();
  17. long skip(long ns);

System

  1. System.in.read();
  2. // 输入一个或多个字符，返回一个字符ASCII码，然后再进行调用，会有迭代的效果
  3. // 注意，read()在最后会保留最后的换行键(ascii:10)
  4. // 再进行调用read时会要求继续输入