I/O系列教材（五）- Java的字符流 Reader Writer

I/O系列教材（四）- 关闭流的方式

I/O系列教材（六）- Java 编码中文问题系统透彻讲解 UNICODE GBK UTF-8 ISO-8859-1 之间的区别

工具版本兼容问题

Reader字符输入流
Writer字符输出流
专门用于字符的形式读取和写入数据

纠

本视频是解读性视频，所以希望您已经看过了本知识点的内容，并且编写了相应的代码之后，带着疑问来观看，这样收获才多。不建议一开始就观看视频

2分14秒
本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

步骤 1 : 使用字符流读取文件
步骤 2 : 使用字符流把字符串写入到文件
步骤 3 : 练习-文件加密
步骤 4 : 答案-文件加密
步骤 5 : 练习-文件解密
步骤 6 : 答案-文件解密

步骤 1 :

使用字符流读取文件

edit 顶折

纠问

FileReader 是Reader子类，以FileReader 为例进行文件读取

代码行数较多，请点击查看

步骤 2 :

使用字符流把字符串写入到文件

edit 顶折

纠问

FileWriter 是Writer的子类，以FileWriter 为例把字符串写入到文件

代码行数较多，请点击查看

步骤 3 :

练习-文件加密

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

准备一个文本文件(非二进制)，其中包含ASCII码的字符和中文字符。
设计一个方法

public static void encodeFile(File encodingFile, File encodedFile);

在这个方法中把encodingFile的内容进行加密，然后保存到encodedFile文件中。
加密算法：
数字：
如果不是9的数字，在原来的基础上加1，比如5变成6, 3变成4
如果是9的数字，变成0
字母字符：
如果是非z字符，向右移动一个，比如d变成e, G变成H
如果是z，z->a, Z-A。
字符需要保留大小写
非字母字符
比如',&^ 保留不变，中文也保留不变
建议：使用以前学习的练习题中的某个Java文件，比如循环练习，就有很多的字符和数字

步骤 4 :

答案-文件加密

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费5个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

10分32秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

