java字符串编码类型获取

最新推荐文章于 2023-02-14 16:44:17 发布
最新推荐文章于 2023-02-14 16:44:17 发布
阅读量236 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hf312350968/article/details/84356611
版权 

Encoding.java


package org.loon.test.encoding;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:编码基本类型集合
 * </p>
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * <p>
 * License: http://www.apache.org/licenses/LICENSE-2.0
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public class Encoding ...{

    // 支持的字符格式
    public static int GB2312 = 0;

    public static int GBK = 1;
    
    public static int BIG5 = 2;

    public static int UTF8 = 3;

    public static int UNICODE = 4;

    public static int EUC_KR = 5;

    public static int SJIS = 6;

    public static int EUC_JP = 7;

    public static int ASCII = 8;

    public static int UNKNOWN = 9;

    public static int TOTALT = 10;

    public final static int SIMP = 0;

    public final static int TRAD = 1;

    // 解析名称用
    public static String[] javaname;

    // 编码用
    public static String[] nicename;

    // 应用于html中的字符集
    public static String[] htmlname;

    public Encoding() ...{
        javaname = new String[TOTALT];
        nicename = new String[TOTALT];
        htmlname = new String[TOTALT];
        javaname[GB2312] = "GB2312";
        javaname[GBK] = "GBK";
        javaname[BIG5] = "BIG5";
        javaname[UTF8] = "UTF8";
        javaname[UNICODE] = "Unicode";
        javaname[EUC_KR] = "EUC_KR";
        javaname[SJIS] = "SJIS";
        javaname[EUC_JP] = "EUC_JP";
        javaname[ASCII] = "ASCII";
        javaname[UNKNOWN] = "ISO8859_1";

        // 分配编码名称
        htmlname[GB2312] = "GB2312";
        htmlname[GBK] = "GBK";
        htmlname[BIG5] = "BIG5";
        htmlname[UTF8] = "UTF-8";
        htmlname[UNICODE] = "UTF-16";
        htmlname[EUC_KR] = "EUC-KR";
        htmlname[SJIS] = "Shift_JIS";
        htmlname[EUC_JP] = "EUC-JP";
        htmlname[ASCII] = "ASCII";
        htmlname[UNKNOWN] = "ISO8859-1";

        // 分配可读名称
        nicename[GB2312] = "GB-2312";
        nicename[GBK] = "GBK";
        nicename[BIG5] = "Big5";
        nicename[UTF8] = "UTF-8";
        nicename[UNICODE] = "Unicode";
        nicename[EUC_KR] = "EUC-KR";
        nicename[SJIS] = "Shift-JIS";
        nicename[EUC_JP] = "EUC-JP";
        nicename[ASCII] = "ASCII";
        nicename[UNKNOWN] = "UNKNOWN";

    }

    public String toEncoding(final int type) ...{
        return (javaname[type] + "," + nicename[type] + "," + htmlname[type])
                .intern();
    }


}

Encode,java（省略，见源码）

ParseEncoding.java


package org.loon.test.encoding;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;

/** *//**
 * <p>
 * Title: LoonFramework
 * </p>
 * <p>
 * Description:
 * </p>
 * <p>
 * Copyright: Copyright (c) 2008
 * </p>
 * <p>
 * Company: LoonFramework
 * </p>
 * <p>
 * License: http://www.apache.org/licenses/LICENSE-2.0
 * </p>
 * 
 * @author chenpeng
 * @email：ceponline@yahoo.com.cn
 * @version 0.1
 */
public class ParseEncoding extends Encode ...{

    public ParseEncoding() ...{
        super();
        GB2312format = new int[94][94];
        GBKformat = new int[126][191];
        Big5format = new int[94][158];
        EUC_KRformat = new int[94][94];
        JPformat = new int[94][94];

        // 初始化编码格式
        init();
    }

    public String getEncoding(final String path) ...{
        return check(getEncodeValue(path));
    }

    public String getEncoding(final InputStream in) ...{
        return check(getEncodeValue(in));
    }

    public String getEncoding(final byte[] buffer) ...{
        return check(getEncodeValue(buffer));
    }

    public String getEncoding(final URL url) ...{
        return check(getEncodeValue(url));
    }

    private String check(final int result) ...{
        if (result == -1) ...{
            return nicename[UNKNOWN];
        }
        return nicename[result];
    }

