`
312350968
  • 浏览: 212130 次
  • 性别: Icon_minigender_1
  • 来自: 济南
社区版块
存档分类
最新评论

java字符串编码类型获取

java 
阅读更多 

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/
分享到：
| 在头文件设置action,直接跳转
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java获取字符串编码类型代码

    通过解析字符串获取字符串编码类型的java代码

    java获取字符串编码类型代码(导入直接查看结果)

    总的来说，Java中获取字符串编码类型没有一个直接的标准方法，开发者需要借助一些技巧和外部库来实现。在处理编码问题时，理解各种编码格式的特性以及它们之间的差异至关重要，这样才能有效地避免乱码问题，保证数据...

    java字符串编码转换

    ### Java字符串编码转换详解 #### 一、Java 字符串编码转换基础 在Java中，字符串的处理是非常常见的操作之一，而字符编码是确保数据正确显示的关键因素。本篇文章将重点介绍Java中字符串编码的转换方法及其在Web...

    java字符串编码获取

    要获取Java字符串的字节序列（即编码），可以使用`getBytes()`方法。此方法默认使用平台的默认编码，通常为UTF-8，但也可以指定其他编码，如`getBytes("GBK")`。如果需要确定字符串的原始编码，需要额外的信息，...

    JAVA 字符串应用笔记

    在Java编程语言中，字符串是极其重要且常用的数据类型，尤其在Android开发中更是不可或缺。字符串主要用于处理文本信息，如用户输入、文件内容、网络数据等。以下是对"JAVA 字符串应用笔记"中可能涉及的一些核心知识...

    Java 字符串与文本相关实例源码

    在Java编程语言中，字符串(String)是至关重要的数据类型，用于处理文本信息。字符串是不可变的，这意味着一旦创建，就不能更改其...通过学习和实践这些示例，开发者可以更好地掌握Java字符串操作的技巧，提升编程能力。

    java中常用字符串方法总结

    17. **字符串编码与解码** `getBytes()`将字符串转换为字节数组，`new String(byte[], charset)`根据字符集将字节数组还原为字符串。 18. **判断前缀与后缀** `startsWith(String prefix)`和`endsWith(String ...

    java处理字符和字符串课件

    在Java编程中，字符和字符串是最常见的数据类型之一。为了方便高效地处理这些数据类型，Java提供了强大的支持，包括`Character`类和`String`类等。这些类位于`java.lang`包中，无需额外导入即可使用。 #### 二、...

    java_字符编码 Javajava_字符编码问题

    #### 二、Java中的字符串与字符编码 在 Java 中，`String` 类型是一种特殊的类型，它用来表示一系列字符的序列。Java 的 `String` 类内部是以 Unicode 编码存储的，这意味着每个字符都对应一个特定的 Unicode 码点...

    JAVA获取文件编码格式

    4. **处理结果**：`detectFileEncoding`函数返回的字符串是检测到的文件编码，可以根据这个信息来决定如何读取和处理文件内容。如果返回的是“unknown”，则表示无法确定文件的编码。 通过以上步骤，我们就可以在...

    截取指定长度的字符串

    字符串在各种编程语言中都是基本的数据类型，如Python中的`str`，Java中的`String`，JavaScript中的`String`等。 截取字符串通常有两种主要方法：固定位置截取和指定长度截取。 1. 固定位置截取：这种方法通常基于...

    JAVA_字符编码

    总之，Java中的字符编码是一个复杂的主题，涉及Unicode、编码解码、I/O流的使用以及字符串处理等多个方面。了解这些知识对于编写跨平台、支持多语言的程序至关重要。通过深入学习和实践，开发者可以更好地处理各种...

    截取如下字符串“java程序教程”的前5个字节,字符串应该为“java程”,截取前6个字符,字符串也应该为“java程”,程序实现之.

    在Java中，字符串是一种对象类型，用于表示文本。而字节则是存储在byte数组中的基本数据类型，用来表示原始的二进制数据。由于Java默认使用Unicode字符编码，每个字符（char）占用2个字节（byte），因此对于中文字符...

    java与c交互传递字符串和整型

    在JNI中，我们使用`NewStringUTF`函数从Java字符串创建一个C的UTF-8编码的字符串，然后使用`GetStringUTFChars`获取其实际内容。在C中处理完字符串后，需要使用`ReleaseStringUTFChars`释放资源。这个过程确保了内存...

    java字符编码问题

    而Java中的字符串`String`是由一系列`char`组成的序列，因此在默认情况下，Java字符串本身就是基于Unicode的。 #### 三、字符集与字符编码的关系 1. **字符集**：是指一组字符的集合，比如ASCII、GBK、GB2312等。 ...

    JAVA字符串中所用的方法.rar

    本资料将深入探讨Java字符串中常用的方法。 1. **创建字符串** - `new String()`: 通过构造函数创建，可以传入字符数组或另一个字符串。 - `""`: 字符串字面量，例如 `"Hello"`，Java会自动在字符串池中创建一个...

    关于JAVA字符编码：Unicode,ISO-8859-1,GBK,UTF-8编码及相互转换

    ### 关于JAVA字符编码：Unicode, ISO-8859-1, GBK, UTF-8 编码及相互转换 在Java开发过程中，字符编码是处理文本数据的基础，不同的编码方式会影响数据的存储、传输以及显示。本文将详细介绍几种常见的字符编码...

    java 给指定字符赋值

    综上所述，Java中的字符赋值涉及到变量声明、转义序列、Unicode编码、字符串与字符转换、字符操作以及I/O流等多个方面。在实际编程中，理解和熟练运用这些概念对于编写高效且可读性强的代码至关重要。

    JAVA字符串截取方法总结[文].pdf

    Java字符串处理是编程中常见的任务，这里我们详细讨论一下Java中字符串截取及相关方法。 1. `length()`：此方法返回字符串的长度，即字符的数量。例如，`s.length()`会返回字符串`s`中字符的个数。 2. `charAt(int...

    java常用字符串方法网络收集txt版

    16. **获取字符串编码** - `getBytes()`: 获取字符串的字节数组，使用平台默认编码。 - `getBytes(Charset charset)`: 指定字符集获取字节数组。 17. **字符串反转** - `reverse()`: 反转字符串中的字符顺序。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics