// 字节流的世界               // 字符流的世界
FileInputStream  ---转换--->  Reader
(原始字节)       InputStreamReader (字符，带编码)

// 错误做法：直接用字节流读文本
FileInputStream fis = new FileInputStream("中文.txt");
int data;
while ((data = fis.read()) != -1) {
    System.out.print((char) data);  //  中文乱码！
}
// 原因：一个中文字符可能是2-4个字节，逐字节转char会出错

// 1. 读取文本文件（字节→字符）
FileInputStream fis = new FileInputStream("file.txt");
// 关键：指定编码转换
InputStreamReader reader = new InputStreamReader(fis, "UTF-8");

// 现在可以按字符读取了
int ch;
while ((ch = reader.read()) != -1) {
    System.out.print((char) ch);  // 正确显示中文
}

// 2. 写入文本文件（字符→字节）
FileOutputStream fos = new FileOutputStream("output.txt");
OutputStreamWriter writer = new OutputStreamWriter(fos, "GBK");
writer.write("你好世界");  // 按GBK编码写入字节
writer.close();

// 不同编码，转换结果完全不同
String text = "你好";

// UTF-8编码：每个中文通常3字节
byte[] utf8Bytes = text.getBytes("UTF-8");  // [-28, -67, -96, -27, -91, -67]

// GBK编码：每个中文2字节  
byte[] gbkBytes = text.getBytes("GBK");  // [-60, -29, -70, -61]

// ISO-8859-1：根本不支持中文！
byte[] isoBytes = text.getBytes("ISO-8859-1");  // [63, 63] 变成??

// 转换流帮你正确处理这些

// 从GBK编码文件读取，转换为UTF-8输出
try (
    FileInputStream fis = new FileInputStream("gbk_file.txt");
    // 按源文件编码读取
    InputStreamReader reader = new InputStreamReader(fis, "GBK");
    
    FileOutputStream fos = new FileOutputStream("utf8_file.txt");
    // 按目标编码写入
    OutputStreamWriter writer = new OutputStreamWriter(fos, "UTF-8")
) {
    char[] buffer = new char[1024];
    int charsRead;
    
    while ((charsRead = reader.read(buffer)) != -1) {
        writer.write(buffer, 0, charsRead);  // 自动转换编码
    }
    // 完成了 GBK → UTF-8 的转换
}

// 最佳实践：转换流 + 缓冲流
// 读取文本文件的黄金组合
try (BufferedReader reader = new BufferedReader(
        new InputStreamReader(
            new FileInputStream("large.txt"),
            StandardCharsets.UTF_8  // Java 7+ 推荐方式
        ),
        8192  // 缓冲区大小
    )) {
    
    String line;
    while ((line = reader.readLine()) != null) {  // 按行读取
        System.out.println(line);
    }
}

// 错误：不指定编码（使用平台默认）
InputStreamReader reader = new InputStreamReader(fis);
// 在中文Windows可能是GBK，在Linux可能是UTF-8 ❌

// 正确：显式指定编码
InputStreamReader reader = new InputStreamReader(fis, "UTF-8");  // ✅

// Java 7+ 推荐方式
import java.nio.charset.StandardCharsets;
InputStreamReader reader = new InputStreamReader(fis, StandardCharsets.UTF_8);

// 1. 输入转换流（InputStreamReader）
// 底层：字节流 → (按指定编码解码) → 字符流
public class InputStreamReader extends Reader {
    private final StreamDecoder sd;  // 真正的解码器
    
    public int read() throws IOException {
        return sd.read();  // 这里发生字节→字符的转换
    }
}

// 2. 输出转换流（OutputStreamWriter）  
// 底层：字符流 → (按指定编码编码) → 字节流
public class OutputStreamWriter extends Writer {
    private final StreamEncoder se;  // 编码器
    
    public void write(int c) throws IOException {
        se.write(c);  // 这里发生字符→字节的转换
    }
}

