🍧 Peach

try{
    File file = new File("D://Test//test.txt");
    FileInputStream fis = new FileInputStram(file);
    int i = fis.read(); // ← 每次读取一个字节
    while(i!=-1){
        System.out.ptinln(i); // → 返回字节对应得Unicode码
        i = fis.read(); 
    }
}catch(IOException e){
    e.printStackTrace;
}

  try{
      FileInputStream fis = new FileInputStram("D://Test//test.txt");
      byte[] b = new bytep[5];	
      int count = fis.read(b); // ← 读取文件内容，装进数组里
      while(count!=-1){	// → 返回读取到的有效字节个数
          // 🔸 String value = new String(b);
          String value = new String(b, 0, count);  // 使用偏移量构造字节型数组字符串
          System.out.ptint(value); // 
          count = fis.read(b); 
      }
  }catch(IOException e){
      e.printStackTrace;
  }

/* 文件内容：
 *	abcdefg
 *	hijklmn
 *	opq
 */

/* 🔸 直接使用String(b)读取内容：
 *	a  b  c  d  e
 *	f  g  \r \n h
 *	i  j  k  l  m 
 *	n  \r \n o  p
 *	q  \r \n o  p  <—— 到q结束，但是之前的没有被替换掉

try {
    FileInputStream fis = new FileInputStream("D://Test//test.txt");
    fis.skip(2);
    int code = fis.read();  // c
    System.out.println((char)code);
} catch (IOException e) {
    e.printStackTrace();
}

try{
    File file = new File("D://Test//test.txt");
    FileOutStream fos = new FileOutStram(file);
    fos.write(97);	// 写入code码
    fos.flush();	// 刷新 将管道中的字节推入文件中
}catch(IOException e){
    e.printStackTrace;
}

try{
    File file = new File("D://Test//test.txt");
    FileOutStream fos = new FileOutStram(file);
    fos.write(97);	// 写入code码
    fos.flush();	// 刷新 将管道中的字节推入文件中
    }
}catch(IOException e){
    e.printStackTrace;
}

String str = "abc";
char[] c = str.toCharArray();
FileWriter fw = new FileWriter(file);
fw.write(97);
fw.write(c);

import java.io.*;

public class OperateFile {

    public void copyFile(File file, String path){
        try {
            // 🔻 0 创建对象
            FileInputStream fis = new FileInputStream(new File("D://test.txt"));
            File newFile = new File(path + "//" + file.gsetName());
            FileOutputStream fos = new FileOutputStream(newFile);
            
            // 🔻 1 读取文件
            byte[] b = new byte[1024]; // 通常创建的数组：1kb-8kb之间
            int count = fis.read(b); // count记录读取的有效字节数，读取到byte数组b里
  
            // 🔻 2 写入文件
            while(count!=-1){ // 当能读取到内容时
                          
            	// 🔸（做点手脚）
                fos.write(b, 0, count); // 写入有效字节数
                fos.flush();
                count = fis.read(b); // 最后再次读取，读取不到内容时，count=-1时退出while循环
            }
            System.out.println("复制完毕！");
        
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭
        }
    }

    public static void main(String[] args) {
        OperateFile of = new OperateFile();
        of.copyFile(new File("D://test.txt"), "D://test");
    }
}

// 读取文件 -> 做点手脚 -> 写入文件
byte temp = b[0];
b[0] = b[1];
b[1] = temp;

public void superCopyFile(File file, String newPath){

    String oldFilePath = file.getAbsolutePath();
    String newFilePath = newPath + oldFilePath.split(":")[1];

    File[] files = file.listFiles(); // 获取当前传递进来的File对象的所有子元素
    File newFile = new File(newFilePath);

    // 判断当前传递进来的file是个文件还是个文件夹 （①isFile isDirectory  ②listFile)
    if(files!=null){ // 🔻 1. 文件夹（才能构成文件数组对象）
        newFile.mkdir();	// 通过新的file对象操作 在硬盘上创建一个文件夹
        if(files.length!=0){ // 🔻 3. 文件夹内有文件              
            for(File f:files){
                this.superCopyFile(f, newPath); // 👈 使用递归
            }
        }
        System.out.println(newFile.getName() + "文件夹复制完成！");

    } else { // 🔻 2. 文件 （没有子文件了）

        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            fis = new FileInputStream(new File(oldFilePath));
            fos = new FileOutputStream(newFile);
            byte[] b = new byte[1024];
            int count = fis.read(b);
            while(count!=-1){
                fos.write(b,0,count);
                fos.flush();
                count = fis.read(b);
            }
            System.out.println(newFile.getName() + "文件复制完成！");

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis!=null){
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos!=null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}

// 构造方法：
// ① 以管道输出流的实例作为输入 (使其连接到src指定的管道字节输出流。) 
PipedInputStream(PipedOutputStream src);  
// ② 创建一个尚未连接的PipedInputStream
PipedInputStream();                       

// 调用PipedInputStream类的connect()建立与输出流的连接：使此管道输入流连接到管道输出流src
void connect(PipedOutputStream src); 

public int avaliable();                       // 返回可读取的字节书
public void close();                          // 关闭管道输入流并释放系统资源
public int read();                            // 从管道输入流中读取下一个字节数据
public int read(byte[] b, int off, int len);  // 从管道输入流读取len字节数据到数组
protected void receive(int b);                // 从管道中接受1字节数据
public void connect(PipedOutputStream src);   // 连接到指定输出流，管道输入流将从该输出流接受数据

/**
 * 简单地建立流链接（📌 注意：这样实际上没有意义，通常应用于线程间通信）
 */
