java8進制轉16

Ⅰ java 以字元串獲取的數組，怎麼轉成16位字元串

你可以使用以下步驟將字元串 msg 轉換為16進制字元串：

1. 將字元串 msg 轉換為位元組數組，可以使用 Arrays.toString(msg.getBytes())

2. 將位元組數組中每個位元組轉換為 16 進制字元串，可以使用 Integer.toHexString(byteValue)

3. 將轉換後的字元串拼接起來得到最正磨終的纖謹16進制字元串

   例如：

   byte[] bytes = msg.getBytes();

   StringBuilder hexString = new StringBuilder();

   for (byte b : bytes) {

   hexString.append(Integer.toHexString(b & 0xff));

   }

   String result = hexString.toString();

4. 注意：轉換後的字元串可能會有一些前導0,如果需要去掉可以使用 string.replaceFirst("毀清基^0+(?!$)", "")

Ⅱ 誰能提供一個java的純數字加密的方法，要從8位變為16位，生成的加密數據要看起來沒有規律

public class DesUtil {

/** 字元串默認鍵值 */
private static String strDefaultKey = "national";

/** 加密工具 */
private Cipher encryptCipher = null;

/** 解密工具 */
private Cipher decryptCipher = null;

/**
* 將byte數組轉換為表示16進制值的字元串， 如：byte[]{8,18}轉換為：0813， 和public static byte[]
* hexStr2ByteArr(String strIn) 互為可逆的轉換過程
*
* @param arrB
* 需要轉換的byte數組
* @return 轉換後的字元串
* @throws Exception
* 本方法不處理任何異常，所有異常全部拋出
*/
public static String byteArr2HexStr(byte[] arrB) throws Exception {
int iLen = arrB.length;
// 每個byte用兩個字元才能表示，所以字元串的長度是數組長度的兩倍
StringBuffer sb = new StringBuffer(iLen * 2);
for (int i = 0; i < iLen; i++) {
int intTmp = arrB[i];
// 把負數轉換為正數
while (intTmp < 0) {
intTmp = intTmp + 256;
}
// 小於0F的數需要在前啟正則面補0
if (intTmp < 16) {
sb.append("0");
}
sb.append(Integer.toString(intTmp, 16));
}
return sb.toString();
}

/**
* 將表示16進制值的字元串轉換為byte數組， 和public static String byteArr2HexStr(byte[] arrB)
* 互為可逆的轉換過程
*
* @param strIn
* 需要轉換的字元串
* @return 轉換後的byte數組
* @throws Exception
* 本方法不處理任何異常，所有異常全部拋出
* @author <a href="mailto:[email protected]">LiGuoQing</a>
*/
public static byte[] hexStr2ByteArr(String strIn) throws Exception {
byte[] arrB = strIn.getBytes();
int iLen = arrB.length;

// 兩個字元表示一個位元組，所以位元組數組長度是字元串長度除以2
byte[] arrOut = new byte[iLen / 2];
for (int i = 0; i < iLen; i = i + 2) {
String strTmp = new String(arrB, i, 2);
arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
}
return arrOut;
}

/**
* 默認構造方法，使用默認悄棚密鑰
*
* @throws Exception
*/
public DesUtil() throws Exception {
this(strDefaultKey);
}

/**
* 指定清蘆密鑰構造方法
*
* @param strKey
* 指定的密鑰
* @throws Exception
*/
public DesUtil(String strKey) throws Exception {
Security.addProvider(new com.sun.crypto.provider.SunJCE());
Key key = getKey(strKey.getBytes());

encryptCipher = Cipher.getInstance("DES");
encryptCipher.init(Cipher.ENCRYPT_MODE, key);

decryptCipher = Cipher.getInstance("DES");
decryptCipher.init(Cipher.DECRYPT_MODE, key);
}

/**
* 加密位元組數組
*
* @param arrB
* 需加密的位元組數組
* @return 加密後的位元組數組
* @throws Exception
*/
public byte[] encrypt(byte[] arrB) throws Exception {
return encryptCipher.doFinal(arrB);
}

/**
* 加密字元串
*
* @param strIn
* 需加密的字元串
* @return 加密後的字元串
* @throws Exception
*/
public String encrypt(String strIn) throws Exception {
return byteArr2HexStr(encrypt(strIn.getBytes()));
}

/**
* 解密位元組數組
*
* @param arrB
* 需解密的位元組數組
* @return 解密後的位元組數組
* @throws Exception
*/
public byte[] decrypt(byte[] arrB) throws Exception {
return decryptCipher.doFinal(arrB);
}

/**
* 解密字元串
*
* @param strIn
* 需解密的字元串
* @return 解密後的字元串
* @throws Exception
*/
public String decrypt(String strIn) throws Exception {
return new String(decrypt(hexStr2ByteArr(strIn)));
}

/**
* 從指定字元串生成密鑰，密鑰所需的位元組數組長度為8位 不足8位時後面補0，超出8位只取前8位
*
* @param arrBTmp
* 構成該字元串的位元組數組
* @return 生成的密鑰
* @throws java.lang.Exception
*/
private Key getKey(byte[] arrBTmp) throws Exception {
// 創建一個空的8位位元組數組（默認值為0）
byte[] arrB = new byte[8];

// 將原始位元組數組轉換為8位
for (int i = 0; i < arrBTmp.length && i < arrB.length; i++) {
arrB[i] = arrBTmp[i];
}

// 生成密鑰
Key key = new javax.crypto.spec.SecretKeySpec(arrB, "DES");

return key;
}

/**
* main方法 。
*
* @author 劉堯興
* @param args
*/
public static void main(String[] args) {
try {
String test = "asc";
DesUtil des = new DesUtil("abc");// 自定義密鑰
// System.out.println("加密前的字元：" + test);
// System.out.println("加密後的字元：" + des.encrypt(test));
// System.out.println("解密後的字元：" + des.decrypt(des.encrypt(test)));
} catch (Exception e) {
e.printStackTrace();
}
}

}