// 普通字节流：只能读写字节
// Data流：可以读写 int, double, boolean 等

// 写入基本数据类型
try (DataOutputStream dos = new DataOutputStream(
        new FileOutputStream("student.dat"))) {
    
    dos.writeUTF("张三");      // 写入字符串（UTF-8编码）
    dos.writeInt(20);         // 写入int（4字节）
    dos.writeDouble(89.5);    // 写入double（8字节）
    dos.writeBoolean(true);   // 写入boolean（1字节）
    dos.writeChar('A');       // 写入char（2字节）
}

// 读取时保持类型
try (DataInputStream dis = new DataInputStream(
        new FileInputStream("student.dat"))) {
    
    String name = dis.readUTF();      // 按字符串读
    int age = dis.readInt();          // 按int读
    double score = dis.readDouble();  // 按double读
    boolean passed = dis.readBoolean();
    char grade = dis.readChar();
    
    System.out.printf("姓名：%s, 年龄：%d, 分数：%.1f%n", 
                     name, age, score);
}

// 序列化：对象 → 字节流（保存/传输）
ObjectOutputStream oos = new ObjectOutputStream(outputStream);
oos.writeObject(user);  // 把对象变成字节流

// 反序列化：字节流 → 对象（读取/接收）
ObjectInputStream ois = new ObjectInputStream(inputStream);
User user = (User) ois.readObject();  // 把字节流变回对象

// 非常重要！用于版本兼容性
private static final long serialVersionUID = 1L;

// 如果不指定，JVM会自动生成
// 问题：类结构改变时，自动生成的UID会变，导致反序列化失败！

// 示例：
class User implements Serializable {
    // 版本1
    private static final long serialVersionUID = 1L;
    String name;
    int age;
}

// 后来添加了字段
class User implements Serializable {
    // 还是版本1（兼容旧数据）
    private static final long serialVersionUID = 1L;  // 保持不变！
    String name;
    int age;
    String email;  // 新增字段
    // 反序列化旧数据时，email为null（安全）
}

public class Student implements Serializable{
    private static final long serialVersionUID=1L;//这样就可以固定序列号，必须这么写不能改
    private transient String name;//加上这个关键字这个属性就不会序列化到本地文件中
    ...
}

public class a {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Student s1=new Student(23,"张三");
        Student s2=new Student(13,"李四");
        Student s3=new Student(43,"王五");
        ArrayList<Student> list=new ArrayList<>();//将要序列化的对象存入集合中，序列化这个集合即可解决
        list.add(s1);
        list.add(s2);
        list.add(s3);
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("3.txt"));
        oos.writeObject(list);
        oos.close();

        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("3.txt"));
        ArrayList<Student> l1=(ArrayList<Student>)ois.readObject();
        System.out.println(l1);
        ois.close();
    }
}

public class a {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        
        PrintStream ps=new PrintStream(new BufferedOutputStream(new FileOutputStream("1.txt",true)),true,"GBK");
        //这里创建方法中因为是父类OutputStream故参数可以写这个父类里面的所有子类
        //最里面的true，是字节输出流的true，表示开启续写功能
        //之所以写BufferedOutputStream是因为这个让字节打印流有缓冲区，从而可以实现自动刷新功能
        ps.printf("%s helllo world","你好");
        ps.print(11);//直接打印的就是11
        ps.println(true);//直接打印的就是true
        ps.close();

    }
}

//获取打印流对象，此打印流在虚拟机启动时，由虚拟机创建，默认指向控制台。
//特殊的打印流：系统中的标准输出流
//标准输出流是不能关闭额，在系统中是唯一的！
PrintStream os=System.out;
//调用打印流中的方法
//写出数据，自动换行，自动刷新
ps.println("123");
ps.close();//关闭了系统标准输出流后！下面的方法就不能执行了
System.out.println("123");//就是上面的方法，用链式编程搞出来的