public class TestPipedInputStream {
    public static void main(String[] args) throws IOException {
        try {
            // 🔹 创建管道输出流
            PipedOutputStream os = new PipedOutputStream();
            // 🔹 创建输入流
            PipedInputStream is = new PipedInputStream(os);

            // 🔸 从输出流写入数据
            byte[] b = new byte[3];
            b[0] = 100;
            b[1] = 101;
            b[2] = 102;
            os.write(b);

            // 🔸 从输入流读取数据
            while (is.available() ＞ 0) {
                int c = is.read();
                System.out.print((char)c);
            }

            // 🔹 关闭输入流
            is.close();

            //关闭输出流
            os.close();
        } catch (IOException e) {
        }
    }
}

/**
 *  管道输出流与管道输入流在多线程中的应用：
 *   - Sender：管道输出流（PipedOutputStream）的独立线程类
 *   - Receiver：管道输入流（PipedInputStream）的独立线程类
 */
public class TestPipedOutputStream {
  
    public static void main(String[] args) {
        try {
            // 🔹 创建发送者线程
            Sender t1 = new Sender();
            PipedOutputStream out = t1.getOutputStream();
            // 🔹 创建接收者线程
            Receiver t2 = new Receiver();
            PipedInputStream in = t2.getInputStream();
            // 🔸 连接管道流
            out.connect(in);

            // 🔹 启动发送者线程和接收者线程
            new Thread(t1).start();
            new Thread(t2).start();
           // 在这两个线程都启动后就会运行各自的run()主函数，
           // 从out中写入的数据就会传递到in中，实现数据的异步传输。
          
        } catch (Exception e) {
        }
    }
  
}

//（1）发送者线程类
class Sender extends Thread {
    private PipedOutputStream out = new PipedOutputStream();

    public PipedOutputStream getOutputStream() {
        return out;
    }

