JAVA检测字符串编码并转换

最新推荐文章于 2023-02-27 08:00:00 发布
最新推荐文章于 2023-02-27 08:00:00 发布
阅读量353 收藏
点赞数
分类专栏： java Web 文章标签： java 编码
java 同时被 2 个专栏收录
35 篇文章 0 订阅
订阅专栏
Web
7 篇文章 0 订阅
订阅专栏

就一个类，detectUtf8(String w3UrlPart)方法

 

package com.mountain.util;

import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.Map;


public class Utf8Utils {
	private static final org.apache.log4j.Logger log = org.apache.log4j.Logger
			.getLogger(Utf8Utils.class);

	public static String detectUtf8(String w3UrlPart) {
		byte[] bts;
		try {
			bts = w3UrlPart.getBytes("iso-8859-1");
			if (likeMultiByteUtf8(bts)) {
				String t = new String(bts, "UTF-8");
				if (log.isDebugEnabled()) {
					log.debug(w3UrlPart + ">treat as utf8.[" + t + "]");
				}
				return t;
			} else {
				String t = new String(bts, "GB18030");
				if (log.isDebugEnabled()) {
					log.debug(w3UrlPart + ">treat as gbxxx [" + t + "]");
				}
				return t;
			}
		} catch (UnsupportedEncodingException e) {
			log.error("", e);
			throw new RuntimeException(e);
		}
	}

	private static boolean likeMultiByteUtf8(byte[] bts) {
		int len = checkUtf8(bts);
		if (len > 2)
			return true;
		return false;
	}


	private static boolean likeEncodedUrl(String urlPart) {
		String r = urlPart.replaceAll("%25", "");
		return r.indexOf("%") > -1;
	}

	public static String detectUtf8Url(String w3UrlPart) {
		if (likeEncodedUrl(w3UrlPart)) {
			w3UrlPart = URLDecoder.decodeUrl(w3UrlPart);
		}
		return detectUtf8(w3UrlPart);
	}

	static class Utf8Magic {
		protected static final byte bm1 = (byte) 0x80; // 0x0

		protected static final byte bm2 = (byte) 0xE0;// 0xC0;

		protected static final byte bm3 = (byte) 0xF0;// 0xE0;

		protected static final byte bm4 = (byte) 0xF8;// 0xF0;

		protected static final byte tm1 = (byte) 0x0;

		protected static final byte tm2 = (byte) 0xC0;

		protected static final byte tm3 = (byte) 0xE0;

		protected static final byte tm4 = (byte) 0xF0;

		public static byte[] bms = new byte[] { bm1, bm2, bm3, bm4 };

		public static byte[] tms = new byte[] { tm1, tm2, tm3, tm4 };

		public static byte[] maskBits = new byte[] { bm1, bm2, bm3, bm4 };

		public static byte[] magicBits = new byte[] { tm1, tm2, tm3, tm4 };

		public static byte siblingMask = (byte) 0xC0;// 后续字节

		public static byte siblingMagicBits = (byte) 0x80;
		// ut16 only
		// DC00..DFFF; Low Surrogates
		// D800..DB7F; High Surrogates
		public static byte firstLowSurrogates = (byte) 0xDC;
		public static byte lastLowSurrogates = (byte) 0xDF;
		public static byte firstHighSurrogates = (byte) 0xD8;
		public static byte lastHighSurrogates = (byte) 0xDB;
	}

	// private boolean isUtf8(byte[] bs) {
	// return isUtf8(bs, false);
	// }

	public static boolean isMultiByteUtf8(byte[] bs) {
		return isUtf8(bs, true);
	}