package stream;
 
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class TestStream {
    /**
     * 
     * @param encodingFile
     *            被加密的文件
     * @param encodedFile
     *            加密后保存的位置
     */
    public static void encodeFile(File encodingFile, File encodedFile) {
 
        try (FileReader fr = new FileReader(encodingFile); FileWriter fw = new FileWriter(encodedFile)) {
            // 读取源文件
            char[] fileContent = new char[(int) encodingFile.length()];
            fr.read(fileContent);
            System.out.println("加密前的内容：");
            System.out.println(new String(fileContent));
 
            // 进行加密
            encode(fileContent);
            // 把加密后的内容保存到目标文件
            System.out.println("加密后的内容：");
            System.out.println(new String(fileContent));
 
            fw.write(fileContent);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    private static void encode(char[] fileContent) {
        for (int i = 0; i < fileContent.length; i++) {
            char c = fileContent[i];
            if (isLetterOrDigit(c)) {
                switch (c) {
                case '9':
                    c = '0';
                    break;
                case 'z':
                    c = 'a';
                    break;
                case 'Z':
                    c = 'A';
                    break;
                default:
                    c++;
                    break;
                }
            }
            fileContent[i] = c;
        }
    }
 
    public static boolean isLetterOrDigit(char c) {
        // 不使用Character类的isLetterOrDigit方法是因为，中文也会被判断为字母
        String letterOrDigital = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        return -1 == letterOrDigital.indexOf(c) ? false : true;
    }
 
    public static void main(String[] args) {
        File encodingFile = new File("E:/project/j2se/src/Test1.txt");
        File encodedFile = new File("E:/project/j2se/src/Test2.txt");
        encodeFile(encodingFile, encodedFile);
    }
}

步骤 5 :

练习-文件解密

edit 顶折

纠问

姿势不对,事倍功半! 点击查看做练习的正确姿势

解密在文件加密中生成的文件。
设计一个方法

public static void decodeFile(File decodingFile, File decodedFile);

在这个方法中把decodingFile的内容进行解密，然后保存到decodedFile文件中。
解密算法：
数字：
如果不是0的数字，在原来的基础上减1，比如6变成5, 4变成3
如果是0的数字，变成9
字母字符：
如果是非a字符，向左移动一个，比如e变成d, H变成G
如果是a，a->z, A-Z。
字符需要保留大小写
非字母字符：
比如',&^ 保留不变，中文也保留不变

步骤 6 :

答案-文件解密

edit 顶折

纠问

在查看答案前，尽量先自己完成，碰到问题再来查看答案，收获会更多

查看本答案会花费5个积分，您目前总共有点积分。查看相同答案不会花费额外积分。积分增加办法或者一次性购买JAVA 中级总计0个答案 (总共需要0积分)

账号未激活账号未激活，功能受限。请点击激活

本视频是解读性视频，所以希望您已经看过了本答案的内容，带着疑问来观看，这样收获才多。不建议一开始就观看视频

2分7秒本视频采用html5方式播放，如无法正常播放，请将浏览器升级至最新版本，推荐火狐，chrome，360浏览器。如果装有迅雷，播放视频呈现直接下载状态，请调整迅雷系统设置-基本设置-启动-监视全部浏览器 (去掉这个选项)。 chrome 的视频下载插件会影响播放，如 IDM 等，请关闭或者切换其他浏览器

1.0 原速 1.25 倍速 1.5 倍速 1.75 倍速

代码行数较多，请点击查看

package stream;
 
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class TestStream {
 
    /**
     * 
     * @param decodingFile
     *            被解密的文件
     * @param decodedFile
     *            解密后保存的位置
     */
    public static void decodeFile(File decodingFile, File decodedFile) {
 
        try (FileReader fr = new FileReader(decodingFile); FileWriter fw = new FileWriter(decodedFile)) {
            // 读取源文件
            char[] fileContent = new char[(int) decodingFile.length()];
            fr.read(fileContent);
            System.out.println("源文件的内容:");
            System.out.println(new String(fileContent));
            // 进行解密
            decode(fileContent);
            System.out.println("解密后的内容:");
            System.out.println(new String(fileContent));
            // 把解密后的内容保存到目标文件
            fw.write(fileContent);
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
 
    private static void decode(char[] fileContent) {
        for (int i = 0; i < fileContent.length; i++) {
            char c = fileContent[i];
            if (isLetterOrDigit(c)) {
                switch (c) {
                case '0':
                    c = '9';
                    break;
                case 'a':
                    c = 'z';
                    break;
                case 'A':
                    c = 'Z';
                    break;
                default:
                    c--;
                    break;
                }
            }
            fileContent[i] = c;
        }
    }
 
    public static boolean isLetterOrDigit(char c) {
        // 不使用Character类的isLetterOrDigit方法是因为，中文也会被判断为字母
        String letterOrDigital ="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        return -1 == letterOrDigital.indexOf(c) ? false : true;
    }
 
    public static void main(String[] args) {
        File decodingFile = new File("E:/project/j2se/src/Test2.txt");
        File decodedFile = new File("E:/project/j2se/src/Test1.txt");
 
        decodeFile(decodingFile, decodedFile);
 
    }
}

I/O系列教材（四）- 关闭流的方式

I/O系列教材（六）- Java 编码中文问题系统透彻讲解 UNICODE GBK UTF-8 ISO-8859-1 之间的区别

HOW2J公众号，关注后实时获知最新的教程和优惠活动，谢谢。

问答区域

2024-07-06 一种通俗、简单的文件类，提供多种文件操作方法

虚心求学

关于 JAVA 中级-I/O-字符流的提问

包含以下功能： 1.纯英文文件的读取、加密、解密，； 2.同时包含中文、英文文件的读取、加密、解密； 3.将任意文件拆分为若干子文件； 4.将若干子文件合并为同一个文件； 5.比较两个文件的内容、大小是否完全一致； 6.查找路径下的所有文件（包括子文件夹及子文件），并返回文件信息，找到内存最大和最小的两个文件； 7.写入指定长度的随机字符串到文件中；

package myFileTest;
 
import java.awt.Frame;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.nio.CharBuffer;
import java.nio.channels.NonWritableChannelException;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.nio.charset.spi.CharsetProvider;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.logging.FileHandler;
 
import javax.annotation.processing.Filer;
import javax.swing.text.html.HTMLDocument.HTMLReader.IsindexAction;
 
import Animal.Fish;
import j2se.HelloWorld;
 
public class TestFile {
    private static String englishSentence = "I love China,English sentence:abcdefgHIJKLMNOPQRSTuvwxyz0123456789中";
    private static String ChineseSentence = "带中文的句子：abcdefgHIJKLMNOPQRSTuvwxyz0123456789我爱中国";
     
    public static void main(String[] args) {
        //创建一个新的文件夹，用以存放测试结果
        File folder = new File("D:/testFolder");
        folder.mkdirs();
        //创建一个只包含英文内容的文本文件
        File engFile = createAndWriteNewFile("D:/testFolder/originDataEnglish.txt"
                ,englishSentence);
        //创建一个同时包含中文和英文内容的文本文件
        File chiFile = createAndWriteNewFile("D:/testFolder/originDataChinese.txt"
                ,ChineseSentence);
 
        //只加密解密英文字符
        File file1 = new File(engFile.getAbsolutePath());
        File encodeFile = encodingFile(file1,false);    //加密源文件
        decodingFile(encodeFile,false);                 //解密源文件
         
        //加密和解密中文和英文字符
        File file2 = new File(chiFile.getAbsolutePath());
        File encodeFile2 = encodingFile(file2,true);    //加密源文件
        decodingFile(encodeFile2,true);                 //解密源文件
         
    }
    /*
     * 在指定路径创建一个新的文件并写入指定内容
     * */
    private static File createAndWriteNewFile(String path,String writeInfo)
    {
        try {
            File file = new File(path);
            try(OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(file),StandardCharsets.UTF_8)) {
                char[]info = new char[writeInfo.length()];
                writeInfo.getChars(0, writeInfo.length(), info, 0);
                writer.write(info);
                return file;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
         
    }
/*
 * 1.对指定的原文件（encodingFile）进行加密，
 * isChineseEncode 为false表示不加密中文。
 * 2.加密成功，在原文件相同的路径下，
 * 生成新的文件encodingFile
 * 并返回加密后的文件
 * */
    public static File encodingFile(File originFile,boolean isChineseEncode) {
        File pFile = originFile.getParentFile();
        String[] fileInfo = originFile.getName().split("\\.");
        String fileName = fileInfo[0];  //文件名
        String filter = fileInfo[1];    //文件后缀
        String path = String.format("%s/%s-加密.%s",pFile.getAbsoluteFile(),fileName,filter);
        File encodingFile = new File(path);     //创建加密的文件
        char[] cs = new char[(int) originFile.length()];
        //使用UTF-8编码形式读取并加密文件
        try (InputStreamReader isr = new InputStreamReader(new FileInputStream(originFile),
                Charset.forName("UTF-8"))) {
            isr.read(cs);
            encoding(cs,isChineseEncode);//加密文件
        } catch (Exception e) {
 
        }
        //使用UTF-8编码形式写入内容到文件中
        try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(encodingFile),Charset.forName("UTF-8"))) {
            writer.write(cs);
            System.out.println("加密成功，文件路径为：" + encodingFile.getAbsolutePath());
        } catch (Exception e) {
            e.printStackTrace();
        }
 
        return encodingFile;
 
    }
    /*
     * 1.对指定的字符数组（char[] cs）进行加密，
     * isEncodeChinese 为false表示不加密中文。
     * 2.规则，字母数字ASCII自增一，例外情况：z、Z=>a、A；9=>0
     * */
    public static void encoding(char[] cs,boolean isEncodeChinese) {
        for (int i = 0; i < cs.length; i++) {
            char c = cs[i];
            if(!isEncodeChinese&&(c<'0'||c>'9'&&c<'A'||c>'z'))continue;
            if (Character.isDigit(c)) {
                if (c != '9')
                    cs[i] = (char) (c + 1);
                else
                    cs[i] = '0';
            } else if (Character.isLetter(c)) {
                if (Character.toLowerCase(c) == 'z') {
                    if (Character.isLowerCase(c))
                        cs[i] = 'a';
                    else
                        cs[i] = 'A';
                } else {
                    cs[i] = (char) (cs[i] + 1);
                }
            }
        }
    }
    /*
     * 1.对指定的加密后的文件（decodingFile）进行解密，
     * isDecodeChinese 为false表示不加密中文。
     * 2.加密成功，在原文件相同的路径下，
     * 生成新的文件decodingFile
     * 并返回加密后的文件
     * */
    public static File decodingFile(File encodingFile,boolean isDecodeChinese) {
        File pFile = encodingFile.getParentFile();
        String[] fileInfo = encodingFile.getName().split("\\.");
        String fileName = fileInfo[0];  //文件名
        String filter = fileInfo[1];    //文件后缀
        String path = String.format("%s/%s-解密.%s",pFile.getAbsoluteFile(),fileName,filter);
        File decodingFile = new File(path);     //创建解密的文件
        //使用UTF-8编码形式读取并解密文件
        try (InputStreamReader fr = new InputStreamReader(new FileInputStream(encodingFile),StandardCharsets.UTF_8)) {
            char[] cs = new char[(int) encodingFile.length()];
            fr.read(cs);
            decoding(cs,isDecodeChinese);
            //使用UTF-8编码写入内容到文件
            try (OutputStreamWriter fWriter = new OutputStreamWriter(new FileOutputStream(decodingFile),StandardCharsets.UTF_8)) {
                fWriter.write(cs);
                System.out.println("解密成功，文件路径为：" + decodingFile.getAbsolutePath());
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
            // TODO: handle exception
        }
 
        return decodingFile;
    }
    /*
     * 1.对指定的字符数组（char[] cs）进行解密，
     * isEncodeChinese 为false表示不解密中文。
     * 2.规则，字母数字ASCII自减一，例外情况：a、A=>z、Z；9=>0
     * */
    public static void decoding(char[] cs,boolean isDecodeChinese) {
        for (int i = 0; i < cs.length; i++) {
            char c = cs[i];
            if(!isDecodeChinese&&(c<'0'||c>'9'&&c<'A'||c>'z'))continue;
            if (Character.isDigit(c)) {
                if (c != '0')
                    cs[i] = (char) (c - 1);
                else
                    cs[i] = '9';
            } else if (Character.isLetter(c)) {
                if (Character.toLowerCase(c) == 'a') {
                    if (Character.isLowerCase(c))
                        cs[i] = 'z';
                    else
                        cs[i] = 'Z';
                } else {
                    cs[i] = (char) (cs[i] - 1);
                }
            }
        }
    }
 
    public static void testSplitorComcbineFile(String[] args) throws IOException {
        File fold = new File("E:/testFolder/"); // 测试路径
        File f = new File(fold, "/testFile1.txt"); // 测试文件
        fold.mkdirs(); // 如果测试路径不存在，则新建一个
        int writeLength = 300 * 1000;
        int splLegnth = 100 * 1000;
        WriteRandStrInFile(f, writeLength);
        File parentFile = SplitFile(f, splLegnth); // 将写入内容完毕的文件，拆分成若干个子文件
        File combineFile = CombineFile(parentFile); // 将拆分完毕的子文件，合并为一个文件
        if (FileEquals(f, combineFile)) // 检查拆分、合并后的结果与原始文件是否相等
        {
            System.out.println("结果检查通过！原始文件经过拆分并合并后的结果，与原始文件完全一致；成功无损地完成文件拆分、合并过程。");
        } else
            System.out.println("结果检查失败！原始文件进行文件拆分、合并过程失败或过程有损失。");
    }
 
    // 写入指定长度的随机字符串到文件中
    public static void WriteRandStrInFile(File f, int strLength) {
        try (FileOutputStream fos = new FileOutputStream(f);) {
            byte[] bs = getRandomStr(strLength).getBytes(); // 生成指定长度的字符串并转为数组
            fos.write(bs); // 写入内容
        } catch (IOException e) {
            e.printStackTrace();
            // TODO: handle exception
        }
    }
 
    // 指定拆分长度，将file拆分为若干子文件（file-1、file-2...）,拆分成功返回拆分文件存放的文件夹parentFile文件，失败返回null。
    public static File SplitFile(File file, int splitLength) throws IOException {
        if (file == null)
            return null;
        if (!file.exists())
            return null;
        int num = (int) Math.ceil((double) file.length() / splitLength);
        File parentFile = new File(String.format("%s/newSplitFolder", file.getParent()));
        FileInputStream fis = new FileInputStream(file);
        byte[] bs = new byte[(int) file.length()];
        try {
            fis.read(bs);
        } catch (Exception e) {
        } finally {
            fis.close();
        }
        for (int i = 0; i < num; i++) {
            byte[] tempArr;
            if (i < num - 1) {
                tempArr = Arrays.copyOfRange(bs, i * splitLength, i * splitLength + splitLength);
            } else // 拆分到最后一个文件
                tempArr = Arrays.copyOfRange(bs, i * splitLength,
                        i * splitLength + (int) file.length() - ((i - 1) * splitLength + splitLength));
            parentFile.mkdirs();
            File f = new File(parentFile, String.format("/%s-%d.txt", (file.getName().split("\\."))[0], i + 1));// split匹配正则表达式，'.'表示任意字符，需要转义
            FileOutputStream fos = new FileOutputStream(f);
            try {
                fos.write(tempArr);
            } catch (Exception e) {
                // TODO: handle exception
            } finally {
                fos.close();
            }
            System.out.println(String.format("拆分成功！第%d个子文件为：%s，大小为  %s %s字节", i + 1, f.getAbsoluteFile(),
                    String.valueOf(f.length() >= 1000 ? (double) f.length() / 1000 : f.length()),
                    f.length() >= 1000 ? "千" : ""));
        }
        return parentFile;
    }
 
    // 根据提供的文件夹，获取该文件夹下的所有子文件，将所有子文件合并为一个新的文件并返回，失败返回null;返回的合并结果路径位于提供的文件夹内。
    public static File CombineFile(File parentFileFolder) throws IOException {
        if (parentFileFolder == null)
            return null;
        File[] fs = parentFileFolder.listFiles();
        if (fs == null)
            return null;
        if (fs.length < 1)
            return null;
        int total = 0;
        for (File f : fs) {
            total += f.length();
        }
        byte[] bs = new byte[total];
        int index = 0;
        for (File f : fs) {
            if (f == null)
                continue;
            if (!f.exists())
                continue;
            byte[] datas = new byte[(int) f.length()];
            try (FileInputStream fis = new FileInputStream(f)) {
                fis.read(datas);
            } catch (IOException e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            System.arraycopy(datas, 0, bs, index, (int) f.length());
            index += f.length();
        }
        File resFile = new File(
                String.format("%s/%s.%s", fs[0].getParent(), "combineFile", fs[0].getName().split("\\.")[1]));
        try (FileOutputStream fos = new FileOutputStream(resFile)) {
            fos.write(bs);
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        System.out.println(String.format("%n子文件合并成功！合并结果文件：path:%s%nspace:%s %s字节", resFile.getAbsoluteFile(),
                String.valueOf(resFile.length() >= 1000 ? (double) resFile.length() / 1000 : resFile.length()),
                resFile.length() >= 1000 ? "千" : ""));
        return resFile;
    }
 
    // 判断两个文件的内容、大小是否完全一致
    public static boolean FileEquals(File f1, File f2) throws IOException {
        if (f1 == null || f2 == null)
            return false;
        if (!f1.exists() || !f2.exists())
            return false;
        if (f1.length() != f2.length())
            return false;
        FileInputStream fis = new FileInputStream(f1);
        byte[] bs1 = new byte[(int) f1.length()];
        byte[] bs2 = new byte[(int) f2.length()];
        fis.read(bs1);
        fis.close();
        fis = new FileInputStream(f2);
        fis.read(bs2);
        fis.close();
        return Arrays.equals(bs1, bs2);
    }
 
    /// 生成指定长度的随机字符串
    public static String getRandomStr(int length) {
        char[] cs = new char[length];
        for (int i = 0; i < cs.length; i++) {
            int rcase = (int) (Math.random() * 10);// 用于随机判断大小写
            if (rcase >= 5)// 各占一半的概率
            {
 
                cs[i] = (char) ('A' + Math.random() * 25);// Z与A相差25
            } else {
                cs[i] = (char) ('a' + Math.random() * 25);// Z与a相差25
            }
 
        }
        return new String(cs);
    }
 
    static int i = 1;
    static long min = Long.MAX_VALUE;
    static long max = Long.MIN_VALUE;
    static File maxFile = null;
    static File minFile = null;
 
    public static String getFiles(File file) {
        if (file == null)
            return "文件不存在";
        if (!file.exists())
            return "文件不存在";
        System.out.print(i + "." + file.getParent());
        File[] fs = file.listFiles();
        if (fs == null)
            return "子文件不存在";
        if (fs.length < 1)
            return "子文件不存在";
 
        for (File f : fs) {
            if (f == null)
                continue;
            // getFiles(f);
            if (f.length() > max) {
                max = (f.length());
                maxFile = f;
            }
            if (f.length() < min && f.length() > 0) {
                min = f.length();
                minFile = f;
            }
            System.out.println(i++ + "." + f.getName() + "\r\n");
        }
        if (minFile == null || maxFile == null)
            return "无找到最大最小文件";
        return String.format("最大的文件是%s，其大小是 %.2f mb%n", maxFile.getAbsoluteFile(), (double) max / (1024 * 1024))
                + String.format("最小的文件是%s，其大小是 %s 字节", minFile.getAbsoluteFile(), String.valueOf(min));
    }
 
    public static String test2() throws IOException {
        File basef = new File("E:/newFolder/garenSkin");
        File f = new File("E:/newFolder/garenSkin/garenLegendSkin.ski");
        if (!basef.exists())
            return "文件不存在";
        String[] allFile = basef.list();
        File[] files = basef.listFiles();
        String outFolder = f.getParent();
        File outFolderFile = f.getParentFile();
        basef.mkdir();
        basef.mkdirs();
        basef.createNewFile();
        File[] roots = basef.listRoots();
        f.getParentFile().mkdirs();
        f.delete();
        f.deleteOnExit();
        return String.format("allFile is :%s%nparent is :%s%nroots is :%s%n", arr2str(allFile), outFolder,
                arr2str(roots));
    }
 
    private static String arr2str(String[] strs) {
        StringBuffer sb = new StringBuffer();
        int i = 1;
        sb.append("\r\n");
        for (String str : strs) {
            sb.append(i++ + ". " + str + "\r\n");
        }
        return sb.toString();
    }
 
    private static String arr2str(File[] fs) {
        StringBuffer sb = new StringBuffer();
        int i = 1;
        sb.append("\r\n");
        for (File f : fs) {
            sb.append(i++ + ". " + f.getName() + "\r\n");
        }
        return sb.toString();
    }
 
    public static void test1() {
        File f1 = new File("E:/newFolder");
        File f2 = new File("LOL.exe");
        File f3 = new File(f1, "LOL.exe");
 
        System.out.println(getInfoFromFile(f1));
        System.out.println(getInfoFromFile(f2));
        System.out.println(getInfoFromFile(f3));
 
        f3.renameTo(new File("E:/newFolder/DOTA.exe"));
        System.out.println("尝试把 LOL.exe 修改为 DOTA.exe");
        System.out.println(getInfoFromFile(f3));
        File f4 = new File("E:/newFolder/DOTA.exe");
        f4.renameTo(new File("E:/newFolder/LOL.exe"));// 恢复名字
        System.out.println(getInfoFromFile(f3));
    }
 
    public static String getInfoFromFile(File f) {
        // System.out.println(f.getAbsolutePath());
        if (!f.exists())
            return "文件不存在";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
 
        String path = f.getAbsolutePath();
        String isFile = String.valueOf(f.isFile()); // 是否为文件
        String isFolder = String.valueOf(f.isDirectory()); // 是否为文件夹
        String name = f.getName(); // 文件名
        float size = f.getUsableSpace(); // 文件占用内存大小（kb）
        String modifiedT = sdf.format(new Date(f.lastModified()));
 
        return String.format("%n文件信息如下：%npath：%s%nisFile：%s%n" + "isFolder：%s%nname：%s%n" + "size：%.2f%n"
                + "lastModified Time is %S", path, isFile, isFolder, name, size, modifiedT);
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2023-12-30 加密与解密代码

javanoobbbb

关于 JAVA 中级-I/O-字符流的提问

f1是目标文件 f2为加密成功文件 f3为f2解密成功的文件，最后f1与f2内容一致

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
 
public class Encoding {
    public static void main(String[] args) {
        File f1=new File("C:\\Users\\ASUS\\Desktop\\LOL.asm");
        File f2=new File("C:\\Users\\ASUS\\Desktop\\encodedLOL.asm");
        File f3=new File("C:\\Users\\ASUS\\Desktop\\unEncodedLOL.asm");
        EncodeFile(f1,f2);//文件加密
        UnEncodeFile(f2,f3);//文件解密
 
    }
    static public void UnEncodeFile(File f1, File f2)
    {
        if (f1.isFile())
        {
            System.out.println("文件解密开始");
            try(FileReader reader=new FileReader(f1))
            {
                char []mycontent=new char[(int)f1.length()];
                char []myCoded=new char[mycontent.length];
                reader.read(mycontent);
                for (int i = 0; i < mycontent.length; i++) {
                    if (Character.isLetter(mycontent[i]))
                    {
                        if (Character.isUpperCase(mycontent[i]))
                        {
                            if (mycontent[i]=='A') myCoded[i]='Z';
                            else myCoded[i]=(char)(mycontent[i]-1);
                        }
                        else {
                            if (mycontent[i]=='a') myCoded[i]='z';
                            else myCoded[i]=(char)(mycontent[i]-1);
                        }
                    } else if (Character.isDigit(mycontent[i])) {
                        switch (mycontent[i])
                        {
                            case '0':myCoded[i]='9'; break;
                            default:myCoded[i]=(char)(mycontent[i]-1);
                        }
 
                    }
                    else
                    {
                        mycontent[i]=mycontent[i];
                    }
                }
                try (FileWriter writer=new FileWriter(f2)){
                    writer.write(myCoded);
 
                }
 
            }
            catch (IOException e)
            {
                e=new IOException("文件解密失败");
                e.printStackTrace();
            }
            System.out.println("文件解密成功");
        }
    }
 
    static public void EncodeFile(File f1, File f2)
    {
        if (f1.isFile())
        {
            System.out.println("文件加密开始");
            try(FileReader reader=new FileReader(f1))
            {
                char []mycontent=new char[(int)f1.length()];
                char []myCoded=new char[mycontent.length];
                reader.read(mycontent);
                for (int i = 0; i < mycontent.length; i++) {
                    if (Character.isLetter(mycontent[i]))
                    {
                        if (Character.isUpperCase(mycontent[i]))
                        {
                            if (mycontent[i]=='Z') myCoded[i]='A';
                            else myCoded[i]=(char)(mycontent[i]+1);
                        }
                        else {
                            if (mycontent[i]=='z') myCoded[i]='a';
                            else myCoded[i]=(char)(mycontent[i]+1);
                        }
                    } else if (Character.isDigit(mycontent[i])) {
                        switch (mycontent[i])
                        {
                            case '9':myCoded[i]='0'; break;
                            default:myCoded[i]=(char)(mycontent[i]+1);
                        }
 
                    }
                    else
                    {
                        mycontent[i]=mycontent[i];
                    }
                }
                try (FileWriter writer=new FileWriter(f2)){
                    writer.write(myCoded);
 
                }
 
            }
            catch (IOException e)
            {
                e=new IOException("文件加密失败");
                e.printStackTrace();
            }
        }
        System.out.println("文件加密成功");
    }
}

4 个答案

木宇
答案时间：2024-05-14

解密

代码超过 5行，点击查看

public class StreamTest2 {
    public static void main(String[] args) {
        //加密前的文档：
        File miQian = new File("D:\\javaFile\\333.txt");
        //加密后的文档
        File miHou = new File("D:\\javaFile\\222.txt");
        jeMiFile(miQian,miHou);
    }
 
 
    public static void jeMiFile(File jeMiFileQian, File jeMiFileHou){
        //思路：将特殊的字母数字用选择法，其他的用数组表示出来，然后将文本对其一一照样那个进行加密
        try(FileReader fr = new FileReader(jeMiFileQian); FileWriter fw = new FileWriter(jeMiFileHou)) {
            //读取源文件
            char[] f = new char[(int) jeMiFileQian.length()];
            fr.read(f);
            System.out.println("解密前的内容：");
            System.out.println(new String(f));
            //加密
            jeMi(f);
            System.out.println("解密后的内容：");
            System.out.println(new String(f));
            //把数组写进文档
            fw.write(f);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void jeMi(char[] shuZu){
        for (int i = 0; i < shuZu.length; i++) {
            //这时的shuZu未加密
            char c = shuZu[i];
            //bool是false 就不执行if语句，如果是ture则执行if语句
            if(bool1(c)){
                switch (c){
                    case '0':
                        c = '9';
                        break;
                    case 'a':
                        c = 'z';
                        break;
                    case 'A':
                        c = 'Z';
                        break;
                    //都不是就c--
                    default:
                        c--;
                        break;
                }
            }
            //这时的shuZu已加密
            shuZu[i] = c;
        }
    }
 
    public static boolean bool1(char c){
        String tiaoJian = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        return tiaoJian.indexOf(c) == -1 ? false:true;
    }
}

木宇
答案时间：2024-05-14

加密

代码超过 5行，点击查看

public class StreamTest1 {
    //练习-文件加密
    /*在这个方法中把encodingFile的内容进行加密，然后保存到encodedFile文件中。
    加密算法：
    数字：
    如果不是9的数字，在原来的基础上加1，比如5变成6, 3变成4
    如果是9的数字，变成0
    字母字符：
    如果是非z字符，向右移动一个，比如d变成e, G变成H
    如果是z，z->a, Z-A。
    字符需要保留大小写
            非字母字符
    比如',&^ 保留不变，中文也保留不变*/
    public static void main(String[] args) {
        //加密前的文档：
        File miQian = new File("D:\\javaFile\\222.txt");
        //加密后的文档
        File miHou = new File("D:\\javaFile\\333.txt");
        jiaMiFile(miQian,miHou);
    }
    public static void jiaMiFile(File jiaMiFileQian, File jiaMiFileHou){
        //思路：将特殊的字母数字用选择法，其他的用数组表示出来，然后将文本对其一一照样那个进行加密
        try(FileReader fr = new FileReader(jiaMiFileQian); FileWriter fw = new FileWriter(jiaMiFileHou)) {
            //读取源文件
            char[] f = new char[(int) jiaMiFileQian.length()];
            fr.read(f);
            System.out.println("加密前的内容：");
            System.out.println(new String(f));
            //加密
            jiaMi(f);
            System.out.println("加密后的内容：");
            System.out.println(new String(f));
            //把数组写进文档
            fw.write(f);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void jiaMi(char[] shuZu){
        for (int i = 0; i < shuZu.length; i++) {
            //这时的shuZu未加密
            char c = shuZu[i];
            //bool是false 就不执行if语句，如果是ture则执行if语句
            if(bool(c)){
                switch (c){
                    case '9':
                        c = '0';
                        break;
                    case 'z':
                        c = 'a';
                        break;
                    case 'Z':
                        c = 'A';
                        break;
                   //都不是就c++
                    default:
                        c++;
                        break;
                }
            }
            //这时的shuZu已加密
          shuZu[i] = c;
        }
    }
    public static boolean bool(char c){
        String tiaoJian = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        return tiaoJian.indexOf(c) == -1 ? false:true;
    }
 
}

木宇
答案时间：2024-05-14

加密

代码超过 5行，点击查看

public class StreamTest1 {
    //练习-文件加密
    /*在这个方法中把encodingFile的内容进行加密，然后保存到encodedFile文件中。
    加密算法：
    数字：
    如果不是9的数字，在原来的基础上加1，比如5变成6, 3变成4
    如果是9的数字，变成0
    字母字符：
    如果是非z字符，向右移动一个，比如d变成e, G变成H
    如果是z，z->a, Z-A。
    字符需要保留大小写
            非字母字符
    比如',&^ 保留不变，中文也保留不变*/
    public static void main(String[] args) {
        //加密前的文档：
        File miQian = new File("D:\\javaFile\\222.txt");
        //加密后的文档
        File miHou = new File("D:\\javaFile\\333.txt");
        jiaMiFile(miQian,miHou);
    }
    public static void jiaMiFile(File jiaMiFileQian, File jiaMiFileHou){
        //思路：将特殊的字母数字用选择法，其他的用数组表示出来，然后将文本对其一一照样那个进行加密
        try(FileReader fr = new FileReader(jiaMiFileQian); FileWriter fw = new FileWriter(jiaMiFileHou)) {
            //读取源文件
            char[] f = new char[(int) jiaMiFileQian.length()];
            fr.read(f);
            System.out.println("加密前的内容：");
            System.out.println(new String(f));
            //加密
            jiaMi(f);
            System.out.println("加密后的内容：");
            System.out.println(new String(f));
            //把数组写进文档
            fw.write(f);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
 
    public static void jiaMi(char[] shuZu){
        for (int i = 0; i < shuZu.length; i++) {
            //这时的shuZu未加密
            char c = shuZu[i];
            //bool是false 就不执行if语句，如果是ture则执行if语句
            if(bool(c)){
                switch (c){
                    case '9':
                        c = '0';
                        break;
                    case 'z':
                        c = 'a';
                        break;
                    case 'Z':
                        c = 'A';
                        break;
                   //都不是就c++
                    default:
                        c++;
                        break;
                }
            }
            //这时的shuZu已加密
          shuZu[i] = c;
        }
    }
    public static boolean bool(char c){
        String tiaoJian = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        return tiaoJian.indexOf(c) == -1 ? false:true;
    }
 
}

梁啊u
答案时间：2024-03-12

代码超过 5行，点击查看

package IOFile;
 
import java.io.*;
 
public class EncodeFile {
    //加密算法：
    //数字：
    //如果不是9的数字，在原来的基础上加1，比如5变成6, 3变成4
    //如果是9的数字，变成0
    //字母字符：
    //如果是非z字符，向右移动一个，比如d变成e, G变成H
    //如果是z，z->a, Z-A。
    //字符需要保留大小写
    //非字母字符
    //比如',&^ 保留不变，中文也保留不变
    public static void encodeFile(File encodingFile, File encodedFile){
        try(FileReader fileReader = new FileReader(encodingFile)){
            char[] encoding = new char[(int)encodingFile.length()];
//            char[] encoded = new char[encoding.length];
            fileReader.read(encoding);
            for (int i=0;i<encoding.length;i++){
                if(Character.isDigit(encoding[i])){
                    if(encoding[i] == '9') encoding[i] = '0';
                    encoding[i] = (char) (encoding[i]+1);
                }
                if (Character.isLetter(encoding[i])){
                    if (encoding[i] == 'z'){
                        encoding[i] = 'a';
                    }else if (encoding[i] == 'Z'){
                        encoding[i] = 'A';
                    }else encoding[i] = (char) (encoding[i]+1);
                }
            }
            try(FileWriter fileWriter = new FileWriter(encodedFile)){
                fileWriter.write(encoding);
            }catch (IOException e){
                e.printStackTrace();
            }
        }catch (IOException ioException){
            ioException.printStackTrace();
        }
    }
    public static void read(File f){
        try(FileReader fis = new FileReader(f)){
            char[] b = new char[(int)f.length()];
            fis.read(b);
            for (char c:b
            ) {
                System.out.print(c);
            }
            System.out.println();
        }catch (IOException exception){
            exception.printStackTrace();
        }
    }
    public static void main(String[] args) {
        File f = new File("D:\\test/abc.txt");
        System.out.println("加密前：");
        read(f);
        encodeFile(f,f);
        System.out.println("加密后：");
        read(f);
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2023-08-19 中文字符的一个坑

旧时亭台阁

关于 JAVA 中级-I/O-字符流的提问

通过 Character.isXXX 接口，中文字符，有些会返回 true 的。还是用 ascii 表去判断字符类型吧。

import java.io.*;
import java.util.function.Function;
 
public class App {
    public static void main(String[] args) throws Exception {
 
        encodeFile(new File("原始文件.txt"), new File("加密后的文件.txt"));
        decodeFile(new File("加密后的文件.txt"), new File("解密后的文件.txt"));
    }
 
    public static void encodeFile(File encodingFile, File encodedFile) throws Exception {
        coreImpl(encodingFile, encodedFile, strategy(1));
    }
 
    public static void decodeFile(File decodingFile, File decodedFile) throws Exception {
        coreImpl(decodingFile, decodedFile, strategy(-1));
    }
 
    public static void coreImpl(File inputFile, File outputFile, Function<Character, Character> transformer) throws Exception {
        FileReader reader = new FileReader(inputFile);
        FileWriter writer = new FileWriter(outputFile);
        char[] buf = new char[1024];
        int len;
        while (-1 != (len = reader.read(buf))) {
            for (int i = 0; i < len; i++) {
                buf[i] = transformer.apply(buf[i]);
            }
            writer.write(buf, 0, len);
        }
        writer.close();
        reader.close();
    }
 
    public static Function<Character, Character> strategy(final int move) {
        return ch -> {
            int base = -1, amount = -1;
            if (ch >= 'A' && ch <= 'Z') {
                base = 'A';
                amount = 26;
            } else if (ch >= 'a' && ch <= 'z') {
                base = 'a';
                amount = 26;
            } else if (ch >= '0' && ch <= '9') {
                base = '0';
                amount = 10;
            }
 
            if (-1 == amount) {
                return ch;
            }
            int off = ch - base;
            off = (off + move + amount) % amount;
            return (char) (off + base);
        };
    }
}

1 个答案

花开花落678
答案时间：2023-09-09

代码超过 5行，点击查看

public static void decodeFile(File decodingFile,File decodedFile){
        try( BufferedReader reader = new BufferedReader(new FileReader(decodingFile));
             BufferedWriter writer = new BufferedWriter(new FileWriter(decodedFile))) {
            int charCode;
            while((charCode = reader.read()) != -1){
                char decodedChar = (char)charCode;
                if (Character.isDigit(decodedChar)){
                    if (decodedChar == '0'){
                        //数字0变成9
                        decodedChar = '9';
                    }else{
                        //非0数字减1
                        decodedChar--;
                    }
                } else if (Character.isLetter(decodedChar)) {
                    if (decodedChar != 'a' && decodedChar != 'A'){
                        //非a字符向左移动一个
                        decodedChar--;
                    }else{
                        //a字符变成z 或 A变成Z
                        if(decodedChar == 'a'){
                            decodedChar = 'z';
                        }else {
                            decodedChar = 'Z';
                        }
                    }
                }
                //将字符写入目标文件中
                writer.write(decodedChar);
            }
        }catch (IOException e){
            e.printStackTrace();
        }
    }
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2023-08-02 加密解密问题

飞机徐徐

关于 JAVA 中级-I/O-字符流的提问

解密则是反过来然后减一

package how2jday06;
import java.io.*;
 class practice {
    /*准备一个文本文件(非二进制)，其中包含ASCII码的字符和中文字符。
设计一个方法
 
public static void encodeFile(File encodingFile, File encodedFile);
 
 
在这个方法中把encodingFile的内容进行加密，然后保存到encodedFile文件中。
加密算法：
数字：
如果不是9的数字，在原来的基础上加1，比如5变成6, 3变成4
如果是9的数字，变成0
字母字符：
如果是非z字符，向右移动一个，比如d变成e, G变成H
如果是z，z->a, Z-A。
字符需要保留大小写
非字母字符
比如',&^ 保留不变，中文也保留不变*/
    public static void main(String[] args) {
        File ecodingFile = new File("D:/ecodingFile.txt");//加密前文件
        File ecodedFile = new File("D:/ecodedFile.txt");//加密后文件
        encodeFile(ecodingFile, ecodedFile);//执行加密函数
    }
 
    public static void encodeFile(File ecodingFile, File ecodedFile) {//加密函数
        char[] eing = new char[(int) ecodingFile.length()];//准备读取加密前文件内容
        char[] eed = new char[(int) ecodingFile.length()];//用于接受加密后文件内容，长度与加密前一致
        try (FileReader fr = new FileReader(ecodingFile)) {//jdk7采用这种方式，流会自动关闭，这里是输入流
            fr.read(eing);//将内容读取到eing数组中
            int i = 0;
            //下面是加密的法则，注意用只要满足一个就用continue跳过后面的过程，否则会在变更后又变一次，如：0变1，1又会变2
            //每次变化后将结果存入eed数组
            for (char iss : eing) {
                if (iss == '9') {
                    iss = '0';
                    eed[i] = iss;
                    i++;
                    continue;
                }
                if (iss == 'z') {
                    iss = 'a';
                    eed[i] = iss;
                    i++;
                    continue;
                }
                if (iss == 'Z') {
                    iss = 'A';
                    eed[i] = iss;
                    i++;
                    continue;
                }
                if ((iss < '9' && iss >= '0') || (iss >= 'a' && iss < 'z') || (iss >= 'A' && iss < 'Z')) {
                    iss = (char) (iss + 1);
                    eed[i] = iss;
                    i++;
                    continue;
                }
                eed[i] = iss;
                i++;
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
 
        try (FileWriter fw = new FileWriter(ecodedFile)) {//建立输出流
            fw.write(eed);//读到加密后文件里，若不想替换而是追加，可以加true：try (FileWriter fw = new FileWriter(ecodedFile，true)) {
        } catch (IOException ioException) {
            ioException.printStackTrace();
        }
    }
 
}

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

2022-09-08 加解密及注意事项

ljbeiji

关于 JAVA 中级-I/O-字符流的提问

如果发现输出结果有小方块说明文件中有中文字符，一个中文字符占3字节长度，所以打印出来就会有两个空字符可以加个循环过滤掉字符等于0的字符，就不会有空字符了

//加密
public static void encodeFile(File metaFile, File encodedFile) throws IOException {
    //存储原始数据
    char[] chars = new char[(int) metaFile.length()];
    //存储去掉中文带来的空字符的数据，这样打印就不会有很多方块了
    char[] tmp = new char[0];
    try (FileReader fr = new FileReader(metaFile);) {
        fr.read(chars);
        //过滤掉空字符
        for (int i = 0; i < chars.length; i++)
            if (chars[i] != 0) {
                tmp = Arrays.copyOf(tmp, tmp.length + 1);
                tmp[i] = chars[i];
            }
        //加密
        for (int i = 0; i < tmp.length; i++) {
            if (Character.isDigit(tmp[i])) {
                if (tmp[i] == '9')
                    tmp[i] -= 9;
                else
                    tmp[i]++;
            } else if (Character.isLetter(tmp[i])) {
                if (tmp[i] == 'Z' || tmp[i] == 'z')
                    tmp[i] -= 25;
                else if (tmp[i] > 64 && tmp[i] < 91 || tmp[i] > 96 && chars[i] < 123)
                    tmp[i]++;
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
 
    try (FileWriter fw = new FileWriter(encodedFile)) {
        fw.write(tmp);
    } catch (IOException e) {
        e.printStackTrace();
    }
 
}
 
//解密
private static void decodeFile(File encodedFile, File decodedFile) {
    //存储待解密元数据
    char[] chars = new char[(int) encodedFile.length()];
    //存储去掉中文带来的空字符的待解密数据
    char[] tmp = new char[0];
    try (FileReader fr = new FileReader(encodedFile);) {
        fr.read(chars);
        //过滤掉空字符
        for (int i = 0; i < chars.length; i++)
            if (chars[i] != 0) {
                tmp = Arrays.copyOf(tmp, tmp.length + 1);
                tmp[i] = chars[i];
            }
        //解密
        for (int i = 0; i < tmp.length; i++) {
            if (Character.isDigit(tmp[i])) {
                if (tmp[i] == '0')
                    tmp[i] += 9;
                else
                    tmp[i]--;
            } else if (Character.isLetter(tmp[i])) {
                if (tmp[i] == 'A' || tmp[i] == 'a')
                    tmp[i] += 25;
                else if (tmp[i] > 64 && tmp[i] < 91 || tmp[i] > 96 && chars[i] < 123)
                    tmp[i]--;
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
 
    try (FileWriter fw = new FileWriter(decodedFile)) {
        fw.write(tmp);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
 
public static void main(String[] args) {
 
    //字符流读
    File file1 = new File("C:\\Users\\ljbeiji\\Desktop\\Test Folder\\Test File.txt");
    //字符流写
    File file2 = new File("C:\\Users\\ljbeiji\\Desktop\\Test Folder\\Test File2.txt");
 
    try {
        encodeFile(file1, file2);
    } catch (IOException e) {
        e.printStackTrace();
    }
 
    decodeFile(file2, file1);
}

1 个答案

阿文6
答案时间：2022-10-27

代码超过 5行，点击查看

public static void encodeFile(File metaFile, File encodedFile) throws IOException {
        //存储原始数据
        char[] chars = new char[(int) metaFile.length()];
        //存储去掉中文带来的空字符的数据，这样打印就不会有很多方块了
        char[] tmp = new char[0];
        try (FileReader fr = new FileReader(metaFile);) {
            fr.read(chars);
            //过滤掉空字符
            for (int i = 0; i < chars.length; i++)
                if (chars[i] != 0) {
                    tmp = Arrays.copyOf(tmp, tmp.length + 1);
                    tmp[i] = chars[i];
                }
            //加密
            for (int i = 0; i < tmp.length; i++) {
                if (Character.isDigit(tmp[i])) {
                    if (tmp[i] == '9')
                        tmp[i] -= 9;
                    else
                        tmp[i]++;
                } else if (Character.isLetter(tmp[i])) {
                    if (tmp[i] == 'Z' || tmp[i] == 'z')
                        tmp[i] -= 25;
                    else if (tmp[i] > 64 && tmp[i] < 91 || tmp[i] > 96 && chars[i] < 123)
                        tmp[i]++;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
      
        try (FileWriter fw = new FileWriter(encodedFile)) {
            fw.write(tmp);
        } catch (IOException e) {
            e.printStackTrace();
        }
      
    }
    public static void main(String[] args){
        TestFile x = new TestFile();
     
         //字符流读
        File file1 = new File("d:/LOL.txt");
        //字符流写
        File file2 = new File("d:/LOL2.txt");
      
        try {
            x.encodeFile(file1, file2);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

回答已经提交成功，正在审核。请于我的回答处查看回答记录，谢谢

提问太多，页面渲染太慢，为了加快渲染速度，本页最多只显示几条提问。还有 116 条以前的提问，请点击查看

提问之前请登陆

提问已经提交成功，正在审核。请于我的提问处查看提问记录，谢谢