PrintStream os=new PrintStream("/1.txt");
System.setOut(ps);//输出语句重定向

 ```java

 // 普通流：要处理IOException
 try {
     FileOutputStream fos = new FileOutputStream("file.txt");
     fos.write(data);
     fos.close();
 } catch (IOException e) {
     // 必须处理
 }
 
 // PrintStream：不抛受检异常！
 PrintStream ps = new PrintStream("file.txt");
 ps.println("Hello");  // 不需要try-catch！
 ps.close();           // 也不抛IOException
 
 // 怎么知道出错了？
 if (ps.checkError()) {  // 检查错误标志
     System.out.println("写入出错！");
 }

 ```java
 // 创建自动刷新的PrintStream
 PrintStream ps = new PrintStream(
     new FileOutputStream("log.txt"), 
     true  // autoFlush = true
 );
 
 ps.println("Log entry 1");  // 自动调用flush()
 ps.println("Log entry 2");  // 数据立即写入，不会在缓冲区等待
 ps.println("Log entry 3");
 
 // 对比：普通OutputStream需要手动flush
 OutputStream os = new FileOutputStream("log.txt");
 os.write("Log entry 1\n".getBytes());
 os.flush();  // 必须手动调用！

 ```java
 PrintStream ps = System.out;  // System.out就是PrintStream！
 
 // 1. printf格式化（C语言风格）
 ps.printf("姓名: %s, 年龄: %d, 成绩: %.2f%n", 
           "张三", 20, 95.5);
 
 // 2. format格式化（Java风格）
 ps.format("时间: %tT, 日期: %tF%n", 
           new Date(), new Date());
 
 // 3. 各种格式化选项
 ps.printf("十六进制: %x, 八进制: %o%n", 255, 255);  // ff, 377
 ps.printf("科学计数: %e%n", 1234567.89);  // 1.234568e+06
 ps.printf("金额: %,.2f元%n", 1234567.89);  // 1,234,567.89元
 ps.printf("宽度对齐: [%-10s][%10s]%n", "左对齐", "右对齐");
 
 // 手动格式化得写多少代码？
 String formatted = String.format("姓名: %s", name);
 // 再手动write...

import java.io.*;
import java.util.zip.*;

public class GzipExample {
    
    // 压缩单个文件
    public static void compressFile(String sourceFile, String destFile) 
            throws IOException {
        try (FileInputStream fis = new FileInputStream(sourceFile);
             FileOutputStream fos = new FileOutputStream(destFile);
             GZIPOutputStream gzos = new GZIPOutputStream(fos)) {
            
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                gzos.write(buffer, 0, len);
            }
            System.out.printf("压缩完成：%s → %s (%.2f%%压缩率)%n",
                sourceFile, destFile, 
                (1 - new File(destFile).length() * 1.0 / new File(sourceFile).length()) * 100);
        }
    }
    
    // 解压缩文件
    public static void decompressFile(String sourceFile, String destFile) 
            throws IOException {
        try (GZIPInputStream gzis = new GZIPInputStream(
                new FileInputStream(sourceFile));
             FileOutputStream fos = new FileOutputStream(destFile)) {
            
            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzis.read(buffer)) != -1) {
                fos.write(buffer, 0, len);
            }
            System.out.printf("解压完成：%s → %s%n", sourceFile, destFile);
        }
    }
    
    // 压缩字符串（常用于网络传输）
    public static byte[] compressString(String data) throws IOException {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (GZIPOutputStream gzos = new GZIPOutputStream(baos)) {
            gzos.write(data.getBytes("UTF-8"));
        }
        return baos.toByteArray();
    }
    
    // 解压字符串
    public static String decompressString(byte[] compressedData) throws IOException {
        ByteArrayInputStream bais = new ByteArrayInputStream(compressedData);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try (GZIPInputStream gzis = new GZIPInputStream(bais)) {
            byte[] buffer = new byte[1024];
            int len;
            while ((len = gzis.read(buffer)) != -1) {
                baos.write(buffer, 0, len);
            }
        }
        return baos.toString("UTF-8");
    }
    
    public static void main(String[] args) throws IOException {
        // 示例：压缩文本文件
        String text = "这是一段需要压缩的文本数据，重复数据重复数据重复数据...";
        Files.write(Paths.get("original.txt"), text.getBytes("UTF-8"));
        
        // 压缩
        compressFile("original.txt", "compressed.gz");
        
        // 解压
        decompressFile("compressed.gz", "decompressed.txt");
        
        // 字符串压缩示例
        String original = "Hello ".repeat(1000); // 重复数据压缩率高
        byte[] compressed = compressString(original);
        String decompressed = decompressString(compressed);
        
        System.out.printf("原始大小：%d bytes%n", original.getBytes("UTF-8").length);
        System.out.printf("压缩后：%d bytes%n", compressed.length);
        System.out.printf("压缩率：%.1f%%%n", 
            (1 - compressed.length * 1.0 / original.getBytes("UTF-8").length) * 100);
    }
}

import java.io.*;
import java.nio.file.*;
import java.util.zip.*;
import java.util.*;

public class ZipExample {
    
    // 压缩单个文件到ZIP
    public static void zipSingleFile(String sourceFile, String zipFile) 
            throws IOException {
        try (ZipOutputStream zos = new ZipOutputStream(
                new FileOutputStream(zipFile))) {
            
            File fileToZip = new File(sourceFile);
            FileInputStream fis = new FileInputStream(fileToZip);
            
            // 创建ZIP条目（文件入口）
            ZipEntry zipEntry = new ZipEntry(fileToZip.getName());
            zos.putNextEntry(zipEntry);
            
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1) {
                zos.write(buffer, 0, len);
            }
            
            fis.close();
            zos.closeEntry();
        }
    }
    
    // 压缩整个目录（递归）
    public static void zipDirectory(String sourceDir, String zipFile) 
            throws IOException {
        try (ZipOutputStream zos = new ZipOutputStream(
                new FileOutputStream(zipFile))) {
            
            Path sourcePath = Paths.get(sourceDir);
            Files.walk(sourcePath)
                 .filter(path -> !Files.isDirectory(path))
                 .forEach(path -> {
                     try {
                         // 获取相对路径（保持目录结构）
                         String relativePath = sourcePath.relativize(path).toString();
                         
                         ZipEntry zipEntry = new ZipEntry(relativePath);
                         zos.putNextEntry(zipEntry);
                         
                         Files.copy(path, zos);
                         zos.closeEntry();
                         
                         System.out.println("已添加：" + relativePath);
                     } catch (IOException e) {
                         e.printStackTrace();
                     }
                 });
        }
    }
    
    // 压缩多个指定文件
    public static void zipMultipleFiles(List<String> files, String zipFile) 
            throws IOException {
        try (ZipOutputStream zos = new ZipOutputStream(
                new FileOutputStream(zipFile))) {
            
            for (String filePath : files) {
                File file = new File(filePath);
                FileInputStream fis = new FileInputStream(file);
                
                ZipEntry zipEntry = new ZipEntry(file.getName());
                zos.putNextEntry(zipEntry);
                
                byte[] buffer = new byte[1024];
                int len;
                while ((len = fis.read(buffer)) != -1) {
                    zos.write(buffer, 0, len);
                }
                
                fis.close();
                zos.closeEntry();
            }
        }
    }
    
    // 解压ZIP文件
    public static void unzipFile(String zipFile, String destDir) 
            throws IOException {
        File destDirectory = new File(destDir);
        if (!destDirectory.exists()) {
            destDirectory.mkdirs();
        }
        
        try (ZipInputStream zis = new ZipInputStream(
                new FileInputStream(zipFile))) {
            
            ZipEntry zipEntry;
            while ((zipEntry = zis.getNextEntry()) != null) {
                String fileName = zipEntry.getName();
                File newFile = new File(destDir + File.separator + fileName);
                
                // 创建必要的目录结构
                if (zipEntry.isDirectory()) {
                    newFile.mkdirs();
                    continue;
                } else {
                    newFile.getParentFile().mkdirs();
                }
                
                // 解压文件
                try (FileOutputStream fos = new FileOutputStream(newFile)) {
                    byte[] buffer = new byte[1024];
                    int len;
                    while ((len = zis.read(buffer)) != -1) {
                        fos.write(buffer, 0, len);
                    }
                }
                
                System.out.println("解压：" + fileName);
                zis.closeEntry();
            }
        }
    }
    
    // 查看ZIP文件内容（不解压）
    public static void listZipContents(String zipFile) throws IOException {
        try (ZipInputStream zis = new ZipInputStream(
                new FileInputStream(zipFile))) {
            
            System.out.println("ZIP文件内容：");
            System.out.println("====================");
            
            ZipEntry zipEntry;
            while ((zipEntry = zis.getNextEntry()) != null) {
                String info = String.format("%-40s %10d bytes %s",
                    zipEntry.getName(),
                    zipEntry.getSize(),
                    zipEntry.isDirectory() ? "[目录]" : "");
                System.out.println(info);
                
                // 跳过文件内容，只读取元数据
                byte[] buffer = new byte[1024];
                while (zis.read(buffer) != -1) {
                    // 只读取，不处理
                }
                zis.closeEntry();
            }
        }
    }
    
    // 压缩并设置密码（需要额外的库，如zip4j）
    public static void zipWithPassword(String sourceFile, String zipFile, String password) {
        // 注意：Java原生ZIP不支持密码，需要第三方库
        System.out.println("Java原生ZIP库不支持加密，需要使用zip4j等第三方库");
    }
    
    public static void main(String[] args) throws IOException {
        // 准备测试文件
        Files.write(Paths.get("doc1.txt"), 
                   "这是文档1的内容".getBytes("UTF-8"));
        Files.write(Paths.get("doc2.txt"), 
                   "这是文档2的内容".getBytes("UTF-8"));
        Files.write(Paths.get("data.csv"), 
                   "姓名,年龄,成绩\n张三,20,95\n李四,22,88".getBytes("UTF-8"));
        
        // 创建测试目录
        new File("testdir").mkdir();
        Files.write(Paths.get("testdir/image.png"), 
                   new byte[1024]); // 模拟图片文件
        
        // 示例1：压缩单个文件
        zipSingleFile("doc1.txt", "single.zip");
        
        // 示例2：压缩多个文件
        List<String> files = Arrays.asList("doc1.txt", "doc2.txt", "data.csv");
        zipMultipleFiles(files, "multiple.zip");
        
        // 示例3：压缩目录
        zipDirectory(".", "alldir.zip");
        
        // 示例4：查看ZIP内容
        listZipContents("multiple.zip");
        
        // 示例5：解压
        unzipFile("multiple.zip", "extracted");
        
        // 清理测试文件
        Files.deleteIfExists(Paths.get("doc1.txt"));
        Files.deleteIfExists(Paths.get("doc2.txt"));
        Files.deleteIfExists(Paths.get("data.csv"));
        Files.deleteIfExists(Paths.get("single.zip"));
        Files.deleteIfExists(Paths.get("multiple.zip"));
        Files.deleteIfExists(Paths.get("alldir.zip"));
        deleteDirectory(Paths.get("testdir"));
        deleteDirectory(Paths.get("extracted"));
    }
    
    private static void deleteDirectory(Path path) throws IOException {
        if (Files.exists(path)) {
            Files.walk(path)
                 .sorted(Comparator.reverseOrder())
                 .map(Path::toFile)
                 .forEach(File::delete);
        }
    }
}