    /** *//**
     * 解析指定字符串路径编码所用格式
     * 
     * @param path
     * @return
     */
    private int getEncodeValue(String path) ...{
        int express = UNKNOWN;
        if (path.startsWith("http://")) ...{
            try ...{
                express = getEncodeValue(new URL(path));
            } catch (MalformedURLException e) ...{
                express = -1;
            }
        } else ...{
            express = getEncodeValue(new File(path));
        }
        return express;
    }

    /** *//**
     * 
     * 解析指定InputStream所用编码，返回或然率最高的编码类型数值
     * 
     * @param in
     * @return
     */
    public int getEncodeValue(InputStream in) ...{
        byte[] rawtext = new byte[8192];
        int bytesread = 0, byteoffset = 0;
        int express = UNKNOWN;
        InputStream stream = in;
        try ...{
            while ((bytesread = stream.read(rawtext, byteoffset, rawtext.length
                    - byteoffset)) > 0) ...{
                byteoffset += bytesread;
            }
            ;
            stream.close();
            express = getEncodeValue(rawtext);
        } catch (Exception e) ...{
            express = -1;
        }
        return express;
    }

    /** *//**
     * 解析指定url下数据所用编码，返回或然率最高的编码类型数值
     * 
     * @param url
     * @return
     */
    public int getEncodeValue(URL url) ...{

        InputStream stream;
        try ...{
            stream = url.openStream();
        } catch (IOException e) ...{
            stream = null;
        }

        return getEncodeValue(stream);
    }

    /** *//**
     * 解析指定file所用编码，返回或然率最高的编码类型数值
     * 
     * @param file
     * @return
     */
    public int getEncodeValue(File file) ...{
        byte[] buffer;
        try ...{
            buffer = read(new FileInputStream(file));
        } catch (FileNotFoundException e) ...{
            buffer = null;
        }
        return getEncodeValue(buffer);
    }

