工作笔记:正则切割字符串

对 “中华｜人民｜共和｜国”这样的字符串进行切割，切割后写入以新的文件中。
1、用FileOutputStream 把字符串写入文件中；
2、用FileInputStream（或者BufferedReader）对文件进行读取，缓冲区大小设为文件大小；并且转换成16进制；
3、对16进制下的文件进行切割。
4、切割后把16进制转换成字符串，并写入到新的文件中。

JAVA中涉及i/o流操作，就必须了解计算机编码：
1、ASCII：
在计算机中数据的存储和运算都是使用进制，而这些二进制具体表示成哪个符号，这就形成了编码。如果编码方式特别多，在通信中就会造成很多混乱。这就形成了美国信息交换标准代码(ASCII)，在于早期的西方国家，对于日常中使用的字符就是英文字母+符号。也就是2的7次方就可以完全表示使用的字符。ASCII中能表示128（0-127）个字符，比如说在大写A是65，二进制是01000001。

2、ISO-8859-1
128个字符，仍然没有办法完全表示欧洲国家所需要字符，于是在ascii的基础上利用高位又进行了扩充，使用能够表示256个字符（0-255）,这基本上满足了欧洲国家的需求。

3、Unicode
但是对于其他国家来说，比如中国的汉字可能在10万以上，ascii根本无法满足这样的需求。于是Unicode就出现了。Unicode（统一码、万国码、单一码）是一种在计算机上使用的字符编码。Unicode 是为了解决传统的字符编码方案的局限而产生的，它为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求。

4、Unicode和utf-8,utf-16;
unicode是一种编码方式，和ascii是同一个概念，而UTF是一种存储方式（格式）。unicode相当于一个符号集，它规定的每种语言对应的二进制，编码，但没有规定这个二进制如何存储。比如说汉字，占两个字节，但在编码中靠后的有可能三个字节，甚至四个字节，这样就产生了unicode编码的多种存储方式。

5、UTF-8
utf-8它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。

6、GBK
GBK的文字编码是双字节来表示的，即不论中、英文字符均使用双字节来表示，只不过为区分中文，将其最高位都定成1。
至于UTF－8编码则是用以解决国际上字符的一种多字节编码，它对英文使用8位（即一个字节），中文使用24位（三个字节）来编码。对于英文字符较多的论坛则用UTF－8节省空间。
GBK包含全部中文字符，
UTF-8则包含全世界所有国家需要用到的字符。
GBK是在国家标准GB2312基础上扩容后兼容GB2312的标准
UTF-8编码的文字可以在各国各种支持UTF8字符集的浏览器上显示。
比如，如果是UTF8编码，则在外国人的英文IE上也能显示中文，而无需他们下载IE的中文语言支持包。

对于英文比较多的论坛，使用GBK则每个字符占用2个字节，而使用UTF－8英文却只占一个字节。
UTF-8版本虽然具有良好的国际兼容性，但需要比GBK/BIG5版本多占用50%的数据库存储空间，因此并非推荐使用，仅供对国际兼容性有特殊要求的用户使用。

7、UTF-16
UTF-16好处在于大部分字符都以固定长度的字节 (2字节) 储存，但UTF-16却无法兼容于ASCII编码。最后在java中使用UTF-16表示内部文本

代码，在eclipse中写入文件

public class RegexWrite {
    /** * @param yu */
    public final static String FILE_NAME = "file.txt";
    public final static String FILE_NAME_REGEX="file_regex.txt";

    public static void main(String[] args) {
        // 写文件："中华｜人民｜共和｜国"
        try {
            //创建文件输入流，写文件；
            FileOutputStream fos = new FileOutputStream(FILE_NAME);
            fos.write("中华|人民|共和|国".getBytes());
            fos.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

2、读取文件，并转换成16进制切割，再写切割后写入到新的文件中。

public class RegexRead {
    public static void main(String[] args) {
        String context = "";
        String str_split = "|";
        try {
            // 1创建缓冲文件输出流，读文件；在java中默认的创建缓存区的大小为8192个字节；
            /*BufferedReader br = new BufferedReader(new FileReader( RegexWrite.FILE_NAME)); int read = 0; while ((read = br.read()) != -1) { context = context + (char) read; } br.close();*/
            //2、设置缓冲区文件大小为要读写文件大小；
            int read;
            FileInputStream fis =new FileInputStream(RegexWrite.FILE_NAME);
            //得到文件的字节个数；
            int available=fis.available();
            //把文件大小赋值给byte数组；
            byte b[] =new byte[available];
            System.out.println("available"+available);
            while((read=fis.read(b))>0){
                System.out.println(new String(b,0,read));
                context=context+new String(b,read);
            }
            fis.close();

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("读取所要切割的字符串 " + context);
        // 把字符串用十六进制表示；
        String str_hex = str2HexStr(context);
        // 把切割的字符串转换成十六进制；
        String split_hex = str2HexStr(str_split);

        System.out.println("内容的十六进制表示： " + str_hex);
        System.out.println("| 的十六进制表示： " + split_hex);
        // 对字符串切割，返回数组；
        String[] splie_context = str_hex.split(split_hex);
        String str_final = "";
        for (int i = 0; i < splie_context.length; i++) {
            String convert_str = "";
            convert_str = hexStr2Str(splie_context[i]);
            // convert_str = hexString2String(splie_context[i]);
            System.out
                    .println(splie_context[i] + " 转换后 " + convert_str);
            str_final = str_final + convert_str;
        }
        System.out.println("str_final " + str_final);
        // 把得到的字符串写入到新的文件中;
        try {

            BufferedWriter bw = new BufferedWriter(new FileWriter(
                    RegexWrite.FILE_NAME_REGEX));
            bw.write(str_final);
            bw.flush();
            bw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    /** * 字符串转换成16进制； * * @param str * @return */
    public static String str2HexStr(String str) {
        char[] chars = "0123456789ABCDEF".toCharArray();
        StringBuilder sb = new StringBuilder("");
        byte[] bs = str.getBytes();
        int bit;
        for (int i = 0; i < bs.length; i++) {
            bit = (bs[i] & 0x0f0) >> 4;
            sb.append(chars[bit]);
            bit = bs[i] & 0x0f;
            sb.append(chars[bit]);
        }
        return sb.toString();
    }

    /** * 十六进制转换字符串 */

    public static String hexStr2Str(String hexStr) {
        String str = "0123456789ABCDEF";
        char[] hexs = hexStr.toCharArray();
        byte[] bytes = new byte[hexStr.length() / 2];
        int n;
        for (int i = 0; i < bytes.length; i++) {
            n = str.indexOf(hexs[2 * i]) * 16;
            n += str.indexOf(hexs[2 * i + 1]);
            bytes[i] = (byte) (n & 0xff);
        }
        return new String(bytes);
    }

}

切割后

运行打印