자바 에서 byte 와 16 진 문자열 의 상호 변환

자바 에서 byte 는 2 진법 으로 8 자 리 를 차지 한 다 는 것 을 표시 하고 16 진법 의 모든 문 자 는 4 비트 2 진법 으로 표시 해 야 한 다 는 것 을 알 고 있 습 니 다 (23 + 22 + 21 + 20 = 15). 그래서 우 리 는 모든 byte 를 해당 하 는 16 진수 문자 로 바 꿀 수 있 습 니 다. 즉, byte 의 높 은 4 비트 와 낮은 4 비트 를 해당 하 는 16 진수 H 와 L 로 바 꿀 수 있 습 니 다.byte 를 16 진수 문자열 로 변환 한 결과 new String (H) + new String (L) 을 조합 합 니 다.즉 byte 는 16 진법 으로 2 자리 만 차지 한 다 는 것 이다.
같은 이치 에서 반대 되 는 변환 도 두 개의 16 진수 문 자 를 하나의 byte 로 바 꾸 는 것 으로 원 리 는 같다.
이상 의 원리 에 따라 우 리 는 byte [] 배열 을 16 진 문자열 로 바 꿀 수 있 습 니 다. 물론 16 진 문자열 을 byte [] 배열 로 바 꿀 수도 있 습 니 다.
 

     * Convert byte[] to hex string.       byte   int，    Integer.toHexString(int)    16     。
     * @param src byte[] data
     * @return hex string
     */   
    public static String bytesToHexString(byte[] src){
        StringBuilder stringBuilder = new StringBuilder("");
        if (src == null || src.length <= 0) {
            return null;
        }
        for (int i = 0; i < src.length; i++) {
            int v = src[i] & 0xFF;
            String hv = Integer.toHexString(v);
            if (hv.length() < 2) {
                stringBuilder.append(0);
            }
            stringBuilder.append(hv);
        }
        return stringBuilder.toString();
    }
    /**
     * Convert hex string to byte[]
     * @param hexString the hex string
     * @return byte[]
     */
    public static byte[] hexStringToBytes(String hexString) {
        if (hexString == null || hexString.equals("")) {
            return null;
        }
        hexString = hexString.toUpperCase();
        int length = hexString.length() / 2;
        char[] hexChars = hexString.toCharArray();
        byte[] d = new byte[length];
        for (int i = 0; i < length; i++) {
            int pos = i * 2;
            d[i] = (byte) (charToByte(hexChars[pos]) << 4 | charToByte(hexChars[pos + 1]));
        }
        return d;
    }
    /**
     * Convert char to byte
     * @param c char
     * @return byte
     */
     private byte charToByte(char c) {
        return (byte) "0123456789ABCDEF".indexOf(c);
    }

 

public static String bytes2HexString(byte[] b) {
  String ret = "";
  for (int i = 0; i < b.length; i++) {
   String hex = Integer.toHexString(b[ i ] & 0xFF);
   if (hex.length() == 1) {
    hex = '0' + hex;
   }
   ret += hex.toUpperCase();
  }
  return ret;
}

 
자바 에서 byte 가 int 를 변환 할 때 왜 0xff 와 연산 을 합 니까?
이 문 제 를 분석 하기 전에 다음 과 같은 코드 를 보 세 요.