    /** *//**
     * 将inputstream转为byte[]
     * 
     * @param inputStream
     * @return
     */
    private final byte[] read(final InputStream inputStream) ...{
        byte[] arrayByte = null;
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] bytes = new byte[8192];
        try ...{
            bytes = new byte[inputStream.available()];
            int read;
            while ((read = inputStream.read(bytes)) >= 0) ...{
                byteArrayOutputStream.write(bytes, 0, read);
            }
            arrayByte = byteArrayOutputStream.toByteArray();
        } catch (IOException e) ...{
            return null;
        }
        return arrayByte;
    }

    /** *//**
     * 解析指定byte[]所用编码，返回或然率最高的数值类型
     * 
     * @param content
     * @return
     */
    public int getEncodeValue(byte[] content) ...{
        if (content == null)
            return -1;
        int[] scores;
        int index, maxscore = 0;
        int encoding = UNKNOWN;
        scores = new int[TOTALT];
        // 分配或然率
        scores[GB2312] = gb2312probability(content);
        scores[GBK] = gbkprobability(content);
        scores[BIG5] = big5probability(content);
        scores[UTF8] = utf8probability(content);
        scores[UNICODE] = utf16probability(content);
        scores[EUC_KR] = euc_krprobability(content);
        scores[ASCII] = asciiprobability(content);
        scores[SJIS] = sjisprobability(content);
        scores[EUC_JP] = euc_jpprobability(content);
        scores[UNKNOWN] = 0;

        // 概率比较
        for (index = 0; index < TOTALT; index++) ...{
            if (scores[index] > maxscore) ...{
                // 索引
                encoding = index;
                // 最大几率
                maxscore = scores[index];
            }
        }
        // 返回或然率大于50%的数据
        if (maxscore <= 50) ...{
            encoding = UNKNOWN;
        }
        return encoding;
    }

    /** *//**
     * gb2312数据或然率计算
     * 
     * @param content
     * @return
     */
    private int gb2312probability(byte[] content) ...{
        int i, rawtextlen = 0;

        int dbchars = 1, gbchars = 1;
        long gbformat = 0, totalformat = 1;
        float rangeval = 0, formatval = 0;
        int row, column;

        // 检查是否在亚洲汉字范围内
        rawtextlen = content.length;
        for (i = 0; i < rawtextlen - 1; i++) ...{
            if (content[i] >= 0) ...{
            } else ...{
                dbchars++;
                // 汉字GB码由两个字节组成，每个字节的范围是0xA1 ~ 0xFE
                if ((byte) 0xA1 <= content[i] && content[i] <= (byte) 0xF7
                        && (byte) 0xA1 <= content[i + 1]
                        && content[i + 1] <= (byte) 0xFE) ...{
                    gbchars++;
                    totalformat += 500;
                    row = content[i] + 256 - 0xA1;
                    column = content[i + 1] + 256 - 0xA1;
                    if (GB2312format[row][column] != 0) ...{
                        gbformat += GB2312format[row][column];
                    } else if (15 <= row && row < 55) ...{
                        // 在gb编码范围
                        gbformat += 200;
                    }

                }
                i++;
            }
        }
        rangeval = 50 * ((float) gbchars / (float) dbchars);
        formatval = 50 * ((float) gbformat / (float) totalformat);

        return (int) (rangeval + formatval);
    }

    /** *//**
     * gb2312或然率计算
     * 
     * @param content
     * @return
     */
    private int gbkprobability(byte[] content) ...{
        int i, rawtextlen = 0;

        int dbchars = 1, gbchars = 1;
        long gbformat = 0, totalformat = 1;
        float rangeval = 0, formatval = 0;
        int row, column;
        rawtextlen = content.length;
        for (i = 0; i < rawtextlen - 1; i++) ...{
            if (content[i] >= 0) ...{
            } else ...{
                dbchars++;
                if ((byte) 0xA1 <= content[i] && content[i] <= (byte) 0xF7
                        && // gb范围
                        (byte) 0xA1 <= content[i + 1]
                        && content[i + 1] <= (byte) 0xFE) ...{
                    gbchars++;
                    totalformat += 500;
                    row = content[i] + 256 - 0xA1;
                    column = content[i + 1] + 256 - 0xA1;
                    if (GB2312format[row][column] != 0) ...{
                        gbformat += GB2312format[row][column];
                    } else if (15 <= row && row < 55) ...{
                        gbformat += 200;
                    }

                } else if ((byte) 0x81 <= content[i]
                        && content[i] <= (byte) 0xFE && // gb扩展区域
                        (((byte) 0x80 <= content[i + 1] && content[i + 1] <= (byte) 0xFE) || ((byte) 0x40 <= content[i + 1] && content[i + 1] <= (byte) 0x7E))) ...{
                    gbchars++;
                    totalformat += 500;
                    row = content[i] + 256 - 0x81;
                    if (0x40 <= content[i + 1] && content[i + 1] <= 0x7E) ...{
                        column = content[i + 1] - 0x40;
                    } else ...{
                        column = content[i + 1] + 256 - 0x40;
                    }
                    if (GBKformat[row][column] != 0) ...{
                        gbformat += GBKformat[row][column];
                    }
                }
                i++;
            }
        }
        rangeval = 50 * ((float) gbchars / (float) dbchars);
        formatval = 50 * ((float) gbformat / (float) totalformat);
        return (int) (rangeval + formatval) - 1;
    }

    /** *//**
     * 解析为big5的或然率
     * 
     * @param content
     * @return
     */
    private int big5probability(byte[] content) ...{
        int i, rawtextlen = 0;
        int dbchars = 1, bfchars = 1;
        float rangeval = 0, formatval = 0;
        long bfformat = 0, totalformat = 1;
        int row, column;
        rawtextlen = content.length;
        for (i = 0; i < rawtextlen - 1; i++) ...{
            if (content[i] >= 0) ...{
            } else ...{
                dbchars++;
                if ((byte) 0xA1 <= content[i]
                        && content[i] <= (byte) 0xF9
                        && (((byte) 0x40 <= content[i + 1] && content[i + 1] <= (byte) 0x7E) || ((byte) 0xA1 <= content[i + 1] && content[i + 1] <= (byte) 0xFE))) ...{
                    bfchars++;
                    totalformat += 500;
                    row = content[i] + 256 - 0xA1;
                    if (0x40 <= content[i + 1] && content[i + 1] <= 0x7E) ...{
                        column = content[i + 1] - 0x40;
                    } else ...{
                        column = content[i + 1] + 256 - 0x61;
                    }
                    if (Big5format[row][column] != 0) ...{
                        bfformat += Big5format[row][column];
                    } else if (3 <= row && row <= 37) ...{
                        bfformat += 200;
                    }
                }
                i++;
            }
        }
        rangeval = 50 * ((float) bfchars / (float) dbchars);
        formatval = 50 * ((float) bfformat / (float) totalformat);

        return (int) (rangeval + formatval);
    }

    /** *//**
     * 在utf-8中的或然率
     * 
     * @param content
     * @return
     */
    private int utf8probability(byte[] content) ...{
        int score = 0;
        int i, rawtextlen = 0;
        int goodbytes = 0, asciibytes = 0;
        // 检查是否为汉字可接受范围
        rawtextlen = content.length;
        for (i = 0; i < rawtextlen; i++) ...{
            if ((content[i] & (byte) 0x7F) == content[i]) ...{
                asciibytes++;
            } else if (-64 <= content[i] && content[i] <= -33
                    && i + 1 < rawtextlen && -128 <= content[i + 1]
                    && content[i + 1] <= -65) ...{
                goodbytes += 2;
                i++;
            } else if (-32 <= content[i] && content[i] <= -17
                    && i + 2 < rawtextlen && -128 <= content[i + 1]
                    && content[i + 1] <= -65 && -128 <= content[i + 2]
                    && content[i + 2] <= -65) ...{
                goodbytes += 3;
                i += 2;
            }
        }

        if (asciibytes == rawtextlen) ...{
            return 0;
        }

        score = (int) (100 * ((float) goodbytes / (float) (rawtextlen - asciibytes)));
        // 如果不高于98则减少到零
        if (score > 98) ...{
            return score;
        } else if (score > 95 && goodbytes > 30) ...{
            return score;
        } else ...{
            return 0;
        }

    }

    /** *//**
     * 检查为utf-16的或然率
     * 
     * @param content
     * @return
     */
    private int utf16probability(byte[] content) ...{

        if (content.length > 1
                && ((byte) 0xFE == content[0] && (byte) 0xFF == content[1])
                || ((byte) 0xFF == content[0] && (byte) 0xFE == content[1])) ...{
            return 100;
        }
        return 0;
    }

    /** *//**
     * 检查为ascii的或然率
     * 
     * @param content
     * @return
     */
    private int asciiprobability(byte[] content) ...{
        int score = 75;
        int i, rawtextlen;

        rawtextlen = content.length;

        for (i = 0; i < rawtextlen; i++) ...{
            if (content[i] < 0) ...{
                score = score - 5;
            } else if (content[i] == (byte) 0x1B) ...{ // ESC (used by ISO 2022)
                score = score - 5;
            }
            if (score <= 0) ...{
                return 0;
            }
        }
        return score;
    }

    /** *//**
     * 检查为euc_kr的或然率
     * 
     * @param content
     * @return
     */
    private int euc_krprobability(byte[] content) ...{
        int i, rawtextlen = 0;

        int dbchars = 1, krchars = 1;
        long krformat = 0, totalformat = 1;
        float rangeval = 0, formatval = 0;
        int row, column;
        rawtextlen = content.length;
        for (i = 0; i < rawtextlen - 1; i++) ...{
            if (content[i] >= 0) ...{
            } else ...{
                dbchars++;
                if ((byte) 0xA1 <= content[i] && content[i] <= (byte) 0xFE
                        && (byte) 0xA1 <= content[i + 1]
                        && content[i + 1] <= (byte) 0xFE) ...{
                    krchars++;
                    totalformat += 500;
                    row = content[i] + 256 - 0xA1;
                    column = content[i + 1] + 256 - 0xA1;
                    if (EUC_KRformat[row][column] != 0) ...{
                        krformat += EUC_KRformat[row][column];
                    } else if (15 <= row && row < 55) ...{
                        krformat += 0;
                    }

                }
                i++;
            }
        }
        rangeval = 50 * ((float) krchars / (float) dbchars);
        formatval = 50 * ((float) krformat / (float) totalformat);

        return (int) (rangeval + formatval);
    }

    private int euc_jpprobability(byte[] content) ...{
        int i, rawtextlen = 0;

        int dbchars = 1, jpchars = 1;
        long jpformat = 0, totalformat = 1;
        float rangeval = 0, formatval = 0;
        int row, column;

        rawtextlen = content.length;
        for (i = 0; i < rawtextlen - 1; i++) ...{
            if (content[i] >= 0) ...{
            } else ...{
                dbchars++;
                if ((byte) 0xA1 <= content[i] && content[i] <= (byte) 0xFE
                        && (byte) 0xA1 <= content[i + 1]
                        && content[i + 1] <= (byte) 0xFE) ...{
                    jpchars++;
                    totalformat += 500;
                    row = content[i] + 256 - 0xA1;
                    column = content[i + 1] + 256 - 0xA1;
                    if (JPformat[row][column] != 0) ...{
                        jpformat += JPformat[row][column];
                    } else if (15 <= row && row < 55) ...{
                        jpformat += 0;
                    }

                }
                i++;
            }
        }
        rangeval = 50 * ((float) jpchars / (float) dbchars);
        formatval = 50 * ((float) jpformat / (float) totalformat);

        return (int) (rangeval + formatval);
    }

    private int sjisprobability(byte[] content) ...{
        int i, rawtextlen = 0;

        int dbchars = 1, jpchars = 1;
        long jpformat = 0, totalformat = 1;
        float rangeval = 0, formatval = 0;
        int row, column, adjust;

        rawtextlen = content.length;
        for (i = 0; i < rawtextlen - 1; i++) ...{
            if (content[i] >= 0) ...{
            } else ...{
                dbchars++;
                if (i + 1 < content.length
                        && (((byte) 0x81 <= content[i] && content[i] <= (byte) 0x9F) || ((byte) 0xE0 <= content[i] && content[i] <= (byte) 0xEF))
                        && (((byte) 0x40 <= content[i + 1] && content[i + 1] <= (byte) 0x7E) || ((byte) 0x80 <= content[i + 1] && content[i + 1] <= (byte) 0xFC))) ...{
                    jpchars++;
                    totalformat += 500;
                    row = content[i] + 256;
                    column = content[i + 1] + 256;
                    if (column < 0x9f) ...{
                        adjust = 1;
                        if (column > 0x7f) ...{
                            column -= 0x20;
                        } else ...{
                            column -= 0x19;
                        }
                    } else ...{
                        adjust = 0;
                        column -= 0x7e;
                    }
                    if (row < 0xa0) ...{
                        row = ((row - 0x70) << 1) - adjust;
                    } else ...{
                        row = ((row - 0xb0) << 1) - adjust;
                    }

                    row -= 0x20;
                    column = 0x20;
                    if (row < JPformat.length && column < JPformat[row].length
                            && JPformat[row][column] != 0) ...{
                        jpformat += JPformat[row][column];
                    }
                    i++;
                } else if ((byte) 0xA1 <= content[i]
                        && content[i] <= (byte) 0xDF) ...{
                }

            }
        }
        rangeval = 50 * ((float) jpchars / (float) dbchars);
        formatval = 50 * ((float) jpformat / (float) totalformat);

        return (int) (rangeval + formatval) - 1;
    }

}