	public static boolean isUtf8(byte[] bs, boolean multibyte) {
		// printHex(bs);
		// System.outt.println("length multibyte?" + multibyte);

		StringBuilder sb = null;
		if (log.isDebugEnabled()) {
			sb = new StringBuilder();
		}
		try {
			for (int i = 0; i < bs.length; i++) {
				byte b = bs[i];
				if (log.isDebugEnabled()) {
					sb.append("\n");
					sb.append(i).append(" : 0x").append(
							Integer.toString((0xFF & b), 16)).append("_")
							.append(Integer.toString((0xFF & b), 2));
				}
				// System.outt.print(i);
				// System.outt.print(" : 0x");
				// System.out.println(Integer.toString(b, 16));
				for (int j = 0; j < Utf8Magic.maskBits.length; j++) {

					if ((b & Utf8Magic.maskBits[j]) == Utf8Magic.magicBits[j]) {
						if (j == 0) {
							// 单字节
							if (multibyte) {
								// System.outt.println(" no allow single byte");
								if (log.isDebugEnabled()) {
									sb.append(",not allow single byte");
								}
								return false;
							} else {
							}
						} else {
							// 后面有j个字节，共j + 1 byte
							for (int k = 0; k < j; k++) {
								if ((bs[++i] & Utf8Magic.siblingMask) != Utf8Magic.siblingMagicBits) {
									// System.outt.println(" not match " +
									// Integer.toHexString(0xFF & bs[i]));
									if (log.isDebugEnabled()) {
										sb
												.append(", not match ")
												.append(
														Integer.toString(
																0xFF & bs[i],
																16))
												.append("_")
												.append(
														Integer
																.toString(
																		0xFF & bs[i],
																		2));
									}
									return false;
								} else {
									// System.outt.println(" match " +
									// Integer.toHexString(0xFF & bs[i]));
									if (log.isDebugEnabled()) {
										sb
												.append(", ")
												.append(
														Integer.toString(
																0xFF & bs[i],
																16))
												.append("_")
												.append(
														Integer
																.toString(
																		0xFF & bs[i],
																		2));
									}
								}
							}
						}
						// System.outt.println("match by " + j);
						if (log.isDebugEnabled()) {
							sb.append(", match by " + j);
						}
						break;
					} else {
						if (j >= Utf8Magic.maskBits.length - 1) {
							// System.outt.println(j);
							// System.outt.println("no mask match");
							if (log.isDebugEnabled()) {
								sb.append(", no mask match ").append(j);
							}
							return false;
						}
					}
				}
				// System.outt.println();
			}
			return true;
		} finally {
			if (log.isDebugEnabled()) {
				log.debug(sb.toString());
			}
		}
	}

	private static class MatchCtx {

		private static ByteMatcher firstByteMatcher = new Utf8FirstByteMatcher();
		private static ByteMatcher otherByteMatcher = new Utf8OtherByteMatcher();
		private int encLength;
		private int require;
		private int found;

		private int maxByteLen = 0;

		private ByteMatcher matcher;

		private StringBuilder sb;

		public MatchCtx() {
			init();
			if (log.isDebugEnabled()) {
				sb = new StringBuilder(1024);
			}
		}

		private void init() {
			this.matcher = firstByteMatcher;
			this.found = 0;
			this.require = 0;
			this.encLength = 0;
		}

		public ByteMatcher matcher() {
			return matcher;
		}

		public void start(int len) {
			this.encLength = len;
			this.require = len - 1;
			this.matcher = otherByteMatcher;
			if (len == 1) {
				if (maxByteLen == 0)
					maxByteLen = 1;
				init();
			}
		}

		public void consume() {
			found++;
			if (found >= require) {
				// switch to next character start
				if (encLength > maxByteLen) {
					maxByteLen = encLength;
				}
				init();
			}
		}

		public int getMaxByteLen() {
			return maxByteLen;
		}

		public void debug(Object... msgs) {
			if (msgs != null) {
				for (Object o : msgs) {
					sb.append(String.valueOf(o));
				}
			}
		}

		@Override
		public String toString() {
			if (log.isDebugEnabled()) {
				return sb.toString();
			}
			return super.toString();
		}
	}

	private static interface ByteMatcher {
		boolean match(byte bt, MatchCtx ctx);
	}

	private static String hex(byte b) {
		return Integer.toHexString(0xFF & b);
	}