    public void run() {
        // 🔹 发送字符串
        String s = new String("hello,receiver,how are you");
        try {
            out.write(s.getBytes());
            out.close();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

//（2）接收者线程
class Receiver extends Thread {
    private PipedInputStream in = new PipedInputStream();

    public PipedInputStream getInputStream() {
        return in;
    }

    public void run() {
        // 🔹 接收字符串
        String s = null;
        byte[] buf = new byte[1024];
        try {
            int len = in.read(buf);
            s = new String(buf, 0, len);
            System.out.println("from:\n" + s);
            in.close();
        } catch (IOException e) {
            System.out.println(e.getMessage());
        }
    }
}

// 运行该程序，即可实现发送者线程往接收者线程发送数据的功能，
// 它们分别使用了管道输入流和输出流。

//（1）串联数据源
SequenceInputStream(InputStream s1,InputStream s2);  // 将按顺序读取这两个参数，先读取s1，然后读取s2         
//（2）串联 Enumeration 类型的数据源列表
SequenceInputStream(Enumeration＜?extends InputStream＞e);  

/** 将两个文件数据源串联起来，创建一个SequenceInputStream类型的数据源并输出文件内容到控制台中。 */
public class TestSequenceInputStream {
    public static void main(String[] args) {
        try {
            // 🔹 创建输入源数组
            // * 串联的数据源列表中，可以包含各种InputStream实现类的数据流对象。
            FileInputStream fis1 = new FileInputStream("D:/demo/test.txt");
            FileInputStream fis2 = new FileInputStream("D:/demo/test2.txt");
            Vector＜FileInputStream＞ vector = new Vector＜FileInputStream＞();
            vector.add(fis1);
            vector.add(fis2);
            Enumeration＜FileInputStream＞ e = vector.elements();

            // 🔸 创建序列输入源
            SequenceInputStream is = new SequenceInputStream(e);

            // 🔹 从输入流读取数据
            while (is.available() ＞ 0) {
                int c = is.read();
                System.out.print((char)c);
            }

            // 🔹 关闭输入流
            is.close();
        } catch (IOException e) {
        }
    }
}

public class TestBufferedInputStream {
    public static void main(String[] args) {
        try {
            // 🔹创建输入流
            FileInputStream is = new FileInputStream("D:/demo/test.txt");
            BufferedInputStream bis = new BufferedInputStream(is);
            // 🔹从输入流读取数据
            while (bis.available() ＞ 0) {
                int c = bis.read();
                System.out.print((char)c);
            }

            // 🔹关闭输入流
            bis.close();
            is.close();
        } catch (IOException e) {
        }
    }
}

/** 将文件输入流对象os转换为缓存输出流 */
public class TestBufferedOutputStream {
    public static void main(String[] args) {
        try {
            // 🔹创建输出流
            FileOutputStream os = new FileOutputStream("D:/demo/test.txt");
            BufferedOutputStream bos = new BufferedOutputStream(os);

            // 🔹写入数组数据
            byte[] buf = new byte[3];
            buf[0] = 100;
            buf[1] = 101;
            buf[2] = 102;
            bos.write(buf);

            // 🔹关闭输出流
            bos.close();
            os.close();
        } catch (IOException e) {
        }
    }
}

// 运行该程序，将会往文件中写入3个字符“def”。

BufferedReader(Reader in);        // 创建一个使用默认大小输入缓存区的缓存字符输入流
BufferedReader(Reader in,int sz); // 创建一个使用指定大小输入缓存区的缓存字符输入流

/**
 * 组合使用 FileReader 和 BufferedReader：获得一个具有缓存的文件输入流
 */ 
public class TestBufferedReader {
    public static void main(String[] args) {
        try {
            // 🔹创建输入流
            FileReader is = new FileReader("D:/demo/test.txt");
            BufferedReader bis = new BufferedReader(is);

            // 🔹从输入流读取数据
            while (bis.ready()) {
                int c = bis.read();
                System.out.print((char)c);
            }

            // 🔹关闭输入流
            bis.close();
            is.close();
        } catch (IOException e) {
        }
    }
}

// 运行该程序，将会输出文件中的内容到控制台中。

 PrintWriter out = new PrintWriter(
   new BufferedWriter(new FileWriter("foo.out")));

// 若没有缓冲，则每次调用 print() 方法会导致将字符转换为字节，
// 然后立即写入到文件，而这是极其低效的。

/** 将文件输入流对象os转换为缓存输出流。 */
public class TestBufferedWriter {
    public static void main(String[] args) {
        try {
            // 🔹 创建输出流
            FileWriter os = new FileWriter("D:/demo/test.txt");
            BufferedWriter bos = new BufferedWriter(os);

            // 🔹 写入数组数据
            char[] buf = new char[3];
            buf[0] = 'a';
            buf[1] = 'b';
            buf[2] = '中';
            bos.write(buf);

            // 🔹 关闭输出流
            bos.close();
            os.close();
        } catch (IOException e) {
        }
    }
}

// 运行该程序，将会在文件中写入“ab中”。

boolean readBoolean();   // 读取一个boolean值
byte readByte();         // 读取一个8位的字节
char readChar();         // 读取一个16位的char值
double readDouble();     // 读取一个 64 位的double值
float readFloat();       // 读取一个 32 位的float值
int readInt();           // 读取一个 32 位的int值
long readLong();         // 读取一个 64 位的long值
short readShort();       // 读取一个 16 位的short值

ObjectInputStream：读取基本数据类型 + 对象数据类型
DataInputStrream： 读取基本数据类型

/**
 * 读取DataOutputStream类所写文件的过程
 *  （data.tmp可以通过下一节中 DataOutputStream 类的演示程序运行生成）
 */
public class TestDataInputStream {
  
    public static void main(String[] args) {
        try {
            // 🔹 创建文件输入流
            FileInputStream fis = new FileInputStream("D:/demo/data.tmp");
            // 🔹 创建数据输入流
            DataInputStream dis = new DataInputStream(fis);
            // 🔸 读取对象数据
            int i = dis.readInt();
            boolean b = dis.readBoolean();
            float f = dis.readFloat();
            System.out.println("i=" + i);
            System.out.println("b=" + b);
            System.out.println("f=" + f);

            // 🔹 关闭输入流
            dis.close();
            fis.close();
        } catch (IOException e) {
        }
    }
  
}

//  i=12345
//  b=true
//  f=1000.0

// 继承OutputStream的同时，实现了DataOutput接口，因此它具有DataOutput所规定的方法：

void writeBoolean(boolean v);  // 将一个boolean值以1-byte值形式写入输出流
void writeByte(int v);         // 将一个byte值以1-byte值形式写出到输出流中
void writeBytes(Strings);      // 将字符串按字节顺序写出到输出流中
void writeChar(int v);         // 将一个char值以2-byte值形式写入输出流中，先写入高字节
void writeChars(Strings);      // 将字符串按字符顺序写入输出流
void writeDouble(double v);    // 使用Double类中的doubleToLongBits方法将double参数转换为一个long值，然后将该long值以8-byte值形式写入输出流中，先写入高字节
void writeFloat(float v);      // 使用Float类中的floatToIntBits方法将float参数转换为一个int值，然后将该int值以4-byte值形式写入输出流中，先写入高字节
void writeInt(int v);          // 将一个int值以4-byte值形式写入输出流中，先写入高字节
void writeLong(long v);        // 将一个long值以8-byte值形式写入输出流中，先写入高字节
void writeShort(int v);        // 将一个short值以2-byte值形式写入输出流中，先写入高字节
void writeUTF(Stringstr);      // 以与机器无关方式使用UTF-8编码将一个字符串写入输出流

/**
 * DataOutputStream类写入文件data.tmp的过程。
 */
public class TestDataOutputStream {
    public static void main(String[] args) {
        try {
            // 🔹 创建文件输出流
            FileOutputStream fos = new FileOutputStream("D:/demo/data.tmp");
            // 🔹 创建对象输出流
            DataOutputStream oos = new DataOutputStream(fos);

            // 🔸 写入对象数据
            oos.writeInt(12345);
            oos.writeBoolean(true);
            oos.writeFloat(1000.0f);

            // 🔹 关闭输出流
            oos.close();
            fos.close();
        } catch (IOException e) {
        }
    }
}

// 运行该程序，将会将对象数据写入文件中。

getLineNumber();   // 取得行号
setLineNumber();   // 设置行号

/** 
 *  按照文件的行读取，输出每一行的行号和内容。
 */

public class TestLineNumberInputStream {
    public static void main(String[] args) {
        try {
            // 🔹 创建文件输入流
            FileInputStream fis = new FileInputStream("D:/demo/test.txt");
            // 🔹 创建行号输入流
            LineNumberInputStream lis = new LineNumberInputStream(fis);
            // 🔹 创建数据输入流：通过DataInputStream 进行输入流过滤，获得readLine()的功能。
            DataInputStream dis = new DataInputStream(lis);

            // 🔸 读取数据
            String line;
            while ((line = dis.readLine()) != null) {
                System.out.println(lis.getLineNumber() + ":" + line);
            }

            // 关闭输入流
            dis.close();
            lis.close();
            fis.close();
        } catch (IOException e) {
        }
    }
}

//  1:hello,World!
//  2:hello,China!
//  3:Hello,Beijing!

LineNumberReader(Reader in);           // 使用默认输入缓存区的大小创建新的行编号reader
LineNumberReader(Reader in,int sz);    // 创建新的行编号reader，将字符读入给定大小的缓存区

getLineNumber();     // 取得行号  
setLineNumber(int);  // 设置行号

// 注意：setLineNumber(int)不会实际更改流中的当前位置；它只更改由getLineNumber()返回的值

/**
 *  根据文件输入流fis创建行号输入流的方法，
 *  通过lis的readLine()方法可以读取一行数据，使用getLineNumber()取得行号，并输出行号和该行内容。
 */
public class TestLineNumberReader {
    public static void main(String[] args) {
        try {
            // 🔹 创建文件输入流
            FileReader fis = new FileReader("D:/demo/test.txt");
            // 🔹 创建行号输入流
            LineNumberReader lis = new LineNumberReader(fis);

            // 🔸 读取数据
            String line;
            while ((line = lis.readLine()) != null) {
                System.out.println(lis.getLineNumber() + ":" + line);
            }

            // 关闭输入流
            lis.close();
            fis.close();
        } catch (IOException e) {
        }
    }
}

// 1:hello,World!
// 2:hello,China!
// 3:Hello,Beijing!