EncodingTest.java


package org.loon.test.encoding;
/** *//**
 * <p>Title: LoonFramework</p>
 * <p>Description:</p>
 * <p>Copyright: Copyright (c) 2008</p>
 * <p>Company: LoonFramework</p>
 * <p>License: http://www.apache.org/licenses/LICENSE-2.0</p>
 * @author chenpeng  
 * @email：ceponline@yahoo.com.cn 
 * @version 0.1
 */
public class EncodingTest ...{
    public static void main(String argc[]) ...{
        ParseEncoding parse;

        parse = new ParseEncoding();
        
         System.out.println("中国大陆：");
         System.out.println("测试字符串，编码格式="+parse.getEncoding("百度".getBytes()));
         System.out.println("测试站点，编码格式="+parse.getEncoding("http://www.baidu.com"));
         System.out.println();
         System.out.println("中国台湾：");
         System.out.println("测试字符串，编码格式="+parse.getEncoding("い地チ瓣".getBytes()));
         System.out.println("测试站点，编码格式="+parse.getEncoding("http://tw.yahoo.com/"));
         System.out.println("测试站点(繁体字，UTF编码)，编码格式="+parse.getEncoding("http://www.javaworld.com.tw/jute"));
         System.out.println();
         System.out.println("日本：");
         System.out.println("测试字符串，编码格式="+parse.getEncoding("その機能".getBytes()));
         System.out.println("测试站点，编码格式="+parse.getEncoding("http://www.4gamer.net"));
         System.out.println();
         System.out.println("自称蚩尤后代那群……：");
         System.out.println("测试站点，编码格式="+parse.getEncoding("http://www.easyjava.co.kr/"));
        
    }
}
 原文: http://xxw8393.blog.163.com/blog/static/37256834200910432656672/