	private static class Utf8FirstByteMatcher implements ByteMatcher {
		public boolean match(byte bt, MatchCtx ctx) {
			// if (log.isDebugEnabled()) {
			// log.debug("match first byte " + hex(bt));
			// }
			if (log.isDebugEnabled()) {
				ctx.debug("[0x", hex(bt), " ");
			}
			for (int i = 0; i < Utf8Magic.magicBits.length; i++) {
				// if (log.isDebugEnabled()) {
				// log.debug("magicBits " + hex(Utf8Magic.magicBits[i]));
				// }
				if ((bt & Utf8Magic.maskBits[i]) == Utf8Magic.magicBits[i]) {
					if (log.isDebugEnabled()) {
						ctx.debug(i + 1, ":", hex(Utf8Magic.magicBits[i]));
					}
					ctx.start(i + 1);
					return true;
				}
			}
			if (log.isDebugEnabled()) {
				ctx.debug("^");
			}
			return false;
		}
	}

	private static class Utf8OtherByteMatcher implements ByteMatcher {
		public boolean match(byte bt, MatchCtx ctx) {
			if (log.isDebugEnabled()) {
				ctx.debug(" ", hex(bt));
			}
			if ((bt & Utf8Magic.siblingMask) == Utf8Magic.siblingMagicBits) {
				ctx.consume();
				return true;
			}
			if (log.isDebugEnabled()) {
				ctx.debug("^");
			}
			return false;
		}

	}

	/**
	 * @param bs
	 * @return 如果是utf-8,那么返回最长的utf8码字节数
	 */
	public static int checkUtf8(byte[] bs) {
		MatchCtx ctx = new MatchCtx();
		try {
			for (int i = 0; i < bs.length; i++) {
				byte b = bs[i];
				if (!ctx.matcher().match(b, ctx)) {
					// not utf8
					return 0;
				}
			}
		} finally {
			if (log.isDebugEnabled()) {
				log.debug(ctx);
			}
		}
		return ctx.getMaxByteLen();
	}

	public static String encode(String part) {
		if (part == null)
			return null;
		return URLEncoder.encodeUrl(part);
	}

	private static Map<Character.UnicodeBlock, Boolean> FullWidthBlocks = new HashMap<Character.UnicodeBlock, Boolean>();
	static {
		FullWidthBlocks.put(Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS,
				Boolean.TRUE);
		FullWidthBlocks.put(
				Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A,
				Boolean.TRUE);
		FullWidthBlocks.put(
				Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B,
				Boolean.TRUE);
		FullWidthBlocks.put(
				Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS,
				Boolean.TRUE);
		FullWidthBlocks.put(
				Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT,
				Boolean.TRUE);
		FullWidthBlocks.put(Character.UnicodeBlock.KANBUN, Boolean.TRUE);

		// Radicals and Strokes
		FullWidthBlocks.put(Character.UnicodeBlock.CJK_RADICALS_SUPPLEMENT,
				Boolean.TRUE);
		FullWidthBlocks.put(Character.UnicodeBlock.KANGXI_RADICALS,
				Boolean.TRUE);

		FullWidthBlocks.put(Character.UnicodeBlock.CJK_COMPATIBILITY,
				Boolean.TRUE);// ?
		FullWidthBlocks.put(Character.UnicodeBlock.CJK_COMPATIBILITY_FORMS,
				Boolean.TRUE);// ?

		FullWidthBlocks.put(Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION,
				Boolean.TRUE);
		// Chinese-specific
		FullWidthBlocks.put(Character.UnicodeBlock.BOPOMOFO, Boolean.TRUE);
		FullWidthBlocks.put(Character.UnicodeBlock.BOPOMOFO_EXTENDED,
				Boolean.TRUE);

		// japanese
		FullWidthBlocks.put(Character.UnicodeBlock.HIRAGANA, Boolean.TRUE);
		FullWidthBlocks.put(Character.UnicodeBlock.KATAKANA, Boolean.TRUE);
		FullWidthBlocks.put(
				Character.UnicodeBlock.KATAKANA_PHONETIC_EXTENSIONS,
				Boolean.TRUE);

		// korea
		FullWidthBlocks.put(Character.UnicodeBlock.HANGUL_SYLLABLES,
				Boolean.TRUE);
		FullWidthBlocks.put(Character.UnicodeBlock.HANGUL_JAMO, Boolean.TRUE);
		FullWidthBlocks.put(Character.UnicodeBlock.HANGUL_COMPATIBILITY_JAMO,
				Boolean.TRUE);
	}

