16進数とは｜変換・計算のやり方と0〜255早見表を3言語で実演

2進数を4桁ずつ区切ると16進数の1桁になり、各桁に16の累乗をかけて足すと10進数になります。

flowchart TD
    A[2進数 1111 1010] -->|4桁ずつ区切る| B[1111 と 1010]
    B -->|1組を1文字に| C[16進数 FA]
    C -->|15×16 + 10×1| D[10進数 250]

よく出てくる値の対応です。全部の対応は記事の最後の「0〜255の全対応表」にあります。

10進数	16進数	2進数
10	A	1010
15	F	1111
16	10	1 0000
100	64	110 0100
255	FF	1111 1111
256	100	1 0000 0000
1000	3E8	11 1110 1000
65535	FFFF	1111 1111 1111 1111

確認環境：Ubuntu 24.04.4・Python 3.11.15・OpenJDK 21.0.10・Node.js 22.22.2・bc 1.07.1・xxd（vim 9.1 同梱、2023-10-25 版）・hexdump（util-linux 2.39.3）・od（GNU coreutils 9.4）。この記事の変換・計算・エラー文・ダンプの出力は、すべてこれらで実行して得たものです。関数の仕様は Python のドキュメント、Java SE 21 の API ドキュメント（Integer・HexFormat）、MDN（parseInt・Number.prototype.toString・16進カラー）、各コマンドのマニュアル、UTF-8 は RFC 3629、IPv6 の書き方は RFC 5952、UUID は RFC 9562 で確かめました（確認日 2026年10月22日）。

16進数とは（意味・読み方・A〜Fを使う理由）

この節では、16進数の意味と読み方、なぜアルファベットが混ざるのかが分かります。

16進数（じゅうろくしんすう）は、16になると桁が1つ上がる数の表し方です。 英語では hexadecimal（ヘキサデシマル）、略して hex（ヘックス）と呼びます。ギリシャ語の hexa（6）とラテン語の decimal（10）を合わせた言葉です。

ふだん使う10進数は「0〜9の10個の記号を使い、10で桁が上がる」数え方です。この「何で桁が上がるか」を基数（きすう）と呼びます。2進数は基数2、8進数は基数8、16進数は基数16です。

進数	使う記号	桁が上がるところ	各桁の重み（右から）
2進数	0・1	2	1・2・4・8 …
8進数	0〜7	8	1・8・64・512 …
10進数	0〜9	10	1・10・100・1000 …
16進数	0〜9・A〜F	16	1・16・256・4096 …

A〜Fを使う理由

16進数は1桁で0〜15を表す必要があります。数字は0〜9の10個しかないので、10〜15にアルファベットのA〜Fを当てます。 A=10、B=11、C=12、D=13、E=14、F=15 です。

大文字と小文字はどちらでも同じ値です。FF と ff はどちらも255です。Python・Java・JavaScript の変換関数は、どちらも読み取れました（後の節）。

読み方

数として読むときは、10進数のように「百」「千」とは読まず、1文字ずつ読みます。 たとえば 16進数の 10 は「いちぜろ」と読み、10進数の16です。「じゅう」と読むと10進数の10と混ざります。

16進数・10進数・2進数の対応表（0〜15）

この節では、変換の土台になる0〜15の対応が分かります。この16通りを覚えると、2進数と16進数の変換は表を見るだけでできます。

16進	2進（10進）	16進	2進（10進）
0	0000（0）	8	1000（8）
1	0001（1）	9	1001（9）
2	0010（2）	A	1010（10）
3	0011（3）	B	1011（11）
4	0100（4）	C	1100（12）
5	0101（5）	D	1101（13）
6	0110（6）	E	1110（14）
7	0111（7）	F	1111（15）

16の次は 10、255の次は 100 です。桁が1つ増えるたびに、値は16倍になります。

16進数	10進数	意味
10	16	16が1つ
100	256	16×16 が1つ
1000	4096	16×16×16 が1つ
10000	65536	16の4乗が1つ

16進数を使う理由（2進数4桁が1桁になる）

この節では、コンピューターの世界でなぜ10進数でなく16進数が使われるのかが分かります。

コンピューターの中の値は2進数ですが、2進数は桁が多すぎて人が読み書きしにくいためです。 16は2の4乗なので、2進数の4桁がちょうど16進数の1桁になります。10進数では、この切りのよい対応がありません。

同じ値	書き方	桁数
2進数	1111 1010	8桁
10進数	250	3桁
16進数	FA	2桁

10進数のほうが桁は少なく見えますが、10進数の250から「上位4ビットが1111」と読み取るには計算が要ります。16進数の FA なら、F が上位4ビット・A が下位4ビットと、そのまま読めます。

16進数の書き方（0x・#・U+などの表記一覧）

この節では、文章やコードの中で「これは16進数だ」と示す書き方が分かります。10 が10進数の10なのか16進数の16なのかは、数字だけでは区別できないため、印を付けます。

書き方	例（すべて255か、その並び）	使われる所
0x を前に付ける	0xFF	C・Java・Python・JavaScript など多くの言語
# を前に付ける	#FF8800	CSS・HTML の色
U+ を前に付ける	U+3042	Unicode の文字番号
\x を前に付ける	\xFF	文字列の中の1バイト（C・Python など）
&#x と ; で挟む	あ	HTML・XML の文字参照
% を前に付ける	%E3%81%82	URL エンコード
h を後ろに付ける	0FFh	一部のアセンブリ言語
&H を前に付ける	&HFF	BASIC 系
$ を前に付ける	$FF	一部のアセンブリ言語・Pascal 系
右下に16を書く	(FF)₁₆	教科書・試験

試験の問題文や教科書では、10進数を (255)₁₀、2進数を (1111 1111)₂ のように、右下に基数を小さく書いて区別します。