//   byte   16           
public static void printHexString( byte[] b) {  
   for (int i = 0; i < b.length; i++) { 
     String hex = Integer.toHexString(b[i] & 0xFF); 
     if (hex.length() == 1) { 
       hex = '0' + hex; 
     } 
     System.out.print(hex.toUpperCase() ); 
   } 

}

 
위 는 byte [] 를 16 진법 으로 바 꾸 는 문자열 입 니 다. 여기 서 b [i] & 0xFF 는 하나의 byte 와 0xFF 를 연산 한 다음 에 Integer. toHexstring 을 사용 하여 16 진법 문자열 을 얻 었 습 니 다. b [i] & 0xFF 연산 후에 나 온 것 은 여전히 int 임 을 알 수 있 습 니 다. 그렇다면 왜 0xFF 와 연산 을 해 야 합 니까?직접 Integer. toHexString (b [i]);,byte 를 int 로 강하 게 바 꾸 면 안 돼 요?답 은 안 됩 니 다. 그 이 유 는 1. byte 의 크기 는 8bits 이 고 int 의 크기 는 32bits 2. 자바 의 바 이 너 리 는 패 치 형식 을 사용 하기 때 문 입 니 다. 여기 서 컴퓨터 기초 이론 byte 는 하나의 바이트 로 저장 되 어 있 으 며 8 개의 비트, 즉 8 개의 0, 1 을 복습 합 니 다.8 명의 첫 번 째 자 리 는 기호 자리 이 고, 그 러 니까 0000 0001 은 숫자 1 을 뜻 하 는 거 예요. 1000 만 이 대표 하 는 게 - 1. 그래서 정수 가 가장 큰 자리 0111 1111, 즉 숫자 127 입 니 다. 음수 최대 1111 1111, 즉 숫자 - 128 위 에서 말 한 바 이 너 리 원 코드 이지 만 자바 에서 사용 하 는 것 은 패 치 형식 입 니 다. 다음은 패 치 1, 반 코드 가 무엇 인지 소개 합 니 다.        하나의 숫자 가 플러스 라면 그 반 코드 는 원래 코드 와 같다.        하나의 숫자 가 마이너스 라면 기호 위 치 는 1 이 고 나머지 여러분 은 원 코드 를 반대 합 니 다.2. 보충 코드: 넘 침 을 이용 하여 우 리 는 감법 을 덧셈 으로 바 꿀 수 있다.       10 진수 에 대해 서 는 9 에서 5 까지 감법 이 가능 합 니 다.       9－4＝5    4 + 6 = 10, 우 리 는 6 을 4 의 보수 로 할 수 있 기 때문이다.       덧셈 으로 바 꾸 기:       9 + 6 = 15 (고위 1 을 제거 하면 10 을 줄 이 는 것) 5 를 얻는다.       16 진수 에 대해 c 에서 5 까지 감법 할 수 있 습 니 다.       c－7＝5    7 + 9 = 16 은 9 를 7 의 보수 로 하기 때문이다.       덧셈 으로 바 꾸 기:       c + 9 = 15 (고위 1 을 제거 하면 16 을 줄 이 는 것) 5 를 얻 을 수 있다.    컴퓨터 에서 만약 우리 가 1 개의 바이트 로 하나의 수 를 표시 한다 면, 1 개의 바이트 가 8 자리 가 있 고, 8 자리 가 넘 으 면 1 에 들 어 가 며, 메모리 에 있 는 상황 은 (100000000) 이 고, 1 자리 가 버 려 진다.    (1) 하나의 수가 플러스 이면 그의 원래 코드, 반 코드, 보충 코드 가 같다.    (2) 하 나 는 마이너스 이 고 강 한 기호 위 치 는 1 이 며 나머지 여러분 은 원 코드 를 반대 한 다음 에 전체 숫자 에 1 을 추가 합 니 다.    - 1 의 원 코드 는                10000001 - 1 의 반 코드 는?                11111110                                                   + 1 - 1 의 보충 코드 는                111111110 의 원 코드 는                 00000000                 11111111 (플러스 0 과 마이너스 0 의 반 코드 가 같다)                                          +10 의 보충 코드 는               100000000 (선두 의 1 을 버 리 고 0 과 마이너스 의 패 치가 같 습 니 다) Integer. toHexstring 의 인 자 는 int 입 니 다. & 0 xff 를 하지 않 으 면 하나의 byte 가 int 로 바 뀔 때 int 는 32 비트 이 고 byte 는 8 비트 이기 때문에 이 때 는 패 치 를 합 니 다.즉, 0xffffff ff. 그러나 이 수 는 옳지 않 습 니 다. 이런 보 위 는 오 차 를 일 으 킬 수 있 습 니 다.0xff 와 함께 있 으 면 높이 24 비트 가 0 으로 정리 되 고 결 과 는 맞다.자바 의 한 byte 는 그 범 위 는 - 128 ~ 127 이 고 Integer. toHexstring 의 매개 변 수 는 원래 int 입 니 다. & 0xff 를 하지 않 으 면 byte 가 int 로 바 뀔 때 마이너스 에 대해 확장 을 합 니 다. 예 를 들 어 하나의 byte 의 - 1 (즉 0xff) 은 int 의 - 1 (즉 0xff ff ff ff) 로 바 뀔 것 입 니 다. 그러면 바 뀌 는 결 과 는 우리 가 원 하 는 것 이 아 닙 니 다.한편, 0xff 는 기본적으로 성형 이기 때문에 하나의 byte 와 0xff 가 회의 에 참석 하여 먼저 그 byte 를 성형 연산 으로 바 꾸 면 결과 중의 높 은 24 비트 는 항상 0 이 되 기 때문에 결 과 는 항상 우리 가 원 하 는 것 이다.