Ⅲ java實現：整數進制相互轉換

java實現：整數進制相互轉換的方法：

1. 十進制轉為二進制、八進制、十六進制， 用 Integer.toXXXString()方法

   （1）十進制轉為二進制： Integer.toBinaryString(int i);

   public static String toBinaryString(inti)：以二進制（基數 2）無符號整數形式返回一個整數參數的字元串表示形式。

   （2）十進制轉為8進制 ：Integer.toOctalString(int i);
   public static String toOctalString(inti)：以八進制（基數 8）無符號整數形式返回一個整數參數的字元串表示形式。

   （3）十進制轉為16進制: Integer.toHexString(int i);

   public static String toHexString(inti)：以十六進制（基數 16）無符號整數形式返回一個整數參數的字元串表示形式。

舉例：

Stringbin=Integer.toBinaryString(10);
Stringoct=Integer.toOctalString(10);
Stringhex=Integer.toHexString(10);

2.十六進制、八進制、二進制轉為十進制（有兩種方法）:parseInt() 和valueOf()。

Integer.parseInt(String s,int radix);

public static int parseInt(String s,int radix) throws NumberFormatException{}使用第二個參數作為指定的基數，將字元串參數解析為有符號的整數;

Integer.valueOf(String s,int radix);

public static Integer valueOf(Strings, intradix) throws NumberFormatException{}返回一個 Integer 對象，該對象中保存了用第二個參數提供的基數進行解析時從指定的 String 中提取的值。

舉例：

try{
inti=Integer.parseInt("a",16);
//輸出為10進制數10
System.out.println(i);
}catch(Exceptione){
e.printStackTrace();
}
try{
//十六進制轉成十進制
Stringhex=Integer.valueOf("FFFF",16).toString();
System.out.println(hex);
//八進制轉成十進制
Stringoct=Integer.valueOf("12",8).toString();
System.out.println(oct);
//二進制轉十進制
Stringbin=Integer.valueOf("0101",2).toString();
System.out.println(bin);
}catch(Exceptione){
e.printStackTrace();
}