16進数の変換方法（手計算のやり方）

この節では、電卓やプログラムを使わずに、10進数・2進数・8進数と16進数を行き来する手順が分かります。どれも、後の節でプログラムの結果と一致することを確かめています。

10進数から16進数へ：16で割り続けて、余りを下から読む

10進数の2026を16進数にします。

16 ) 2026
16 )  126 … 10 (A)  ↑
16 )    7 … 14 (E)  ↑ 下から読む
         0 …  7     ↑
→ 7EA

16進数から10進数へ：各桁に16の累乗をかけて足す

16進数の各桁は、右から 1・16・256・4096 の重みを持ちます。7EA なら次のとおりです。

桁	値	重み	かけた結果
7	7	256（16の2乗）	1792
E	14	16（16の1乗）	224
A	10	1（16の0乗）	10
合計			2026

2桁なら「上の桁×16＋下の桁」です。FF は 15×16＋15＝255、A3 は 10×16＋3＝163 です。

2進数から16進数へ：右から4桁ずつ区切る

2進数を右から4桁ずつ区切り、それぞれを0〜15の表で1文字に置き換えます。左端が4桁に足りないときは、左に0を足します。

2進数   1 1111 0100
左に0   0001 1111 0100
置換      1    F    4
→ 16進数 1F4（10進数の500）

16進数から2進数へ：1文字を4桁に戻す

逆は1文字ずつ4桁の2進数に置き換えます。各文字が必ず4桁になるように、0も省かずに書きます。

16進数   3    A    C
2進数   0011 1010 1100

8進数と16進数：2進数を経由する

8進数は1桁が2進数の3桁です。8進数→2進数（3桁ずつ）→4桁ずつ区切り直す→16進数、の順に変換します。

8進数    3   7   7
2進数   011 111 111
区切り直し 1111 1111
16進数    F    F

Linux のファイルの権限 755 などは8進数で書かれます。8進数の書き方と、2進数・16進数との関係はここまでの手順で変換できます。

小数を16進数にする：16をかけて整数部分を取る

10進数の小数は、16をかけて整数部分を取り出すことを繰り返します。

0.1 × 16 = 1.6 → 1
0.6 × 16 = 9.6 → 9
0.6 × 16 = 9.6 → 9（ここから 9 がずっと続く）
→ 0.1999…（16進数）

10進数の0.1は、16進数では割り切れず、無限に続きます。 0.5 は 0.5×16＝8.0 で、16進数の 0.8 と割り切れます。16進数で割り切れるのは、分母が2の累乗の分数（1/2・1/4・1/8 など）だけです。このあと Python と JavaScript で 0.1 を16進数にした結果も、1999… が続いていました。

16進数の計算（足し算・引き算・掛け算）

この節では、16進数どうしの計算の手順が分かります。考え方は10進数の筆算と同じで、「10で繰り上がる」が「16で繰り上がる」に変わるだけです。

足し算：16になったら繰り上がる

    3 A
  + 2 F
  -----
    6 9

1. 右の桁：A＋F は 10＋15＝25。25は16を1つ超えて9余るので、9 を書いて1繰り上がる。
2. 左の桁：3＋2＋繰り上がり1＝6。
3. 答えは 69（10進数の105。58＋47＝105 と一致）。

FF + 1 は、右の桁が F＋1＝16 で 0 繰り上がり、左の桁も F＋1＝16 で 0 繰り上がり、100 になります。

引き算：引けないときは16を借りる

    A 3
  - 5 C
  -----
    4 7

1. 右の桁：3 から C（12）は引けないので、左の桁から16を借りる。16＋3−12＝7。
2. 左の桁：借りたので A（10）は9になる。9−5＝4。
3. 答えは 47（10進数の71。163−92＝71 と一致）。

掛け算・割り算

掛け算は、1桁どうしの結果を16進数に直します。F×F は 15×15＝225 で、225＝14×16＋1 なので E1 です。

16進数の 10（＝16）で割る・かけるのは、桁をずらすだけです。 10進数で10をかけると0が1つ増えるのと同じです。

計算	答え	10進数で見ると
3A ＋ 2F	69	58 ＋ 47 ＝ 105
FF ＋ 1	100	255 ＋ 1 ＝ 256
A3 − 5C	47	163 − 92 ＝ 71
100 − 1	FF	256 − 1 ＝ 255
F × F	E1	15 × 15 ＝ 225
1F × 10	1F0	31 × 16 ＝ 496
7EA ÷ 10	7E 余り A	2026 ÷ 16 ＝ 126 余り 10

Python で同じ計算をすると、表の答えと一致しました。0x を付けて書くと16進数のまま計算できます。