	public static boolean isHalfWidth(int codepoint) {
		if (true) {
			return !isFullWidth(codepoint);
		}
		Character.UnicodeBlock ub = null;
		try {
			ub = Character.UnicodeBlock.of(codepoint);
		} catch (Exception e) {
			log.error("cant find a unicode block for " + codepoint, e);
		}
		if (ub != null) {
			if (ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
				//
				if (codepoint >= 0xFF00 && codepoint <= 0xff60) {
					return false;
				} else if (codepoint >= 0xffe0 && codepoint <= 0xffe6) {
					return false;
				} else {
					return true;
				}
			} else if (FullWidthBlocks.containsKey(ub)) {
				return false;
			}
		}
		return true;
	}

	private static int[] fwstarts = new int[] {
			//
			0, 0x00A1, 0x00A4, 0x00A7, 0x00AA, 0x00AD, 0x00B0, 0x00B6, 0x00BC,
			0x00C6, 0x00D0, 0x00D7, 0x00DE, 0x00E6, 0x00E8, 0x00EC, 0x00F0,
			0x00F2, 0x00F7, 0x00FC, 0x00FE, 0x0101, 0x0111, 0x0113, 0x011B,
			0x0126, 0x012B, 0x0131, 0x0138, 0x013F, 0x0144, 0x0148, 0x014D,
			0x0152, 0x0166, 0x016B, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6,
			0x01D8, 0x01DA, 0x01DC, 0x0251, 0x0261, 0x02C4, 0x02C7, 0x02C9,
			0x02CD, 0x02D0, 0x02D8, 0x02DD, 0x02DF, 0x0300, 0x0391, 0x03A3,
			0x03B1, 0x03C3, 0x0401, 0x0410, 0x0451, 0x1100, 0x115F, 0x2010,
			0x2013, 0x2018, 0x201C, 0x2020, 0x2024, 0x2030, 0x2032, 0x2035,
			0x203B, 0x203E, 0x2074, 0x207F, 0x2081, 0x20AC, 0x2103, 0x2105,
			0x2109, 0x2113, 0x2116, 0x2121, 0x2126, 0x212B, 0x2153, 0x215B,
			0x2160, 0x2170, 0x2190, 0x21B8, 0x21D2, 0x21D4, 0x21E7, 0x2200,
			0x2202, 0x2207, 0x220B, 0x220F, 0x2211, 0x2215, 0x221A, 0x221D,
			0x2223, 0x2225, 0x2227, 0x222E, 0x2234, 0x223C, 0x2248, 0x224C,
			0x2252, 0x2260, 0x2264, 0x226A, 0x226E, 0x2282, 0x2286, 0x2295,
			0x2299, 0x22A5, 0x22BF, 0x2312, 0x2329, 0x2460, 0x24EB, 0x2550,
			0x2580, 0x2592, 0x25A0, 0x25A3, 0x25B2, 0x25B6, 0x25BC, 0x25C0,
			0x25C6, 0x25CB, 0x25CE, 0x25E2, 0x25EF, 0x2605, 0x2609, 0x260E,
			0x2614, 0x261C, 0x261E, 0x2640, 0x2642, 0x2660, 0x2663, 0x2667,
			0x266C, 0x266F, 0x273D, 0x2776, 0x2E80, 0x2E9B, 0x2F00, 0x2FF0,
			0x3000, 0x3041, 0x3099, 0x3105, 0x3131, 0x3190, 0x31C0, 0x31F0,
			0x3220, 0x3250, 0x3300, 0x3400, 0x4E00, 0xA000, 0xA490, 0xAC00,
			0xE000, 0xF900, 0xFA30, 0xFA70, 0xFE00, 0xFE30, 0xFE54, 0xFE68,
			0xFF01, 0xFFE0, 0xFFFD, 0x20000, 0x2A6D7, 0x2F800, 0x2FA1E,
			0x30000, 0xE0100, 0xF0000, 0x100000 };
	private static int[] fwends = new int[] {
			//
			0, 0x00A1, 0x00A4, 0x00A8, 0x00AA, 0x00AE, 0x00B4, 0x00BA, 0x00BF,
			0x00C6, 0x00D0, 0x00D8, 0x00E1, 0x00E6, 0x00EA, 0x00ED, 0x00F0,
			0x00F3, 0x00FA, 0x00FC, 0x00FE, 0x0101, 0x0111, 0x0113, 0x011B,
			0x0127, 0x012B, 0x0133, 0x0138, 0x0142, 0x0144, 0x014B, 0x014D,
			0x0153, 0x0167, 0x016B, 0x01CE, 0x01D0, 0x01D2, 0x01D4, 0x01D6,
			0x01D8, 0x01DA, 0x01DC, 0x0251, 0x0261, 0x02C4, 0x02C7, 0x02CB,
			0x02CD, 0x02D0, 0x02DB, 0x02DD, 0x02DF, 0x036F, 0x03A1, 0x03A9,
			0x03C1, 0x03C9, 0x0401, 0x044F, 0x0451, 0x1159, 0x115F, 0x2010,
			0x2016, 0x2019, 0x201D, 0x2022, 0x2027, 0x2030, 0x2033, 0x2035,
			0x203B, 0x203E, 0x2074, 0x207F, 0x2084, 0x20AC, 0x2103, 0x2105,
			0x2109, 0x2113, 0x2116, 0x2122, 0x2126, 0x212B, 0x2154, 0x215E,
			0x216B, 0x2179, 0x2199, 0x21B9, 0x21D2, 0x21D4, 0x21E7, 0x2200,
			0x2203, 0x2208, 0x220B, 0x220F, 0x2211, 0x2215, 0x221A, 0x2220,
			0x2223, 0x2225, 0x222C, 0x222E, 0x2237, 0x223D, 0x2248, 0x224C,
			0x2252, 0x2261, 0x2267, 0x226B, 0x226F, 0x2283, 0x2287, 0x2295,
			0x2299, 0x22A5, 0x22BF, 0x2312, 0x232A, 0x24E9, 0x254B, 0x2573,
			0x258F, 0x2595, 0x25A1, 0x25A9, 0x25B3, 0x25B7, 0x25BD, 0x25C1,
			0x25C8, 0x25CB, 0x25D1, 0x25E5, 0x25EF, 0x2606, 0x2609, 0x260F,
			0x2615, 0x261C, 0x261E, 0x2640, 0x2642, 0x2661, 0x2665, 0x266A,
			0x266D, 0x266F, 0x273D, 0x277F, 0x2E99, 0x2EF3, 0x2FD5, 0x2FFB,
			0x303E, 0x3096, 0x30FF, 0x312C, 0x318E, 0x31B7, 0x31CF, 0x321E,
			0x3243, 0x32FE, 0x33FF, 0x4DB5, 0x9FBB, 0xA48C, 0xA4C6, 0xD7A3,
			0xF8FF, 0xFA2D, 0xFA6A, 0xFAD9, 0xFE19, 0xFE52, 0xFE66, 0xFE6B,
			0xFF60, 0xFFE6, 0xFFFD, 0x2A6D6, 0x2F7FF, 0x2FA1D, 0x2FFFD,
			0x3FFFD, 0xE01EF, 0xFFFFD, 0x10FFFD };
	private static int fwlength = fwstarts.length;

