字符串16进制java
① 字符串怎么转化为16进制 java
publicstaticStringstr2HexStr(Stringstr){
char[]chars="0123456789ABCDEF".toCharArray();
StringBuildersb=newStringBuilder("");
byte[]bs=str.getBytes();
intbit;
for(inti=0;i<bs.length;i++){
bit=(bs[i]&0x0f0)>>4;
sb.append(chars[bit]);
bit=bs[i]&0x0f;
sb.append(chars[bit]);
}
returnsb.toString();
}
② java字符串转16进制
1、写转换函数是必须的，目前Jdk中无现有类。
2、在不同的字符编码当中，汉字的对应的数值或者说编码值不一样，像GBK、Unicode肯定是不一样的。以Java默认的Unicode为例说明问题。
3、 一，得到字符串，
二，遍历每个字符，用char来接收，实为int值，或直接用int也可以。
三，Integer.toHexString(每个字符对应的int值);
四，前缀加个“0x”就可以了。
4、如果是其它类型的话，找到对应的字符和数值对应表就可以了。
不知可否解决问题了。
③ java中如何声明一个十六进制的字符串，或者说，怎么发送一个十六进制数据
static String
toHexString(int i)
以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
可以用这个试试，具体不知道你是什么意思。
④ java 将十进制转换成十六进制字符串
importjava.util.Scanner;
publicclassTentoSixteen{
privatestaticStringBuildersum=newStringBuilder();
privatestaticintrulst;//定义一个结果，记录数与15的与运算结果，求得原数二进制最后四位的值
privatestaticintcount;//若数的二进制不止四位，定义一个数来记录除去后四位的新数，运用递归作用与rulst相同
privatestaticvoidTtoSMethod1(inti){//JDK自带的转化方法
Stringexchanged=Integer.toHexString(i);
System.out.println(exchanged);
}
privatestaticvoidSop(){//将得到的字符串反转
System.out.println(sum.reverse().toString());
}
privatestaticvoidsubim(intrulst){//判断是否超出10，根据十六进制的规则超出10部分由字母ABCDEF代替
if(rulst<10){
sum.append(rulst);
}else{
sum.append((char)('A'+(rulst-10)));//将int强制转换为char
}
}
privatestaticvoidTtoSMethod2(inti){
rulst=i&15;
if(i<(1<<4)&&i>=0){//判断数有多少位，大于0小于16，则转换后打直接印
subim(rulst);
}else{//不止四位的数则用递归来多次运算
count=i>>4;//除去最后四位
subim(rulst);
TtoSMethod2(count);//递归直到count为0止
}
}
publicstaticvoidmain(String[]args){
@SuppressWarnings("resource")
Scannerscan=newScanner(System.in);
System.out.println("请出入一个十进制数:");
intnum=scan.nextInt();
TtoSMethod1(num);//自带方法
TtoSMethod2(num);//自定义方法,可将任意的十进制转化为十六进制
Sop();//输出
}
}
⑤ java怎么把16进制的字符串转化为十进制
toHexString
public static String toHexString(int
i)以十六进制的无符号整数形式返回一个整数参数的字符串表示形式。
如果参数为负，那么无符号整数值为参数加上
232；否则等于该参数。将该值转换为十六进制（基数 16）的无前导 0 的 ASCII 数字字符串。如果无符号数的大小值为零，则用一个零字符 '0'
('\u0030') 表示它；否则，无符号数大小的表示形式中的第一个字符将不是零字符。用以下字符作为十六进制数字：
0123456789abcdef
这些字符的范围是从 '\u0030' 到 '\u0039' 和从 '\u0061' 到 '\u0066'。如果希望得到大写字母，可以在结果上调用
String.toUpperCase() 方法：
Integer.toHexString(n).toUpperCase()
参数：
i
- 要转换成字符串的整数。
返回：
用十六进制（基数 16）参数表示的无符号整数值的字符串表示形式。
// 转化字符串为十六进制编码
public static String toHexString(String s)
{
String str="";
for
(int i=0;i<s.length();i++)
{
int ch = (int)s.charAt(i);
String s4
= Integer.toHexString(ch);
str = str + s4;
}
return str;
}
// 转化十六进制编码为字符串
public static String toStringHex(String s)
{
byte[] baKeyword = new byte[s.length()/2];
for(int i = 0; i <
baKeyword.length; i++)
{
try
{
baKeyword[i] = (byte)(0xff &
Integer.parseInt(s.substring(i*2, i*2+2),16));
}
catch(Exception e)
{
e.printStackTrace();
}
}
try
{
s = new
String(baKeyword, "utf-8");//UTF-16le:Not
}
catch (Exception e1)
{
⑥ 请教JAVA怎么将十六进制转换为字符串，多谢
privatestaticStringhexString="0123456789ABCDEF";
publicstaticvoidmain(String[]args){
System.out.println(encode("中文"));
System.out.println(decode(encode("中文")));
}
/*
*将字符串编码成16进制数字,适用于所有字符（包括中文）
*/
publicstaticStringencode(Stringstr){
//根据默认编码获取字节数组
byte[]bytes=str.getBytes();
StringBuildersb=newStringBuilder(bytes.length*2);
//将字节数组中每个字节拆解成2位16进制整数
for(inti=0;i<bytes.length;i++){
sb.append(hexString.charAt((bytes[i]&0xf0)>>4));
sb.append(hexString.charAt((bytes[i]&0x0f)>>0));
}
returnsb.toString();
}
/*
*将16进制数字解码成字符串,适用于所有字符（包括中文）
*/
publicstaticStringdecode(Stringbytes){
ByteArrayOutputStreambaos=newByteArrayOutputStream(bytes.length()/2);
//将每2位16进制整数组装成一个字节
for(inti=0;i<bytes.length();i+=2)
baos.write((hexString.indexOf(bytes.charAt(i))<<4|hexString
.indexOf(bytes.charAt(i+1))));
returnnewString(baos.toByteArray());
}
亲测可行，支持中文！！！
⑦ Java 16进制字符串转化成十六进制数字
没懂啥意思，可以先将字符串转化为整型，后面有需要了，再将整型转化为16进制的数字
int parseInt = Integer.parseInt("cc", 16);
System.out.println(parseInt);
String hexString = Integer.toHexString(parseInt);
System.out.println(hexString);
⑧ java 怎么用正则表达式判断一个字符串是否为16进制数，且如果包含字母要转为大写
用正则表达式判断一个字符串是否为16进制数的Java程序如下(不知道是不是你想要的)
publicclassAA{
publicstaticvoidmain(String[]args){
Strings="123bf";
Stringregex="^[A-Fa-f0-9]+$";
if(s.matches(regex)){
System.out.println(s.toUpperCase()+"是16进制数");
}else{
System.out.println(s.toUpperCase()+"不是16进制数");
}
}
}运行结果
123BF是16进制数
⑨ 在线等！！！java 如何将字符串转换成十六进制
nt main(void)
4{
5 unsigned char array[4] = ;
6 unsigned long num;
7 num = 0;
8 for(int i=0; i<sizeof(array); i++)
9 {
10 num<<=8;
11 num |= array[i];
12 }
13 printf("num = %d",num);
14 return 0;
15
16}
二进制,字节数组,字符,十六进制,BCD编码转换
* 把16进制字符串转换成字节数组
* @param hex
* @return
*/
public static byte[] hexStringToByte(String hex) {
int len = (hex.length() / 2);
byte[] result = new byte[len];
char[] achar = hex.toCharArray();
for (int i = 0; i < len; i++) {
int pos = i * 2;
result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));
}
return result;
}
private static byte toByte(char c) {
byte b = (byte) "0123456789ABCDEF".indexOf(c);
return b;
}
public static final String bytesToHexString(byte[] bArray) {
StringBuffer sb = new StringBuffer(bArray.length);
String sTemp;
for (int i = 0; i < bArray.length; i++) {
sTemp = Integer.toHexString(0xFF & bArray[i]);
if (sTemp.length() < 2)
sb.append(0);
sb.append(sTemp.toUpperCase());
}
return sb.toString();
}
public static final Object bytesToObject(byte[] bytes) throws IOException, ClassNotFoundException {
ByteArrayInputStream in = new ByteArrayInputStream(bytes);
ObjectInputStream oi = new ObjectInputStream(in);
Object o = oi.readObject();
oi.close();
return o;
}
public static final byte[] objectToBytes(Serializable s) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream ot = new ObjectOutputStream(out);
ot.writeObject(s);
ot.flush();
ot.close();
return out.toByteArray();
}
public static final String objectToHexString(Serializable s) throws IOException{
return bytesToHexString(objectToBytes(s));
}
public static final Object hexStringToObject(String hex) throws IOException, ClassNotFoundException{
return bytesToObject(hexStringToByte(hex));
}
public static String bcd2Str(byte[] bytes){
StringBuffer temp=new StringBuffer(bytes.length*2);
for(int i=0;i<bytes.length;i++){
temp.append((byte)((bytes[i]& 0xf0)>>>4));
temp.append((byte)(bytes[i]& 0x0f));
}
return temp.toString().substring(0,1).equalsIgnoreCase("0")?temp.toString().substring(1):temp.toString();
}
public static byte[] str2Bcd(String asc) {
int len = asc.length();
int mod = len % 2;
if (mod != 0) {
asc = "0" + asc;
len = asc.length();
}
byte abt[] = new byte[len];
if (len >= 2) {
len = len / 2;
}
byte bbt[] = new byte[len];
abt = asc.getBytes();
int j, k;
for (int p = 0; p < asc.length()/2; p++) {
if ( (abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {
j = abt[2 * p] - '0';
} else if ( (abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {
j = abt[2 * p] - 'a' + 0x0a;
} else {
j = abt[2 * p] - 'A' + 0x0a;
}
if ( (abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {
k = abt[2 * p + 1] - '0';
} else if ( (abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {
k = abt[2 * p + 1] - 'a' + 0x0a;
}else {
k = abt[2 * p + 1] - 'A' + 0x0a;
}
int a = (j << 4) + k;
byte b = (byte) a;
bbt[p] = b;
}
return bbt;
}
public static String BCD2ASC(byte[] bytes) {
StringBuffer temp = new StringBuffer(bytes.length * 2);
for (int i = 0; i < bytes.length; i++) {
int h = ((bytes[i] & 0xf0) >>> 4);
int l = (bytes[i] & 0x0f);
temp.append(BToA[h]).append( BToA[l]);
}
return temp.toString() ;
}
public static String MD5EncodeToHex(String origin) {
return bytesToHexString(MD5Encode(origin));
}
public static byte[] MD5Encode(String origin){
return MD5Encode(origin.getBytes());
}
public static byte[] MD5Encode(byte[] bytes){
MessageDigest md=null;
try {
md = MessageDigest.getInstance("MD5");
return md.digest(bytes);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return new byte[0];
}
}
//关于byte: signed byte 把 0x00 ~ 0xff 映射成范围 0~127和 -128~-1 两段,比较简单的办法用 (b+256)%256的办法令其值回到0~255，或者用&0xff并赋给一个int
⑩ 怎么把字符串转化为十六进制字符串 java
思路：用一个初始化为0~9~a~f的字符串数组，也就是一个十六进制对应表，用这个对应表即可算出一个十六进制字符串的数值。
方法如下：
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();
}
调用方法如下：
String str = str2HexStr("asbd");