print(hex(0x3A + 0x2F), hex(0xFF + 0x01), hex(0x100 - 0x01), hex(0xA3 - 0x5C))
print(hex(0xF * 0xF), hex(0x7EA // 0x10), hex(0x7EA % 0x10), hex(0x1F * 0x10))

0x69 0x100 0xff 0x47
0xe1 0x7e 0xa 0x1f0

シェルの bc でも、obase=16（出力を16進数）と ibase=16（入力を16進数）で計算できます。ibase=16 のときは、16進数の英字を大文字で書きます。

$ echo 'obase=16; 2026' | bc
7EA
$ echo 'ibase=16; 7EA' | bc
2026

プログラムで16進数に変換する（Python・Java・JavaScript）

この節では、3つの言語とシェルで、10進数⇔16進数、文字列⇔バイト列を変換する書き方と、その実行結果が分かります。

やりたいこと	Python	Java	JavaScript
数 → 16進の文字列	format(255, 'x')	Integer.toHexString(255)	(255).toString(16)
16進の文字列 → 数	int('ff', 16)	Integer.parseInt("ff", 16)	parseInt('ff', 16)
2桁・大文字にそろえる	format(10, '02X')	String.format("%02X", 10)	.toString(16).toUpperCase().padStart(2, '0')
バイト列 → 16進の文字列	b.hex()	HexFormat.of().formatHex(b)	Buffer.from(b).toString('hex')（Node.js）
16進の文字列 → バイト列	bytes.fromhex('e381')	HexFormat.of().parseHex("e381")	Buffer.from('e381', 'hex')（Node.js）

Python

# 10進 → 16進
print(hex(255))              # 0x 付きの小文字
print(format(255, 'x'))      # 0x なし
print(format(255, '02X'))    # 大文字・2桁
print(f"{10:#06x}")          # 0x 付き・4桁
print(f"{3054:X}")
# 16進 → 10進
print(int('ff', 16))
print(int('0xFF', 16))       # 0x 付きも読める
print(int('0xff', 0))        # 0 は接頭辞から判断
print(0x7EA)                 # リテラル
# 2進・8進
print(bin(0xFF), oct(0xFF))
print(int('1111_1111', 2))
print(format(0xA5, '08b'))

0xff
ff
FF
0x000a
BEE
255
255
255
2026
0b11111111 0o377
255
10100101

• hex() は常に 0x 付きの小文字です。付けたくないときや大文字にしたいときは format() か f文字列を使います。Python のドキュメントにも、この3通りの書き方が並べてあります。
• int(文字列, 16) は、0x 付きの文字列も読めます。基数に 0 を渡すと、0x・0b・0o の接頭辞から基数を決めます。
• f"{10:#06x}" の 06 は「0x を含めて6文字」です。0x000a のように、0x の2文字の分だけ数字の桁が減ります。

文字列とバイト列の変換です。

s = 'あA'
print(s.encode('utf-8').hex())          # バイト列 → 16進文字列
print(s.encode('utf-8').hex(' '))       # 1バイトずつ空白で区切る
print(bytes.fromhex('e3 81 82 41').decode('utf-8'))
print(f"U+{ord('あ'):04X}", chr(0x3042))

e3818241
e3 81 82 41
あA
U+3042 あ

Java

import java.util.HexFormat;
import java.nio.charset.StandardCharsets;

public class Hex {
    public static void main(String[] args) {
        // 10進 → 16進
        System.out.println(Integer.toHexString(255));          // ff
        System.out.println(String.format("%02X", 10));         // 0A
        System.out.println(String.format("%#x", 255));         // 0xff
        System.out.println(Long.toHexString(4294967296L));     // 100000000
        // 16進 → 10進
        System.out.println(Integer.parseInt("ff", 16));        // 255
        System.out.println(Integer.decode("0x7EA"));           // 2026
        System.out.println(0x7EA);                             // リテラル
        // 2進
        System.out.println(Integer.toBinaryString(0xA5));
        System.out.println(Integer.parseInt("10100101", 2));
        // バイト列（Java 17 以降の HexFormat）
        byte[] b = "あA".getBytes(StandardCharsets.UTF_8);
        System.out.println(HexFormat.of().formatHex(b));
        System.out.println(HexFormat.ofDelimiter(" ").withUpperCase().formatHex(b));
        System.out.println(new String(HexFormat.of().parseHex("e3818241"), StandardCharsets.UTF_8));
    }
}

ff
0A
0xff
100000000
255
2026
2026
10100101
165
e3818241
E3 81 82 41
あA

• Integer.parseInt(文字列, 16) は 0x 付きの文字列を読めません（後の「よくある間違い」）。0x や # が付いた文字列は Integer.decode() で読みます。API ドキュメントでは、decode が受け付ける接頭辞は 0x・0X・#・0（8進数）です。
• HexFormat は Java 17 で入ったクラスです。区切り文字・大文字・接頭辞を指定して、バイト列と16進の文字列を変換できます。

JavaScript

// 10進 → 16進
console.log((255).toString(16));                    // 'ff'
console.log((10).toString(16).toUpperCase().padStart(2, '0')); // '0A'
// 16進 → 10進
console.log(parseInt('ff', 16), parseInt('0xff', 16), Number('0xff'), 0x7ea);
// 途中で止まる・読めない
console.log(parseInt('1F'), parseInt('1F', 16), Number('1F'), parseInt('g', 16));
// 2進
console.log((0xa5).toString(2), parseInt('10100101', 2));
// 文字列 ↔ バイト列
const bytes = new TextEncoder().encode('あA');
console.log(Array.from(bytes, b => b.toString(16).padStart(2, '0')).join(' '));
console.log('あ'.codePointAt(0).toString(16), String.fromCodePoint(0x3042));
// 大きい数
console.log((2 ** 53 + 1).toString(16), (2n ** 53n + 1n).toString(16), 0xffffffffffffffffn);

ff
0A
255 255 255 2026
1 31 NaN NaN
10100101 165
e3 81 82 41
3042 あ
20000000000000 20000000000001 18446744073709551615n

• parseInt('1F') は基数を省くと 1 になります。 10進数として読み、F で読むのを止めるためです。MDN にも「有効な数字ではない文字を見つけた場合、その文字とそれ以降のすべての文字を無視」とあります。16進数を読むときは、基数の 16 を必ず書きます。
• Number('0xff') は 0x 付きなら読めますが、Number('1F') は NaN です。
• 2の53乗を超えると、Number では1刻みの整数を正しく表せません。 2の53乗＋1 を16進数にすると末尾が 0 になり、1が消えました。大きい値は BigInt（末尾に n）を使います。

Node.js では Buffer でも変換できます。

$ node -e "console.log(Buffer.from('あA').toString('hex'), Buffer.from('e3818241','hex').toString())"
e3818241 あA

シェル（printf・bash の算術展開）

$ printf '%x\n' 255
ff
$ printf '%X\n' 2026
7EA
$ printf '%02x\n' 10
0a
$ printf '%d\n' 0xff
255
$ echo $((16#ff)) $((0x7EA)) $((2#11111111))
255 2026 255

$((16#ff)) は「16進数の ff」を意味する bash・zsh の書き方です。

16進数でビットを取り出す（マスク）

16進数は、決まったビットだけを取り出す「マスク」を書くときにもよく使います。0xFF は「下位8ビットがすべて1」です。

x = 0x12345678
print(hex((x >> 8) & 0xFF))   # 右に8ビットずらして、下位8ビットを取り出す

0x56

ビット演算の書き方は、関連記事「Javaビット演算入門|シフト演算>>と>>>の違いとフラグ管理」で扱っています。

16進数が使われる場面（色コード・文字コード・ダンプ・アドレス・ハッシュ値）

この節では、16進数が実際にどこに出てくるのかを、その場で出した実物で確かめます。

色コード（#RRGGBB）

CSS の色 #FF8800 は、FF（赤）・88（緑）・00（青）の3つに分かれ、それぞれが 0〜255 の強さです。

c = 'FF8800'
print(tuple(int(c[i:i+2], 16) for i in (0, 2, 4)))
print('#{:02X}{:02X}{:02X}'.format(255, 136, 0))

(255, 136, 0)
#FF8800

MDN によると、16進カラーには #RGB・#RGBA・#RRGGBB・#RRGGBBAA の4つの書き方があり、大文字と小文字は区別されません。#f09 のような3桁は、各桁を2つ重ねた #ff0099 と同じです。後ろに2桁足した AA は透明度で、00 が完全に透明、ff が完全に不透明です。1色が2桁で256段階なので、組み合わせは 256×256×256＝16,777,216 色です。

CSS での色の書き方全般は、関連記事「CSSの色指定まとめ｜rgb・hsl・カラーコードと透明度の書き方」で扱っています。

文字コード（U+3042 と UTF-8 のバイト）

Unicode では、すべての文字に16進数の番号が振られています。「あ」は U+3042 です。ファイルに保存するときは、文字コード（符号化方式）によってバイトの並びが変わります。

print('あ'.encode('utf-8').hex(' '))
print('あ'.encode('shift_jis').hex(' '))
print('あ'.encode('utf-16-be').hex(' '))

e3 81 82
82 a0
30 42

文字コード	「あ」のバイト	バイト数
Unicode の番号	U+3042	―
UTF-8	E3 81 82	3
Shift_JIS	82 A0	2
UTF-16（ビッグエンディアン）	30 42	2

UTF-8 の E3 81 82 は、U+3042 のビットを決まった型にはめて作られます。RFC 3629 の表では、U+0800〜U+FFFF の文字は 1110xxxx 10xxxxxx 10xxxxxx の3バイトです。

flowchart TD
    A[U+3042] --> B[2進数<br>0011 0000 0100 0010]
    B --> C[4・6・6ビットに分ける<br>0011 / 000001 / 000010]
    C --> D[型に入れる<br>11100011 10000001 10000010]
    D --> E[16進数 E3 81 82]

文字コードの違いとサロゲートペアは、関連記事「UnicodeとUTF-8の違いとは？UTF-16・サロゲートペアまで実行結果で理解」で扱っています。

ファイルの中身を16進数で見る（xxd・hexdump・od）

「あいA」と改行を UTF-8 で保存したファイル（8バイト）を、3つのコマンドで見ました。

$ printf 'あいA\n' > a.txt
$ xxd a.txt
00000000: e381 82e3 8184 410a                      ......A.
$ hexdump -C a.txt
00000000  e3 81 82 e3 81 84 41 0a                           |......A.|
00000008
$ od -An -tx1 a.txt
 e3 81 82 e3 81 84 41 0a

コマンド	1行の形	補足
xxd	位置・2バイトずつの16進・文字	-p で16進だけ、-r で元に戻す
hexdump -C	位置・1バイトずつの16進・縦線で囲んだ文字	1バイトずつで読みやすい
od -An -tx1	1バイトずつの16進だけ	-An で位置を出さない

いちばん左の 00000000 は、ファイルの先頭から何バイト目かを16進数で表した位置です。右端の . は、文字として表示できないバイトです（日本語の各バイトもここでは . になります）。

xxd -p で16進数だけを出し、xxd -r -p で16進数からバイトに戻せます。

$ xxd -p a.txt
e38182e38184410a
$ echo 'e3818241' | xxd -r -p
あA

ファイルの種類は、先頭の数バイト（マジックナンバー）で分かります。 実行ファイル（ELF）は 7f 45 4c 46、PNG 画像は 89 50 4e 47 で始まっていました。45 4c 46 は文字の「ELF」、50 4e 47 は「PNG」です。

$ xxd -l 16 /bin/ls
00000000: 7f45 4c46 0201 0100 0000 0000 0000 0000  .ELF............
$ xxd -l 16 orange.png
00000000: 8950 4e47 0d0a 1a0a 0000 000d 4948 4452  .PNG........IHDR

メモリアドレス

プログラムが使うメモリの番地も16進数で表示されます。Python（CPython）の id() は、ドキュメントにある実装の詳細のとおり、オブジェクトのメモリ上の番地を返します。

$ python3 -c "x=[1,2,3]; print(hex(id(x))); print(object())"
0x7f725b7f9800
<object object at 0x7f725b784190>

プロセスのメモリの配置（/proc/self/maps）も、番地の範囲が16進数で並びます。

00400000-0041f000 r--p 00000000 fe:00 233879                             /usr/bin/python3.11

MAC アドレス・IPv6 アドレス

ネットワーク機器の MAC アドレスは6バイト（48ビット）で、1バイトずつ2桁の16進数をコロンでつなぎます。

$ ip -br link
lo               UNKNOWN        00:00:00:00:00:00 <LOOPBACK,UP,LOWER_UP>
eth0             UP             02:fc:00:00:00:01 <BROADCAST,MULTICAST,UP,LOWER_UP>

IPv6 アドレスは128ビットを16ビット（16進数4桁）ずつ8つに区切って書きます。RFC 5952 は、各区切りの先頭の0を省き、英字は小文字で書くと決めています。Python の ipaddress で書き直すと、その形になりました。

>>> a = ipaddress.ip_address('2001:0DB8:0000:0000:0000:0000:0000:0001')
>>> print(a, a.exploded)
2001:db8::1 2001:0db8:0000:0000:0000:0000:0000:0001

ハッシュ値・UUID

ファイルのハッシュ値も16進数で表示されます。hello と改行の6バイトのファイルから計算すると、SHA-256 は64桁、MD5 は32桁でした。1桁が4ビットなので、256ビット÷4＝64桁、128ビット÷4＝32桁です。

$ printf 'hello\n' > h.txt
$ sha256sum h.txt
5891b5b522d5df086d0ff0b110fbd9d21bb4fc7163af34d08286a2e846f6be03  h.txt
$ md5sum h.txt
b1946ac92492d2347c6235b4d2611184  h.txt

UUID は 128ビットで、RFC 9562 では 8-4-4-4-12 桁の16進数をハイフンでつなぐ形です。

$ python3 -c "import uuid; print(uuid.uuid4())"
deec72a1-5236-4cad-8e1e-b822be2132c5

ハッシュ値の計算は、関連記事「Python hashlibの使い方｜SHA256・MD5とファイルのハッシュ値」で扱っています。

負の数と2の補数（16進数のマイナス）

この節では、16進数でマイナスの値がどう表されるか、FF が255なのか−1なのかの見分け方が分かります。

紙の上では、16進数のマイナスも10進数と同じく -FF のように - を付けて書きます。Python の hex(-1) は -0x1、JavaScript の (-0xff).toString(16) は -ff を返しました。

一方、コンピューターの中の整数は - の記号を持てないので、「2の補数」という決まりで負の数を表します。 8ビットなら、00〜7F を 0〜127、80〜FF を −128〜−1 に割り当てます。

同じ1バイトを、符号なしと符号ありで読んだ結果です（Python の int.from_bytes で確かめました）。

16進数（8ビット）	符号なし	符号あり（2の補数）
00	0	0
01	1	1
7F	127	127
80	128	−128
81	129	−127
FB	251	−5
FE	254	−2
FF	255	−1

2の補数の求め方

−5 を8ビットの2の補数にします。やり方は2通りあり、どちらも FB になります。

1. ビットを反転して1を足す：5 は 0000 0101。反転すると 1111 1010。1を足すと 1111 1011＝FB。
2. 256 から引く：256 − 5 ＝ 251 ＝ FB。8ビットなら 2の8乗＝256 から、32ビットなら 2の32乗 から引きます。

print(format(5, '08b'), format(~5 & 0xFF, '08b'), format((~5 + 1) & 0xFF, '08b'), hex((~5 + 1) & 0xFF), 256 - 5)

00000101 11111010 11111011 0xfb 251

言語ごとの負の数の16進表示

コード	結果	何が起きたか
Python hex(-1)	-0x1	符号付きで表示（2の補数にしない）
Python hex(-1 & 0xFF)	0xff	下位8ビットだけ取り出すと2の補数になる
Java Integer.toHexString(-1)	ffffffff	32ビットの2の補数で表示
JavaScript (-1).toString(16)	-1	符号付きで表示
JavaScript (-1 >>> 0).toString(16)	ffffffff	符号なし32ビットにしてから表示

Java の API ドキュメントでは、toHexString は負の数に 2の32乗 を足した符号なしの値を表示します。MDN では、JavaScript の toString は負の数の符号を残し、2の補数ではない、と書かれています。

16進数の文字列を「符号ありの値」として読み戻す方法です。

print(int.from_bytes(bytes.fromhex('ff'), 'big', signed=True))
print(int.from_bytes(bytes.fromhex('80000000'), 'big', signed=True))
print((-128).to_bytes(1, 'big', signed=True).hex())

-1
-2147483648
80

Java では byte x = (byte) 0xFF; と書くと x は −1 になり、(int) Long.parseLong("ffffffff", 16) は −1 になりました。

桁あふれ（オーバーフロー）

この節では、決まったビット数の入れ物に入りきらない値を入れたとき、16進数で何が起きるかが分かります。

8ビットの FF に1を足すと 100 になりますが、8ビットには下の2桁 00 しか入らないので、結果は0になります。 上に出た1は捨てられます。これが桁あふれ（オーバーフロー）です。

  FF   (1111 1111)
+ 01   (0000 0001)
----
 100   (1 0000 0000) → 8ビットに入るのは 00

入れ物	計算	結果	確かめたコード
符号なし8ビット	0xFF + 1	0	Python ctypes.c_uint8(0xFF+1).value
符号あり8ビット	0x7F + 1	−128	Java byte y = (byte) 0x7F; y++;
符号あり32ビット	0x7FFFFFFF + 1	−2147483648	Java の int・JS のビット演算
符号なし8ビット（JS）	256 を入れる	0	new Uint8Array([256])[0]
Python の int	0xFFFFFFFF + 1	0x100000000	Python の int は桁あふれしない

Java の実行結果です。0x7FFFFFFF（int の最大値）に1を足すと、16進数では 80000000、10進数では最小値の −2147483648 になりました。

int max = 0x7FFFFFFF;
System.out.println(max + 1);
System.out.println(Integer.toHexString(max + 1));
byte y = (byte) 0x7F; y++;
System.out.println(y);

-2147483648
80000000
-128

最大値は16進数で覚えると分かりやすくなります。 符号ありの最大値は「先頭が7で、あとはF」（7F・7FFF・7FFFFFFF）、最小値は「先頭が8で、あとは0」（80・8000・80000000）です。Java の型ごとの範囲は、関連記事「Javaデータ型一覧｜基本型8種の範囲・最大値とオーバーフロー」で扱っています。

よくある間違いとエラーの直し方

この節では、16進数を扱うときに出やすいエラーの原文と、その直し方が分かります。すべて実際に出たメッセージです。

エラー・結果（原文）	書いたコード	直し方
ValueError: invalid literal for int() with base 10: '0xff'	Python int('0xff')	基数を書く：int('0xff', 16) か int('0xff', 0)
ValueError: invalid literal for int() with base 16: 'fg'	Python int('fg', 16)	0〜9・A〜F 以外の文字を除く
ValueError: non-hexadecimal number found in fromhex() arg at position 3	Python bytes.fromhex('abc')	桁数を偶数にする（'0abc'）
OverflowError: int too big to convert	Python (255).to_bytes(1, 'big', signed=True)	符号ありの1バイトは127まで。signed=False にする
NumberFormatException: For input string: "0xff" under radix 16	Java Integer.parseInt("0xff", 16)	Integer.decode("0xff") を使う
NumberFormatException: For input string: "ffffffff" under radix 16	Java Integer.parseInt("ffffffff", 16)	Integer.parseUnsignedInt か Long.parseLong
IllegalArgumentException: string length not even: 3	Java HexFormat.of().parseHex("abc")	桁数を偶数にする
NaN	JS Number('1F')・parseInt('g', 16)	parseInt(文字列, 16) を使い、文字を確かめる

Java で byte を16進数にすると ffffffff になる

byte x = (byte) 0xFF;
System.out.println(x);                                 // -1
System.out.println(Integer.toHexString(x));            // ffffffff
System.out.println(Integer.toHexString(x & 0xFF));     // ff
System.out.println(HexFormat.of().toHexDigits(x));     // ff

-1
ffffffff
ff
ff

hexdump と od で、バイトの順番が入れ替わって見える

同じ a.txt を、オプションなしの hexdump と od -x で見ると、2バイトずつ前後が入れ替わって表示されました。

$ hexdump a.txt
0000000 81e3 e382 8481 0a41
0000008
$ od -x a.txt
0000000 81e3 e382 8481 0a41
0000010

ファイルの先頭は e3 81 なのに、81e3 と出ています。2バイトを1つの数として、この CPU（x86-64、リトルエンディアン）の並びで読んでいるためです。 hexdump のマニュアルには、オプションなしは -x（2バイト単位の16進表示）に近い形とあります。1バイトずつ見るときは hexdump -C か od -An -tx1 か xxd を使います。

もう1つの注意は、od の左端の位置は8進数だということです。 8バイトのファイルの終わりが、hexdump では 0000008、od では 0000010 と出ました。od の 10 は8進数の8です。

リトルエンディアンとビッグエンディアンの違いは、Python の struct で見えます。

import struct
print(struct.pack('<I', 0x12345678).hex(' '), struct.pack('>I', 0x12345678).hex(' '))

78 56 34 12 12 34 56 78

間違えやすい点のチェック

• 116進数の 10 を「じゅう」と読んでいないか16進数の 10 は10進数の16
• 2先頭の0が消えていないか10 を16進数にすると a。2桁にそろえるなら format(10, '02x')
• 3基数を省いていないかJS の parseInt('1F') は 1。parseInt('1F', 16) で 31
• 4符号ありの型で 0x80 以上を扱っていないかJava の byte の 0xFF は −1。& 0xFF で直す
• 52進数を左から4桁ずつ区切っていないか区切りは右から。左端が足りなければ0を足す
• 6文字コードを取り違えていないか「あ」は UTF-8 で e3 81 82、Shift_JIS で 82 a0

文字列を数に変える関数の違い全般は、関連記事「JavaScript文字列→数値変換｜parseIntとNumberの違い一覧表」で扱っています。

0〜255の16進数・10進数・2進数 全対応表

この節は、1バイトで表せる0〜255のすべての値の対応表です。

早見の格子（16進数 → 10進数）

行が16進数の上の桁、列が下の桁です。たとえば A5 は「A_ の行」と「_5 の列」が交わる 165 です。

      _0  _1  _2  _3  _4  _5  _6  _7  _8  _9  _A  _B  _C  _D  _E  _F
0_     0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
1_    16  17  18  19  20  21  22  23  24  25  26  27  28  29  30  31
2_    32  33  34  35  36  37  38  39  40  41  42  43  44  45  46  47
3_    48  49  50  51  52  53  54  55  56  57  58  59  60  61  62  63
4_    64  65  66  67  68  69  70  71  72  73  74  75  76  77  78  79
5_    80  81  82  83  84  85  86  87  88  89  90  91  92  93  94  95
6_    96  97  98  99 100 101 102 103 104 105 106 107 108 109 110 111
7_   112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
8_   128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
9_   144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159
A_   160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
B_   176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
C_   192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207
D_   208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
E_   224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
F_   240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255

10進数・16進数・2進数の一覧

DEC が10進数、HX が16進数、BINARY が2進数（8桁）です。

 DEC HX  BINARY   |  DEC HX  BINARY   |  DEC HX  BINARY   |  DEC HX  BINARY  
   0 00  00000000 |   64 40  01000000 |  128 80  10000000 |  192 C0  11000000
   1 01  00000001 |   65 41  01000001 |  129 81  10000001 |  193 C1  11000001
   2 02  00000010 |   66 42  01000010 |  130 82  10000010 |  194 C2  11000010
   3 03  00000011 |   67 43  01000011 |  131 83  10000011 |  195 C3  11000011
   4 04  00000100 |   68 44  01000100 |  132 84  10000100 |  196 C4  11000100
   5 05  00000101 |   69 45  01000101 |  133 85  10000101 |  197 C5  11000101
   6 06  00000110 |   70 46  01000110 |  134 86  10000110 |  198 C6  11000110
   7 07  00000111 |   71 47  01000111 |  135 87  10000111 |  199 C7  11000111
   8 08  00001000 |   72 48  01001000 |  136 88  10001000 |  200 C8  11001000
   9 09  00001001 |   73 49  01001001 |  137 89  10001001 |  201 C9  11001001
  10 0A  00001010 |   74 4A  01001010 |  138 8A  10001010 |  202 CA  11001010
  11 0B  00001011 |   75 4B  01001011 |  139 8B  10001011 |  203 CB  11001011
  12 0C  00001100 |   76 4C  01001100 |  140 8C  10001100 |  204 CC  11001100
  13 0D  00001101 |   77 4D  01001101 |  141 8D  10001101 |  205 CD  11001101
  14 0E  00001110 |   78 4E  01001110 |  142 8E  10001110 |  206 CE  11001110
  15 0F  00001111 |   79 4F  01001111 |  143 8F  10001111 |  207 CF  11001111
  16 10  00010000 |   80 50  01010000 |  144 90  10010000 |  208 D0  11010000
  17 11  00010001 |   81 51  01010001 |  145 91  10010001 |  209 D1  11010001
  18 12  00010010 |   82 52  01010010 |  146 92  10010010 |  210 D2  11010010
  19 13  00010011 |   83 53  01010011 |  147 93  10010011 |  211 D3  11010011
  20 14  00010100 |   84 54  01010100 |  148 94  10010100 |  212 D4  11010100
  21 15  00010101 |   85 55  01010101 |  149 95  10010101 |  213 D5  11010101
  22 16  00010110 |   86 56  01010110 |  150 96  10010110 |  214 D6  11010110
  23 17  00010111 |   87 57  01010111 |  151 97  10010111 |  215 D7  11010111
  24 18  00011000 |   88 58  01011000 |  152 98  10011000 |  216 D8  11011000
  25 19  00011001 |   89 59  01011001 |  153 99  10011001 |  217 D9  11011001
  26 1A  00011010 |   90 5A  01011010 |  154 9A  10011010 |  218 DA  11011010
  27 1B  00011011 |   91 5B  01011011 |  155 9B  10011011 |  219 DB  11011011
  28 1C  00011100 |   92 5C  01011100 |  156 9C  10011100 |  220 DC  11011100
  29 1D  00011101 |   93 5D  01011101 |  157 9D  10011101 |  221 DD  11011101
  30 1E  00011110 |   94 5E  01011110 |  158 9E  10011110 |  222 DE  11011110
  31 1F  00011111 |   95 5F  01011111 |  159 9F  10011111 |  223 DF  11011111
  32 20  00100000 |   96 60  01100000 |  160 A0  10100000 |  224 E0  11100000
  33 21  00100001 |   97 61  01100001 |  161 A1  10100001 |  225 E1  11100001
  34 22  00100010 |   98 62  01100010 |  162 A2  10100010 |  226 E2  11100010
  35 23  00100011 |   99 63  01100011 |  163 A3  10100011 |  227 E3  11100011
  36 24  00100100 |  100 64  01100100 |  164 A4  10100100 |  228 E4  11100100
  37 25  00100101 |  101 65  01100101 |  165 A5  10100101 |  229 E5  11100101
  38 26  00100110 |  102 66  01100110 |  166 A6  10100110 |  230 E6  11100110
  39 27  00100111 |  103 67  01100111 |  167 A7  10100111 |  231 E7  11100111
  40 28  00101000 |  104 68  01101000 |  168 A8  10101000 |  232 E8  11101000
  41 29  00101001 |  105 69  01101001 |  169 A9  10101001 |  233 E9  11101001
  42 2A  00101010 |  106 6A  01101010 |  170 AA  10101010 |  234 EA  11101010
  43 2B  00101011 |  107 6B  01101011 |  171 AB  10101011 |  235 EB  11101011
  44 2C  00101100 |  108 6C  01101100 |  172 AC  10101100 |  236 EC  11101100
  45 2D  00101101 |  109 6D  01101101 |  173 AD  10101101 |  237 ED  11101101
  46 2E  00101110 |  110 6E  01101110 |  174 AE  10101110 |  238 EE  11101110
  47 2F  00101111 |  111 6F  01101111 |  175 AF  10101111 |  239 EF  11101111
  48 30  00110000 |  112 70  01110000 |  176 B0  10110000 |  240 F0  11110000
  49 31  00110001 |  113 71  01110001 |  177 B1  10110001 |  241 F1  11110001
  50 32  00110010 |  114 72  01110010 |  178 B2  10110010 |  242 F2  11110010
  51 33  00110011 |  115 73  01110011 |  179 B3  10110011 |  243 F3  11110011
  52 34  00110100 |  116 74  01110100 |  180 B4  10110100 |  244 F4  11110100
  53 35  00110101 |  117 75  01110101 |  181 B5  10110101 |  245 F5  11110101
  54 36  00110110 |  118 76  01110110 |  182 B6  10110110 |  246 F6  11110110
  55 37  00110111 |  119 77  01110111 |  183 B7  10110111 |  247 F7  11110111
  56 38  00111000 |  120 78  01111000 |  184 B8  10111000 |  248 F8  11111000
  57 39  00111001 |  121 79  01111001 |  185 B9  10111001 |  249 F9  11111001
  58 3A  00111010 |  122 7A  01111010 |  186 BA  10111010 |  250 FA  11111010
  59 3B  00111011 |  123 7B  01111011 |  187 BB  10111011 |  251 FB  11111011
  60 3C  00111100 |  124 7C  01111100 |  188 BC  10111100 |  252 FC  11111100
  61 3D  00111101 |  125 7D  01111101 |  189 BD  10111101 |  253 FD  11111101
  62 3E  00111110 |  126 7E  01111110 |  190 BE  10111110 |  254 FE  11111110
  63 3F  00111111 |  127 7F  01111111 |  191 BF  10111111 |  255 FF  11111111

よくある質問

Q. 16進数とは何ですか？ A. 0〜9 と A〜F の16個の記号を使い、16で桁が上がる数の表し方です。1桁が2進数の4桁にあたり、1バイトを2桁で書けるので、コンピューターの値を表すのに使われます。

Q. 16進数の読み方は？ A. 「じゅうろくしんすう」と読みます。英語では hexadecimal（略して hex）です。値は1文字ずつ読み、16進数の 10 は「いちぜろ」と読むと10進数の10と混ざりません。

Q. 16進数でなぜ A〜F を使うのですか？ A. 1桁で10〜15を表すための記号が数字には無いためです。A=10、B=11、C=12、D=13、E=14、F=15 です。

Q. 16進数を10進数に変換するには？ A. 各桁に、右から 1・16・256・4096 をかけて足します。7EA は 7×256＋14×16＋10＝2026 です。プログラムなら Python は int('7EA', 16)、Java は Integer.parseInt("7EA", 16)、JavaScript は parseInt('7EA', 16) です。

Q. 10進数を16進数に変換するには？ A. 16で割り続けて、余りを下から読みます。2026 は 7EA です。Python は format(2026, 'X')、Java は Integer.toHexString(2026)、JavaScript は (2026).toString(16) です。

Q. 16進数の計算（足し算・引き算）はどうやりますか？ A. 10進数の筆算と同じで、16で繰り上がり、引けないときは16を借ります。3A＋2F＝69、A3−5C＝47 です。「16進数の計算」の節に手順があります。

Q. 16進数の FF はいくつですか？ A. 符号なしでは255、8ビットの符号あり（2の補数）では −1 です。どちらで読むかは、値を入れている型で決まります。

Q. 16進数のマイナスはどう表しますか？ A. 紙の上では -FF のように - を付けます。コンピューターの中では2の補数を使い、8ビットの −1 は FF、−5 は FB です。

Q. 0x とは何ですか？ A. その数が16進数であることを示す印です。0xFF は16進数の FF（255）です。CSS の色では #、Unicode では U+ が同じ役目をします。

Q. 16進数の電卓はありますか？ A. Windows の電卓には「プログラマー」モードがあり、Microsoft の calculator リポジトリの説明にも基数の変換ができるとあります。Linux・Mac では bc（obase=16）や printf '%X\n' 2026、Python の対話モードでも計算できます。

まとめ

• 16進数は 0〜9・A〜F の16記号で、16で桁が上がる。1桁＝2進数4桁、1バイト＝2桁。
• 10進→16進は「16で割って余りを下から」、16進→10進は「各桁×16の累乗を足す」、2進⇔16進は「右から4桁ずつ」。
• 計算は16で繰り上がり・16を借りる。FF＋1＝100、A3−5C＝47。
• Python は int(s, 16)・format(n, 'x')、Java は Integer.parseInt(s, 16)・HexFormat、JavaScript は parseInt(s, 16)・toString(16)。
• 色コード・UTF-8 のバイト・xxd の出力・メモリアドレス・MAC・IPv6・ハッシュ値・UUID が16進数で書かれる。
• 8ビットの FF は符号なしで255、2の補数で −1。0x7FFFFFFF＋1 は int で −2147483648 になる。
• hexdump（オプションなし）と od -x は2バイトずつ入れ替わって見え、od の位置は8進数。

参考・出典

確認日はいずれも 2026年10月22日です。

• Python ドキュメント「Built-in Functions」（hex・int・format）：https://docs.python.org/3/library/functions.html
• Python ドキュメント「Built-in Types」（float.hex・int.to_bytes・int.from_bytes）：https://docs.python.org/3/library/stdtypes.html
• Java SE 21 API「Integer」：https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Integer.html
• Java SE 21 API「HexFormat」：https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/HexFormat.html
• MDN「parseInt()」：https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/parseInt
• MDN「Number.prototype.toString()」：https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Number/toString
• MDN「<hex-color>」：https://developer.mozilla.org/ja/docs/Web/CSS/hex-color
• Ubuntu Manpage「xxd」：https://manpages.ubuntu.com/manpages/noble/man1/xxd.1.html
• Linux man-pages「hexdump(1)」：https://man7.org/linux/man-pages/man1/hexdump.1.html
• Linux man-pages「od(1)」：https://man7.org/linux/man-pages/man1/od.1.html
• RFC 3629 UTF-8, a transformation format of ISO 10646：https://www.rfc-editor.org/rfc/rfc3629
• RFC 5952 A Recommendation for IPv6 Address Text Representation：https://www.rfc-editor.org/rfc/rfc5952
• RFC 9562 Universally Unique IDentifiers (UUIDs)：https://www.rfc-editor.org/rfc/rfc9562
• Microsoft「Windows Calculator」（GitHub）：https://github.com/microsoft/calculator
• IT用語辞典 e-Words「16進数」：https://e-words.jp/w/16%E9%80%B2%E6%95%B0.html
• Wikipedia「十六進法」：https://ja.wikipedia.org/wiki/十六進法

株式会社RJC ― SI事業・SES事業・AI駆動開発。RJCは一緒に成長を楽しめる会社です。