	public static boolean isFullWidth(int codePoint) {
		int top, bottom, current;
		bottom = 0;
		top = fwlength;
		current = top / 2;

		while (top - bottom > 1) {
			if (codePoint >= fwstarts[current]) {
				bottom = current;
			} else {
				top = current;
			}
			current = (top + bottom) / 2;
		}
		// System.out.println("current:" + current);
		if (codePoint <= fwends[current]) {
			return true;
		}
		return false;
	}

	public static int viewUnitLen(String str) {
		if (str == null)
			return 0;
		char ch, chl;
		int cnt = str.length();
		int units = 0;
		int codePoint = 0;
		int i = 0;
		for (i = 0; i < cnt;) {
			ch = str.charAt(i++);
			if (Character.isHighSurrogate(ch)) {
				chl = str.charAt(i++);
				codePoint = Character.toCodePoint(ch, chl);
			} else {
				codePoint = ch;
			}
			if (Utf8Utils.isFullWidth(codePoint)) {
				units++;
			} else {
				// System.out.println("halfwidth:" + ch);
			}
			units++;

		}
		return units;
	}


	public static String toHw(String str) {
		if (str == null) {
			return str;
		}
		int len = str.length();
		StringBuilder sb = new StringBuilder(len);
		char ch;
		boolean lastIsEng = true;
		for (int i = 0; i < len;) {
			ch = str.charAt(i++);
			if ((ch > 0xFF00) && (ch <= 0xFF5E)) {
				// System.out.println("w-- " + ch);
				sb.append((char) (ch - 0xFEE0));
				lastIsEng = true;
			} else if (ch == 0x3002 || ch == 0xFF61) {
				if (lastIsEng) {
					sb.append('.');
				} else {
					sb.append(ch);
				}
			} else {
				// System.out.println("h-- " + ch + ", 0x"
				// + Integer.toString(ch, 16));
				sb.append(ch);
				lastIsEng = false;
			}
		}
		return sb.toString();
	}