翊骷
关注
java获取String字符串编码格式
人真正变得强大，不是因为守护着自尊心，而是抛开自尊心的时候。
02-03 3036
简单做下记录 // 直接上代码 public static String getEncoding(String str) { String encode = "GB2312"; try { if (isEncoding(str, encode)) { // 判断是不是GB2312 return encode; } } catch (Exception exception) { } encode = "ISO-8859-1"; try { if (isEnco
java获取字符串编码类型代码
04-15
通过解析字符串获取字符串编码类型的java代码
Java——获取字符串编码格式
热门推荐
前方一片光明
08-27 1万+
public static String getEncoding(String str) { String encode = "GB2312"; try { if (str.equals(new String(str.getBytes(encode), encode))) { // 判断是不是GB2312 String s = encode; return s; // 是的...
java 获取字符串编码类型
C语言是最好的编程语言
12-21 698
public static String getEncoding(String str) { String encode = "GB2312"; try { if (str.equals(new String(str.getBytes(encode), encode))) {
Java 获取字符串的编码类型
weixin_48468483的博客
12-30 1375
Java 获取字符串的编码类型
java获取字符串编码类型代码(导入直接查看结果)
04-17
总的来说，Java中获取字符串编码类型没有一个直接的标准方法，开发者需要借助一些技巧和外部库来实现。在处理编码问题时，理解各种编码格式的特性以及它们之间的差异至关重要，这样才能有效地避免乱码问题，保证数据...
java字符串编码获取
08-07
要获取Java字符串的字节序列（即编码），可以使用`getBytes()`方法。此方法默认使用平台的默认编码，通常为UTF-8，但也可以指定其他编码，如`getBytes("GBK")`。如果需要确定字符串的原始编码，需要额外的信息，...
详解Java中String类型与默认字符编码
08-26
如果我们不指定编码方式，那么getBytes()方法将使用String类型的默认编码方式来将字符串编码为字节数组。 结论 Java中String类型的默认编码方式是与本地系统的编码方式相关的。我们需要了解String类型的默认编码...
如何使用Java代码获取文件、文件流或字符串的编码方式.zip
02-11
本工程用于研究如何使用Java代码获取文件、文件流或字符串的编码方式 本工程编码方式：UTF-8 开发工具：MyEclipse 参考博客：http://blog.csdn.net/gaohuanjie/article/details/43735891
如何在java获取字符串是什么编码格式
最新发布
weixin_35749796的博客
02-14 2997
要在 Java 中获取字符串的编码格式，您可以使用 Java 的 Charset 类。您可以通过以下方式获取字符串的编码： String str= "your string"; Charset charset = Charset.forName("UTF-8"); System.out.println(charset.displayName()); 其中，UTF-8 是您要使用的编码格式，您可以...
java 字符串的编码格式_java 获取获取字符串编码格式
weixin_36245958的博客
02-12 196
public static String getEncoding(String str) {String encode = "GB2312";try {if (str.equals(new String(str.getBytes(encode), encode))) { //判断是不是GB2312String s = encode;return s; //是的话，返回“GB23...
java获取字符串的编码_java 获取获取字符串编码格式
weixin_34792641的博客
02-18 532
public static String getEncoding(String str) {String encode = "GB2312";try {if (str.equals(new String(str.getBytes(encode), encode))) {String s = encode;return s;}} catch (Exception exception) {}encod...
Java获取字符串编码方式
weixin_34218890的博客
10-08 336
直接下载吧： http://files.cnblogs.com/files/xiluhua/BytesEncodingDetectTool.rar  
获取字符串的编码格式
sinat_19171485的博客
05-26 4839
public static String getEncoding(String str) { String encode = "GB2312"; try { if (str.equals(new String(str.getBytes(encode), encode))) {
判断字符串的编码格式
choujingyou1908的博客
09-23 1653
public String Test(){ String xml=""; String encode = "GB2312"; try { if (xml.equals(new Str...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值