java加密为什么转16进制，DES加密算法 java实现
大家好，关于java加密为什么转16进制很多朋友都还不太明白，今天小编就来为大家分享关于DES加密算法 java实现的知识，希望对各位有所帮助！
java中16进制转字符串的问题
你代码有问题，看我的。、
packagecom.weixin.util;
importjava.io.ByteArrayOutputStream;
publicclassShiLiuJinZhi{
/**
*@date：2015年5月14日上午10:36:02
*@Description:转化字符串为十六进制编码
*@params
*@return
*/
publicstaticStringtoHexString(Strings){
Stringstr="";
for(inti=0;i<s.length();i++){
intch=(int)s.charAt(i);
Strings4=Integer.toHexString(ch);
str=str+s4;
}
returnstr;
}
/**
*@date：2015年5月14日上午10:35:53
*@Description:转化十六进制编码为字符串
*@params
*@return
*/
publicstaticStringtoStringHex1(Strings){
byte[]baKeyword=newbyte[s.length()/2];
for(inti=0;i<baKeyword.length;i++){
try{
baKeyword[i]=(byte)(0xff&Integer.parseInt(s.substring(
i*2,i*2+2),16));
}catch(Exceptione){
e.printStackTrace();
}
}
try{
s=newString(baKeyword,"utf-8");//UTF-16le:Not
}catch(Exceptione1){
e1.printStackTrace();
}
returns;
}
//转化十六进制编码为字符串
publicstaticStringtoStringHex2(Strings){
byte[]baKeyword=newbyte[s.length()/2];
for(inti=0;i<baKeyword.length;i++){
try{
baKeyword[i]=(byte)(0xff&Integer.parseInt(s.substring(
i*2,i*2+2),16));
}catch(Exceptione){
e.printStackTrace();
}
}
try{
s=newString(baKeyword,"utf-8");//UTF-16le:Not
}catch(Exceptione1){
e1.printStackTrace();
}
returns;
}
publicstaticvoidmain(String[]args){
System.out.println(encode("aaa"));
System.out.println(decode(encode("aaa")));
}
/*
*16进制数字字符集
*/
privatestaticStringhexString="0123456789ABCDEF";
/*
*将字符串编码成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());
}
//第二种方法：
//将指定byte数组以16进制的形式打印到控制台
//复制代码代码如下:
/*publicclassUtil{
publicUtil(){
}
*//**
*将指定byte数组以16进制的形式打印到控制台
*@paramhintString
*@parambbyte[]
*@returnvoid
*//*
publicstaticvoidprintHexString(Stringhint,byte[]b){
System.out.print(hint);
for(inti=0;i<b.length;i++){
Stringhex=Integer.toHexString(b[i]&0xFF);
if(hex.length()==1){
hex='0'+hex;
}
System.out.print(hex.toUpperCase()+"");
}
System.out.println("");
}
*//**
*@parambbyte[]
*@returnString
*//*
publicstaticStringBytes2HexString(byte[]b){
Stringret="";
for(inti=0;i<b.length;i++){
Stringhex=Integer.toHexString(b[i]&0xFF);
if(hex.length()==1){
hex='0'+hex;
}
ret+=hex.toUpperCase();
}
returnret;
}
*//**
*将两个ASCII字符合成一个字节；如："EF"-->0xEF
*@paramsrc0byte
*@paramsrc1byte
*@returnbyte
*//*
publicstaticbyteuniteBytes(bytesrc0,bytesrc1){
byte_b0=Byte.decode("0x"+newString(newbyte[]{src0}))
.byteValue();
_b0=(byte)(_b0<<4);
byte_b1=Byte.decode("0x"+newString(newbyte[]{src1}))
.byteValue();
byteret=(byte)(_b0^_b1);
returnret;
}
*//**
*将指定字符串src，以每两个字符分割转换为16进制形式如："2B44EFD9"-->byte[]{0x2B,0x44,0xEF,0xD9}
*@paramsrcString
*@returnbyte[]
*//*
publicstaticbyte[]HexString2Bytes(Stringsrc){
byte[]ret=newbyte[8];
byte[]tmp=src.getBytes();
for(inti=0;i<8;i++){
ret[i]=uniteBytes(tmp[i*2],tmp[i*2+1]);
}
returnret;
}
}*/
}
DES加密算法 java实现
/*
* DesEncrypt.java
*
* Created on 2007-9-20, 16:10:47
*
* To change this template, choose Tools| Template Manager
* and open the template in the editor.
*/
//思路：因为任意一个字符串，都是由若干字节表示的，每个字节实质就是一个
//有8位的进进制数，
//又因为一个8位二进制数，可用两位16进制字符串表示.
//因此任意一个字符串可以由两位16进制字符串表示。
//而 DES是对8位二进制数进行加密，解密。
//所以用DES加密解密时，可以把加密所得的8位进进制数，转成
//两位16进制数进行保存，传输。
//具体方法：1把一个字符串转成8位二进制数，用DES加密，得到8位二进制数的
//密文
// 2然后把（由1）所得的密文转成两位十六进制字符串
// 3解密时，把（由2)所得的两位十六进制字符串，转换成8位二进制
//数的密文
// 4把子3所得的密文，用DES进行解密，得到8位二进制数形式的明文，
//并强制转换成字符串。
//思考：为什么要通过两位16进制数字符串保存密文呢？
//原因是：一个字符串加密后所得的8位二进制数，通常不再时字符串了，如果
//直接把这种密文所得的8位二进制数强制转成字符串，有许多信息因为异
//常而丢失，导制解密失败。因制要把这个8位二制数，直接以数的形式
//保存下来，而通常是用两位十六进制数表示。
package frelationmainten;
import java.security.Key;
import java.security.SecureRandom;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
/**
*
*使用DES加密与解密,可对byte[],String类型进行加密与解密
*密文可使用String,byte[]存储.
*
*方法:
* void getKey(String strKey)从strKey的字条生成一个Key
*
* String getEncString(String strMing)对strMing进行加密,返回String密文
* String getDesString(String strMi)对strMin进行解密,返回String明文
*
*byte[] getEncCode(byte[] byteS)byte[]型的加密
*byte[] getDesCode(byte[] byteD)byte[]型的解密
*/
public class DesEncrypt{
Key key;
/**
*根据参数生成KEY
*@param strKey
*/
public void getKey(String strKey){
try{
KeyGenerator _generator= KeyGenerator.getInstance("DES");
_generator.init(new SecureRandom(strKey.getBytes()));
this.key= _generator.generateKey();
_generator=null;
}catch(Exception e){
e.printStackTrace();
}
}
/**
*加密String明文输入,String密文输出
*@param strMing
*@return
*/
public String getEncString(String strMing){
byte[] byteMi= null;
byte[] byteMing= null;
String strMi="";
try{
return byte2hex(getEncCode(strMing.getBytes()));
// byteMing= strMing.getBytes("UTF8");
// byteMi= this.getEncCode(byteMing);
// strMi= new String( byteMi,"UTF8");
}
catch(Exception e){
e.printStackTrace();
}
finally{
byteMing= null;
byteMi= null;
}
return strMi;
}
/**
*解密以String密文输入,String明文输出
*@param strMi
*@return
*/
public String getDesString(String strMi){
byte[] byteMing= null;
byte[] byteMi= null;
String strMing="";
try{
return new String(getDesCode(hex2byte(strMi.getBytes())));
// byteMing= this.getDesCode(byteMi);
// strMing= new String(byteMing,"UTF8");
}
catch(Exception e){
e.printStackTrace();
}
finally{
byteMing= null;
byteMi= null;
}
return strMing;
}
/**
*加密以byte[]明文输入,byte[]密文输出
*@param byteS
*@return
*/
private byte[] getEncCode(byte[] byteS){
byte[] byteFina= null;
Cipher cipher;
try{
cipher= Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byteFina= cipher.doFinal(byteS);
}
catch(Exception e){
e.printStackTrace();
}
finally{
cipher= null;
}
return byteFina;
}
/**
*解密以byte[]密文输入,以byte[]明文输出
*@param byteD
*@return
*/
private byte[] getDesCode(byte[] byteD){
Cipher cipher;
byte[] byteFina=null;
try{
cipher= Cipher.getInstance("DES");
cipher.init(Cipher.DECRYPT_MODE, key);
byteFina= cipher.doFinal(byteD);
}catch(Exception e){
e.printStackTrace();
}finally{
cipher=null;
}
return byteFina;
}
/**
*二行制转字符串
*@param b
*@return
*/
public static String byte2hex(byte[] b){//一个字节的数，
//转成16进制字符串
String hs="";
String stmp="";
for(int n= 0; n< b.length; n++){
//整数转成十六进制表示
stmp=(java.lang.Integer.toHexString(b[n]& 0XFF));
if(stmp.length()== 1)
hs= hs+"0"+ stmp;
else
hs= hs+ stmp;
}
return hs.toUpperCase();//转成大写
}
public static byte[] hex2byte(byte[] b){
if((b.length%2)!=0)
throw new IllegalArgumentException("长度不是偶数");
byte[] b2= new byte[b.length/2];
for(int n= 0; n< b.length; n+=2){
String item= new String(b,n,2);
//两位一组，表示一个字节,把这样表示的16进制字符串，还原成一个进制字节
b2[n/2]=(byte)Integer.parseInt(item,16);
}
return b2;
}
public static void main(String[] args){
System.out.println("hello");
DesEncrypt des=new DesEncrypt();//实例化一个对像
des.getKey("aadd");//生成密匙
String strEnc= des.getEncString("云海飞舞云122");//加密字符串,返回String的密文
System.out.println(strEnc);
String strDes= des.getDesString(strEnc);//把String类型的密文解密
System.out.println(strDes);
new DesEncrypt();
}
}
JAVA里16进制和字节数组互转
大括号理的就是一个byte类型的数组,里面是3个byte类型那个的数
public static String stringToHexString(String strPart){
String hexString="";
for(int i= 0; i< strPart.length(); i++){
int ch=(int) strPart.charAt(i);
String strHex= Integer.toHexString(ch);
hexString= hexString+ strHex;
}
return hexString;
}
private static String hexString="0123456789ABCDEF";
/*
*将字符串编码成16进制数字,适用于所有字符（包括中文）
*/
public static String encode(String str)
{
//根据默认编码获取字节数组
byte[] bytes=str.getBytes();
StringBuilder sb=new StringBuilder(bytes.length*2);
//将字节数组中每个字节拆解成2位16进制整数
for(int i=0;i<bytes.length;i++)
{
sb.append(hexString.charAt((bytes[i]&0xf0)>>4));
sb.append(hexString.charAt((bytes[i]&0x0f)>>0));
}
return sb.toString();
}
/*
*将16进制数字解码成字符串,适用于所有字符（包括中文）
*/
public static String decode(String bytes)
{
ByteArrayOutputStream baos=new ByteArrayOutputStream(bytes.length()/2);
//将每2位16进制整数组装成一个字节
for(int i=0;i<bytes.length();i+=2)
baos.write((hexString.indexOf(bytes.charAt(i))<<4|hexString.indexOf(bytes.charAt(i+1))));
return new String(baos.toByteArray());
}
private static byte uniteBytes(byte src0, byte src1){
byte _b0= Byte.decode("0x"+ new String(new byte[]{src0})).byteValue();
_b0=(byte)(_b0<< 4);
byte _b1= Byte.decode("0x"+ new String(new byte[]{src1})).byteValue();
byte ret=(byte)(_b0| _b1);
return ret;
public static byte[] HexString2Bytes(String src)
{
byte[] ret= new byte[6];
byte[] tmp= src.getBytes();
for(int i=0; i<6;++i)
{
ret[i]= uniteBytes(tmp[i*2], tmp[i*2+1]);
}
return ret;
}
这方法就可以互相转,你看看吧
关于java加密为什么转16进制的内容到此结束，希望对大家有所帮助。