	public static String stripb(String str, int len) {
		if (str == null)
			return null;
		str = str.trim();

		char ch, chl;
		int cnt = str.length();
		int bytes = 0;
		int codePoint = 0;
		int i = 0;
		for (i = 0; i < cnt;) {
			ch = str.charAt(i++);
			if (Character.isHighSurrogate(ch)) {
				chl = str.charAt(i++);
				codePoint = Character.toCodePoint(ch, chl);
			} else {
				codePoint = ch;
			}
			if (Utf8Utils.isHalfWidth(codePoint)) {
			} else {
				bytes++;
			}
			bytes++;
			if (bytes >= len) {
				break;
			}
		}
		if (i >= cnt) {
			return str;
		}
		return str.substring(0, i);
	}
}
Mountain_
关注
专栏目录
java对字符串编码转换_(转) Java字符编码转换
weixin_26833939的博客
02-20 2777
JVMJVM启动后，JVM会设置一些系统属性以表明JVM的缺省区域。user.language,user.region,file.encoding等。可以使用System.getProperties()详细查看所有的系统属性。如在英文操作系统(如UNIX)下，可以使用如下属性定义强制指定JVM为中文环境-Dclient.encoding.override=GBK -Dfile.encoding=G...
Java 所有字符串转UTF-8 万能工具类-GetEncode.java
04-04
不需要关心接受的字符串编码是UTF_8还是GBK，还是ios-8859-1，自动转换为utf-8编码格式，无需判断字符串原有编码，用法：//处理编码String newStr = GetEncode.transcode(oldStr);
java判断字符集_Java 常用工具类---- 各种字符集编码判断与转换
weixin_33103961的博客
02-12 233
import java.io.UnsupportedEncodingException;/*** 判断字符编码** @author guyinyihun*/public class CharacterCodingUtil {private final static String ENCODE = "GBK";/*** 判断是否为ISO-8859-1** @return*/public static...
编码检测 和 转换
moyuan
06-18 295
[code="java"]def detect_encode require 'hpricot' require 'open-uri' @doc = open("http://www.baidu.com") { |f| Hpricot(f) } guess_res = NKF.guess(@doc.to_s) case guess_res when NK...
【java】字符串编码检测
XYZ
08-14 999
package com.sim.common; public class EncodeHelper { // ASCII、ISO-8859-1、GB2312、GBK、UTF-8、UTF-16 public static String ENCODING_UTF8 = "UTF-8"; public static String ENCODING_GBK = "GBK"; public st...
java检测字符串的编码_Java中检测字符串的编码格式
weixin_35075655的博客
02-13 130
1　　public static String getEncoding(String str) {2 String encode = "GB2312";3 try {4 if (str.equals(new String(str.getBytes(encode), encode))) {5 String s =...
java获取字符串编码类型代码(导入直接查看结果)
04-17
上述代码会遍历Java支持的所有字符集，并尝试将字符串编码和解码，如果编码和解码后的内容一致，那么这个编码就可能是字符串的原始编码。然而，这种方法并不总是准确，因为可能存在多个编码方式都能正确表示相同的...
Java判断字符串是否含有乱码实例代码
08-26
在Java中，我们可以使用正则表达式来检查字符串中是否包含非字母数字字符，以及使用字符块来判断字符是否为中文。下面是实现这一功能的代码实例： ```java import java.util.regex.Pattern; import java.util.regex...
Java反转字符串和相关字符编码的问题解决
09-05
然而，在处理Java中的字符串时，会涉及到字符编码的问题，特别是当字符串涉及到Unicode编码的字符时。在Java中，字符的编码方式并不是直接以字符形式存储，而是以UTF-16编码形式存储。这意味着一个Unicode字符可能...
java文件字符编码检测和转换
04-10
字符编码检测和转换 附件中：FileEncodeDetector.java 此文件可以检测指定文件的编码格式 public static String getFileEncode(File file) {...｝ 附件中：FileCharsetConverter.java 此文件可以实现两个编码的相互转换 FileCharsetConverter.convert( "gbk/DispatcherHandler.java", "GBK", "UTF-8", new FilenameFilter() { public boolean accept(File dir, String name) { return name.endsWith(".java"); } });
Java设置String字符串编码方法详解
最新发布
07-10
在Java编程语言中，处理字符串编码是至关重要的，因为正确的编码和解码可以确保数据的准确性和一致性。本文将深入探讨Java中设置String字符串编码的方法，帮助开发者更好地理解和使用这些功能。 首先，我们需要理解...
关于java的String的编码的各种情况测试代码
天道酬勤
05-22 740
import java.io.File; import java.io.IOException; import java.io.UnsupportedEncodingException; import java.util.Collection; import javax.xml.bind.DatatypeConverter; import org.apache.commons.io.FileU...
根据字符判断是否需要转码
草根的理想
12-09 1243
最近在进行mysql数据库移植的时候遇到乱码问题，因为原来的数据库编码是latin1的，而新库是utf-8的，移植到新库中的数据中文全部是乱码，解决方法是通过判断字符集页面相应的进行相应的转码，或者是逐个读取表中数据转码后再插入正常的数据。下文是如何进行字符的字符集判断。转载自：http://blog.chinaunix.net/u3/95893/showart_2001787.html 
【java】乱码处理+编码转化+判断字符串编码方式
weixin_33923148的博客
06-30 560
之前有一篇是修改IDE的编码，服务器的编码等处理乱码，但是在所有环境因素上，保证了编码方式之后，也会有前台传递给后台【get方式提交】传递给后台的编码方式是非UTF-8的，也会有例如FTP服务器的编码方式是非UTF-8的，所以需要在程序中代码进行编码方式的转码。 1.第一种方式【java.net.URLDecoder】 String condition = URLDecoder.decode(c...
java 字符编码转换
荷逸的博客
02-27 4866
字符编码是将字符转换为二进制数字的过程，用于计算机的输入、输出和存储。在Java中，字符编码是使用Java编程语言中的Unicode字符集进行处理的。Unicode字符集是一个标准的字符集，它为世界上的每个字符分配了一个唯一的编号，包括拉丁字母、汉字、日语假名等等。
java字符串编码转换
05-30
java字符串编码转换和web中的字符串转换
java 多重_java编码-多重（正常）
weixin_39627144的博客
02-20 86
String ISO = "ISO-8859-1";String UTF = "UTF-8";String GBK = "GBK";String string = "你好";byte[] bytes = string.getBytes(UTF);//1,UTF编码for(byte b : bytes)System.out.print(b + " ");//-28 -67 -96 -27 -91 -...
【java代码段】判段字符串的编码格式并转为UTF-8的编码格式
分享感悟和成长
05-17 5534
//判断字符串的编码格式 public static String getEncoding(String str) { String encode = "GB2312"; try { if (str.equals(new String(str.getBytes(encode), encode)...
Java 正确的做字符串编码转换
热门推荐
随心的专栏
11-11 4万+
原文地址：https://blog.csdn.net/h12kjgj/article/details/73496528 文章目录1.字符串的内部表示2. 乱码如何产生？3.如何正确的将GBK转UTF-8 ? （实际上是unicode转UTF-8)4.UTF-8 转GBK5. getBytes函数的作用 1.字符串的内部表示 字符串在java中统一用unicode表示( 即utf-16 LE) , ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值