Java Number System | Complete Tutorial with Examples

What is a Number System?

A number system is a mathematical framework for representing quantities using a fixed set of digits and a base (also called radix). The base determines how many unique digits are available and how positional value is assigned to each digit. Every position in a number represents a power of the base — just like how the '3' in '300' means 3 × 10² in decimal.

Computers — including the JVM that runs Java programs — operate entirely on binary (base 2): every piece of data, every instruction, every character in memory is ultimately represented as a sequence of bits (0s and 1s). As a Java developer, understanding number systems means understanding how the data you write in code (int x = 255) is actually stored and manipulated at the hardware level — and how to work with that binary representation directly when needed.

Java natively supports four number systems in source code: decimal (base 10, everyday use), binary (base 2, bit-level operations), octal (base 8, legacy Unix permissions), and hexadecimal (base 16, memory addresses, colour codes, cryptographic hashes). All four compile to identical machine instructions — they are simply different ways of writing the same integer value in source code.

Four Number Systems Supported in Java

Here is a concise overview of each number system Java supports, including its base, digit set, Java prefix, and primary use case:

System	Base	Digits Used	Java Prefix	Example (= 255)	Primary Use Case
Decimal	10	0 – 9	None (default)	255	Everyday arithmetic, user-facing numbers
Binary	2	0, 1	0b or 0B	0b11111111	Bit manipulation, flags, hardware interfaces
Octal	8	0 – 7	0 (leading zero)	0377	Unix/Linux file permissions, legacy systems
Hexadecimal	16	0–9, A–F (or a–f)	0x or 0X	0xFF	Memory addresses, colour codes, byte values, crypto

☕ JavaAll Four Representations of the Same Value

public class NumberSystems {
    public static void main(String[] args) {

        // All four literals represent the same value: 255
        int decimal     = 255;          // Decimal     (base 10)
        int binary      = 0b11111111;   // Binary      (base 2)  — prefix 0b
        int octal       = 0377;          // Octal       (base 8)  — leading 0
        int hexadecimal = 0xFF;          // Hexadecimal (base 16) — prefix 0x

        System.out.println("Decimal     : " + decimal);
        System.out.println("Binary      : " + binary);
        System.out.println("Octal       : " + octal);
        System.out.println("Hexadecimal : " + hexadecimal);

        // All are equal — same bits in memory
        System.out.println("All equal?  : " + (decimal == binary && binary == octal && octal == hexadecimal));

        // Java 7+ — underscores in numeric literals for readability
        int creditCard  = 1234_5678_9012_3456;  // decimal with underscores
        int colorRed    = 0xFF_00_00;            // hex with underscores
        int flags       = 0b1010_0101;           // binary with underscores
        System.out.println("\nCredit card : " + creditCard);
        System.out.println("Color Red   : " + colorRed);
        System.out.println("Flags byte  : " + flags);
    }
}

Output

Decimal : 255 Binary : 255 Octal : 255 Hexadecimal : 255 All equal? : true Credit card : 1234567890123456 Color Red : 16711680 Flags byte : 165

Why Programmers Need Number Systems

Understanding number systems is not academic theory — it has direct, daily practical applications in professional Java development:

▶
🎨 Colour Codes and Graphics — RGB colours in web and Android development are written in hexadecimal: #FF5733 means Red=0xFF (255), Green=0x57 (87), Blue=0x33 (51). Java AWT and Android's Color class accept hex values like 0xFF5733.
▶
🔐 Cryptography and Hashing — SHA-256, MD5, and other hash outputs are hex strings: e.g. 'a9993e36476...' Each hex character represents 4 bits (a nibble), making hex the most compact human-readable representation of byte arrays.
▶
🚩 Bit Flags and Permissions — Linux file permissions (chmod 755 = rwxr-xr-x) are octal. Java's NIO FilePermissions, Android's Manifest permissions, and network flag fields use bit manipulation where understanding binary layout is essential.
▶
🧠 Memory and Pointer Arithmetic — JVM memory addresses, object references in debugging output (e.g. Object@1b6d3586), and native memory operations via JNI or Java's Unsafe class all use hexadecimal.
▶
⚙️ Bitwise Operations for Performance — Fast power-of-2 operations, bitmask flags, low-level protocol parsing (TCP headers, USB HID reports), and embedded systems interfaces all require direct binary manipulation.
▶
🔢 Binary Data Parsing — Reading binary file formats (PNG, ZIP, class files), network packets, or hardware sensor data requires understanding how bytes (8 bits each) map to integer values across different bases.

Binary vs Octal vs Decimal vs Hexadecimal — Full Comparison

Understanding how the same values look across all four bases builds the mental model needed for base conversion. Here is a reference table of values 0–20 across all four systems:

Decimal	Binary	Octal	Hexadecimal
0	0000	0	0
1	0001	1	1
2	0010	2	2
3	0011	3	3
4	0100	4	4
5	0101	5	5
6	0110	6	6
7	0111	7	7
8	1000	10	8
9	1001	11	9
10	1010	12	A
11	1011	13	B
12	1100	14	C
13	1101	15	D
14	1110	16	E
15	1111	17	F
16	0001 0000	20	10
17	0001 0001	21	11
18	0001 0010	22	12
19	0001 0011	23	13
20	0001 0100	24	14

Key insight: One hexadecimal digit represents exactly 4 binary bits (a nibble). One octal digit represents exactly 3 binary bits. This is why hex is so popular for representing bytes — one byte (8 bits) is always exactly two hex digits (e.g., 0xFF = 1111 1111 = 255).

Number Literals in Java

Java allows integer literals to be written in all four bases directly in source code. Java 7 also added underscore separators inside numeric literals to improve readability — the underscores are ignored by the compiler.

☕ JavaAll Java Numeric Literal Formats

public class NumericLiterals {
    public static void main(String[] args) {

        // ---- INTEGER LITERALS ----
        int dec  = 1_000_000;         // decimal  — 1 million
        int bin  = 0b0001_0000;        // binary   — 16
        int oct  = 0755;               // octal    — 493 (Unix rwxr-xr-x)
        int hex  = 0xCAFE_BABE;        // hex      — Java class file magic number

        // ---- LONG LITERALS (suffix L) ----
        long bigDec = 9_876_543_210L;
        long binLng = 0b1111_1111_1111_1111L;  // 65535L
        long hexLng = 0xDEAD_BEEF_CAFEL;

        // ---- FLOAT LITERALS (suffix f) ----
        float  pi   = 3.14_159_265f;
        double dpi  = 3.141_592_653_589_793;

        // ---- SCIENTIFIC NOTATION ----
        double avogadro  = 6.022e23;    // 6.022 × 10^23
        double electron  = 1.6e-19;     // 1.6  × 10^-19

        // ---- CHAR LITERALS (Unicode hex) ----
        char rupee  = '\u20B9';   // ₹ — Unicode hex U+20B9
        char omega  = '\u03A9';   // Ω
        char check  = '\u2713';   // ✓

        System.out.println("dec       = " + dec);
        System.out.println("bin (16)  = " + bin);
        System.out.println("oct (493) = " + oct);
        System.out.printf ("hex magic = %X%n", hex);
        System.out.println("bigDec    = " + bigDec);
        System.out.println("pi float  = " + pi);
        System.out.println("Avogadro  = " + avogadro);
        System.out.println("Rupee sym = " + rupee);
        System.out.println("Check sym = " + check);
    }
}

Output

dec = 1000000 bin (16) = 16 oct (493) = 493 hex magic = CAFEBABE bigDec = 9876543210 pi float = 3.1415927 Avogadro = 6.022E23 Rupee sym = ₹ Check sym = ✓

Important rules for underscores in literals: Underscores cannot appear at the start or end of a literal (_255 and 255_ are invalid). They cannot appear adjacent to the decimal point in floating-point literals (3._14 is invalid). They cannot appear before the L, f, or d suffix. Other than these restrictions, underscores can appear anywhere — including in hex, binary, and octal literals.

Java Built-in Conversion Methods

Java's Integer, Long, and String classes provide a complete set of built-in methods for converting between number bases. These are the fastest and most reliable way to perform base conversions in Java.

Method	Class	Description	Example
toBinaryString(int n)	Integer	Converts int to binary String (unsigned)	Integer.toBinaryString(25) → "11001"
toOctalString(int n)	Integer	Converts int to octal String	Integer.toOctalString(255) → "377"
toHexString(int n)	Integer	Converts int to hex String (lowercase)	Integer.toHexString(255) → "ff"
toString(int n, int radix)	Integer	Converts int to String in any base (2–36)	Integer.toString(255, 2) → "11111111"
parseInt(String s, int r)	Integer	Parses String in base r to decimal int	Integer.parseInt("ff", 16) → 255
parseInt(String s)	Integer	Parses decimal String to int	Integer.parseInt("255") → 255
valueOf(String s, int r)	Integer	Returns Integer object from String in base r	Integer.valueOf("11001", 2) → 25
bitCount(int n)	Integer	Returns count of 1-bits (set bits) in binary	Integer.bitCount(255) → 8
highestOneBit(int n)	Integer	Returns value with only highest bit set	Integer.highestOneBit(100) → 64
lowestOneBit(int n)	Integer	Returns value with only lowest bit set	Integer.lowestOneBit(12) → 4
numberOfLeadingZeros(int n)	Integer	Counts leading zero bits in 32-bit representation	Integer.numberOfLeadingZeros(1) → 31
numberOfTrailingZeros(int n)	Integer	Counts trailing zero bits	Integer.numberOfTrailingZeros(16) → 4
reverse(int n)	Integer	Reverses the bit order of the int	Integer.reverse(1) → -2147483648
reverseBytes(int n)	Integer	Reverses the byte order (endianness swap)	Integer.reverseBytes(0x12345678) → 0x78563412
toBinaryString(long n)	Long	Converts long to binary String	Long.toBinaryString(100L) → "1100100"
parseLong(String s, int r)	Long	Parses String in base r to long	Long.parseLong("ff", 16) → 255L

☕ JavaBuilt-in Conversion Methods Demo

public class ConversionMethods {
    public static void main(String[] args) {

        int n = 173;

        // Decimal → Other bases
        System.out.println("Decimal       : " + n);
        System.out.println("→ Binary       : " + Integer.toBinaryString(n));
        System.out.println("→ Octal        : " + Integer.toOctalString(n));
        System.out.println("→ Hexadecimal  : " + Integer.toHexString(n));
        System.out.println("→ Base 5       : " + Integer.toString(n, 5));
        System.out.println("→ Base 36      : " + Integer.toString(n, 36));

        // Other bases → Decimal
        System.out.println("\nBinary '10101101' → Decimal: " + Integer.parseInt("10101101", 2));
        System.out.println("Octal  '255'      → Decimal: " + Integer.parseInt("255", 8));
        System.out.println("Hex    'AD'       → Decimal: " + Integer.parseInt("AD", 16));

        // Bit information
        System.out.println("\nBit count of 173 : " + Integer.bitCount(n));
        System.out.println("Leading zeros    : " + Integer.numberOfLeadingZeros(n));
        System.out.println("Trailing zeros   : " + Integer.numberOfTrailingZeros(n));
        System.out.println("Highest one bit  : " + Integer.highestOneBit(n));

        // Padded binary string (8-bit padding)
        String padded = String.format("%8s", Integer.toBinaryString(n)).replace(" ", "0");
        System.out.println("\nPadded binary (8-bit): " + padded);

        // Padded hex string (4 digits)
        System.out.printf("Padded hex (4-digit) : %04X%n", n);
    }
}

Output

Decimal : 173 → Binary : 10101101 → Octal : 255 → Hexadecimal : ad → Base 5 : 1143 → Base 36 : 4t Binary '10101101' → Decimal: 173 Octal '255' → Decimal: 173 Hex 'AD' → Decimal: 173 Bit count of 173 : 5 Leading zeros : 24 Trailing zeros : 0 Highest one bit : 128 Padded binary (8-bit): 10101101 Padded hex (4-digit) : 00AD

Manual Base Conversion Algorithms

Understanding the manual algorithms behind base conversion is essential for interviews and for understanding what Java's built-in methods do internally. Here are the three most common manual conversion algorithms:

☕ JavaManual Base Conversion Algorithms

public class ManualConversions {

    // Algorithm 1: Decimal → Binary (repeated division by 2)
    static String decimalToBinary(int n) {
        if (n == 0) return "0";
        StringBuilder sb = new StringBuilder();
        int temp = Math.abs(n);
        while (temp > 0) {
            sb.append(temp % 2);   // remainder is 0 or 1
            temp /= 2;             // integer divide by base
        }
        if (n < 0) sb.append("-");
        return sb.reverse().toString();
    }

    // Algorithm 2: Binary String → Decimal (positional weight sum)
    static int binaryToDecimal(String binary) {
        int decimal = 0;
        int power   = 0;
        for (int i = binary.length() - 1; i >= 0; i--) {
            int bit = binary.charAt(i) - '0';  // '0'→0, '1'→1
            decimal += bit * (int) Math.pow(2, power);
            power++;
        }
        return decimal;
    }

    // Algorithm 3: Decimal → Any Base (generalised)
    static String decimalToBase(int n, int base) {
        if (n == 0) return "0";
        String digits = "0123456789ABCDEF";
        StringBuilder sb = new StringBuilder();
        int temp = Math.abs(n);
        while (temp > 0) {
            sb.append(digits.charAt(temp % base));
            temp /= base;
        }
        if (n < 0) sb.append("-");
        return sb.reverse().toString();
    }

    public static void main(String[] args) {
        System.out.println("--- Decimal to Binary ---");
        System.out.println("25  → " + decimalToBinary(25));
        System.out.println("100 → " + decimalToBinary(100));
        System.out.println("255 → " + decimalToBinary(255));

        System.out.println("\n--- Binary to Decimal ---");
        System.out.println("11001    → " + binaryToDecimal("11001"));
        System.out.println("1100100  → " + binaryToDecimal("1100100"));
        System.out.println("11111111 → " + binaryToDecimal("11111111"));

        System.out.println("\n--- Decimal to Any Base ---");
        System.out.println("255 base 2  → " + decimalToBase(255, 2));
        System.out.println("255 base 8  → " + decimalToBase(255, 8));
        System.out.println("255 base 16 → " + decimalToBase(255, 16));
        System.out.println("255 base 5  → " + decimalToBase(255, 5));
    }
}

Output

--- Decimal to Binary --- 25 → 11001 100 → 1100100 255 → 11111111 --- Binary to Decimal --- 11001 → 25 1100100 → 100 11111111 → 255 --- Decimal to Any Base --- 255 base 2 → 11111111 255 base 8 → 377 255 base 16 → FF 255 base 5 → 2010

Two's Complement — How Java Represents Negative Numbers

Java's primitive integer types (byte, short, int, long) use two's complement binary representation for negative numbers. This is not just theory — it explains exactly why Integer.MAX_VALUE + 1 == Integer.MIN_VALUE (integer overflow), and why Integer.toBinaryString(-1) returns 32 ones.

▶
Step 1 — Write the binary of the absolute value — For -25: write binary of 25 = 0001 1001 (8-bit)
▶
Step 2 — Flip all bits (one's complement) — 0001 1001 → 1110 0110
▶
Step 3 — Add 1 to the result — 1110 0110 + 1 = 1110 0111 — this is -25 in 8-bit two's complement

☕ JavaTwo's Complement — Negative Numbers in Java

public class TwosComplement {
    public static void main(String[] args) {

        // Integer.toBinaryString shows the actual 32-bit two's complement
        System.out.println("Binary of  5  : " + Integer.toBinaryString(5));
        System.out.println("Binary of -5  : " + Integer.toBinaryString(-5));
        System.out.println("Binary of  1  : " + Integer.toBinaryString(1));
        System.out.println("Binary of -1  : " + Integer.toBinaryString(-1));  // 32 ones
        System.out.println("Binary of  0  : " + Integer.toBinaryString(0));

        // Two's complement property: n + (~n) = -1
        int x = 42;
        System.out.println("\nx           = " + x);
        System.out.println("~x (flip)   = " + (~x));
        System.out.println("x + (~x)    = " + (x + (~x)));  // always -1
        System.out.println("-x manual   = " + (~x + 1));    // two's complement
        System.out.println("-x java     = " + (-x));        // same result

        // Integer overflow — two's complement wrap-around
        System.out.println("\nMAX_VALUE     : " + Integer.MAX_VALUE);
        System.out.println("MAX_VALUE + 1  : " + (Integer.MAX_VALUE + 1)); // wraps to MIN_VALUE
        System.out.println("MIN_VALUE      : " + Integer.MIN_VALUE);
        System.out.println("MIN_VALUE - 1  : " + (Integer.MIN_VALUE - 1)); // wraps to MAX_VALUE

        // Bit widths of Java integer types
        System.out.println("\nbyte  range: " + Byte.MIN_VALUE    + " to " + Byte.MAX_VALUE);
        System.out.println("short range: " + Short.MIN_VALUE   + " to " + Short.MAX_VALUE);
        System.out.println("int   range: " + Integer.MIN_VALUE + " to " + Integer.MAX_VALUE);
        System.out.println("long  range: " + Long.MIN_VALUE    + " to " + Long.MAX_VALUE);
    }
}

Output

Binary of 5 : 101 Binary of -5 : 11111111111111111111111111111011 Binary of 1 : 1 Binary of -1 : 11111111111111111111111111111111 Binary of 0 : 0 x = 42 ~x (flip) = -43 x + (~x) = -1 -x manual = -42 -x java = -42 MAX_VALUE : 2147483647 MAX_VALUE + 1 : -2147483648 MIN_VALUE : -2147483648 MIN_VALUE - 1 : 2147483647 byte range: -128 to 127 short range: -32768 to 32767 int range: -2147483648 to 2147483647 long range: -9223372036854775808 to 9223372036854775807

Bitwise Operators in Java

Java provides six bitwise operators that operate on individual bits of integer operands. These are fundamental for bit manipulation, flag management, performance optimisation, and low-level data processing.

Operator	Name	Operation	Example (5, 3)	Result
&	Bitwise AND	1 only if BOTH bits are 1	0101 & 0011	0001 = 1
\|	Bitwise OR	1 if EITHER bit is 1	0101 \| 0011	0111 = 7
^	Bitwise XOR	1 if bits are DIFFERENT	0101 ^ 0011	0110 = 6
~	Bitwise NOT	Flip all bits (unary)	~0101	1010...1010 = -6
<<	Left Shift	Shift bits left, fill 0s on right	5 << 1	1010 = 10 (×2)
>>	Right Shift	Shift bits right, fill sign bit	5 >> 1	0010 = 2 (÷2)
>>>	Unsigned RS	Shift right, always fill 0s	-8 >>> 1	2147483644

☕ JavaBitwise Operators — Practical Demo

public class BitwiseDemo {
    public static void main(String[] args) {

        int a = 0b1010_1100;  // 172
        int b = 0b0011_1111;  //  63

        System.out.printf("a          = %3d  | %s%n", a, Integer.toBinaryString(a));
        System.out.printf("b          = %3d  | %s%n", b, Integer.toBinaryString(b));
        System.out.printf("a & b      = %3d  | %s%n", (a&b),  Integer.toBinaryString(a&b));
        System.out.printf("a | b      = %3d  | %s%n", (a|b),  Integer.toBinaryString(a|b));
        System.out.printf("a ^ b      = %3d  | %s%n", (a^b),  Integer.toBinaryString(a^b));
        System.out.printf("~a         = %3d  | (32-bit two's complement)%n", ~a);

        System.out.println();

        // Common bitwise tricks
        int x = 52;
        System.out.println("--- Bitwise Tricks ---");
        System.out.println("x = " + x + "  binary: " + Integer.toBinaryString(x));

        // Check if even or odd
        System.out.println("Is even? : " + ((x & 1) == 0));  // LSB = 0 → even

        // Multiply and divide by 2
        System.out.println("x << 1 (×2) = " + (x << 1));   // 104
        System.out.println("x >> 1 (÷2) = " + (x >> 1));   // 26
        System.out.println("x << 3 (×8) = " + (x << 3));   // 416

        // Check if power of 2
        int p = 64;
        System.out.println(p + " is power of 2? " + ((p & (p - 1)) == 0));

        // Toggle, set, clear a specific bit
        int flags = 0b0000_0000;
        flags |=  (1 << 3);   // SET   bit 3
        System.out.println("After SET  bit 3: " + Integer.toBinaryString(flags));
        flags ^=  (1 << 3);   // TOGGLE bit 3
        System.out.println("After TOGGLE bit 3: " + Integer.toBinaryString(flags));
        flags |=  (1 << 5);   // SET   bit 5
        flags &= ~(1 << 5);   // CLEAR bit 5
        System.out.println("After CLEAR bit 5: " + Integer.toBinaryString(flags));
    }
}

Output

a = 172 | 10101100 b = 63 | 111111 a & b = 44 | 101100 a | b = 191 | 10111111 a ^ b = 147 | 10010011 ~a = -173 | (32-bit two's complement) --- Bitwise Tricks --- x = 52 binary: 110100 Is even? : true x << 1 (×2) = 104 x >> 1 (÷2) = 26 x << 3 (×8) = 416 64 is power of 2? true After SET bit 3: 1000 After TOGGLE bit 3: 0 After CLEAR bit 5: 0

Decimal to Binary Conversion — Step-by-Step Flow

The flowchart below illustrates the classic repeated division by 2 algorithm for converting a decimal integer to its binary representation — the same algorithm used by Integer.toBinaryString() internally.

📥 Input decimal Ne.g. N = 25

❓ N == 0?base case check

Yes

✅ Output '0'result is '0'

📝 Remainder = N mod 20 or 1 — record it

➗ N = N div 2integer divide by 2

❓ N > 0?more digits to compute?

Yes

🔁 Repeatback to compute remainder

🔄 Reverse remaindersread from bottom to top

✅ Binary resulte.g. 25 → 11001

Code Execution Flow — from source to output

Trace for N = 25: 25 ÷ 2 = 12 remainder 1 → 12 ÷ 2 = 6 remainder 0 → 6 ÷ 2 = 3 remainder 0 → 3 ÷ 2 = 1 remainder 1 → 1 ÷ 2 = 0 remainder 1. Remainders read bottom-to-top: 11001. Verify: 1×16 + 1×8 + 0×4 + 0×2 + 1×1 = 25 ✓

Bit Shift Operators — << >> >>>

Java's three shift operators move all bits of an integer left or right by a specified number of positions. They are equivalent to fast multiplication or division by powers of 2 and are heavily used in hashing, encoding, and performance-critical code.

☕ JavaShift Operators — Complete Demo

public class ShiftOperators {
    public static void main(String[] args) {

        int n = 12;  // binary: 0000 1100
        System.out.println("n = " + n + "  binary: " + Integer.toBinaryString(n));

        // Left shift << : multiply by 2^k (fast power-of-2 multiplication)
        System.out.println("\n--- Left Shift (<<) ---");
        System.out.println("n << 1 = " + (n << 1) + "  (12 × 2 = 24)");
        System.out.println("n << 2 = " + (n << 2) + "  (12 × 4 = 48)");
        System.out.println("n << 3 = " + (n << 3) + "  (12 × 8 = 96)");

        // Signed right shift >> : divide by 2^k (preserves sign)
        System.out.println("\n--- Signed Right Shift (>>) ---");
        System.out.println("n >> 1 = " + (n >> 1) + "  (12 ÷ 2 = 6)");
        System.out.println("n >> 2 = " + (n >> 2) + "  (12 ÷ 4 = 3)");
        int neg = -48;
        System.out.println("\n-48 >> 1 = " + (neg >> 1) + "  (-48 ÷ 2 = -24, sign preserved)");
        System.out.println("-48 >> 2 = " + (neg >> 2) + "  (-48 ÷ 4 = -12, sign preserved)");

        // Unsigned right shift >>> : always fills with 0 (ignores sign)
        System.out.println("\n--- Unsigned Right Shift (>>>) ---");
        System.out.println("-48 >>> 1 = " + (-48 >>> 1) + "  (large positive — sign bit → 0)");
        System.out.println("-1  >>> 1 = " + (-1 >>> 1)  + "  (Integer.MAX_VALUE = 2147483647)");

        // Real-world: HashMap's hash spreading uses >>>
        // hash(key) = key.hashCode() ^ (key.hashCode() >>> 16)
        int hashCode = 0xABCD1234;
        int spread   = hashCode ^ (hashCode >>> 16);
        System.out.printf("%nHashMap hash spread: 0x%X ^ 0x%X = 0x%X%n",
            hashCode, hashCode >>> 16, spread);

        // Mid-point without overflow — used in binary search
        int lo = 1_000_000_000, hi = 2_000_000_000;
        int mid = (lo + hi) >>> 1;  // safe — no overflow
        System.out.println("\nSafe mid (no overflow): " + mid);
    }
}

Output

n = 12 binary: 1100 --- Left Shift (<<) --- n << 1 = 24 (12 × 2 = 24) n << 2 = 48 (12 × 4 = 48) n << 3 = 96 (12 × 8 = 96) --- Signed Right Shift (>>) --- n >> 1 = 6 (12 ÷ 2 = 6) n >> 2 = 3 (12 ÷ 4 = 3) -48 >> 1 = -24 (-48 ÷ 2 = -24, sign preserved) -48 >> 2 = -12 (-48 ÷ 4 = -12, sign preserved) --- Unsigned Right Shift (>>>) --- -48 >>> 1 = 2147483624 (large positive — sign bit → 0) -1 >>> 1 = 2147483647 (Integer.MAX_VALUE = 2147483647) HashMap hash spread: 0xABCD1234 ^ 0xABCD = 0xABCD9889 Safe mid (no overflow): 1500000000

Number Formatting and Display

Java's String.format() and printf() provide powerful format specifiers for displaying numbers in any base and with custom padding, making output clean and professional.

☕ JavaNumber Formatting with printf and String.format

public class NumberFormatting {
    public static void main(String[] args) {

        int[] values = {0, 7, 15, 42, 100, 173, 255};

        System.out.printf("%-10s %-10s %-10s %-12s%n",
            "Decimal", "Binary", "Octal", "Hexadecimal");
        System.out.println("-".repeat(45));

        for (int v : values) {
            System.out.printf("%-10d %-10s %-10o %-12X%n",
                v,
                String.format("%8s", Integer.toBinaryString(v)).replace(" ","0"),
                v,
                v);
        }

        System.out.println();

        // Format specifier summary
        int n = 255;
        System.out.println("--- Format Specifiers ---");
        System.out.printf("%d   → decimal%n",     n);
        System.out.printf("%o   → octal%n",       n);
        System.out.printf("%x   → hex lowercase%n", n);
        System.out.printf("%X   → hex uppercase%n", n);
        System.out.printf("%08X → padded hex (8 digits)%n", n);
        System.out.printf("#%06X → hex colour code%n", n);
        System.out.printf("%+d  → with sign%n",   n);
        System.out.printf("%,d  → with commas%n", 1_000_000);
        System.out.printf("%.4f → 4 decimal places%n", Math.PI);
        System.out.printf("%e   → scientific notation%n", 1234567.89);
    }
}

Output

Decimal Binary Octal Hexadecimal --------------------------------------------- 0 00000000 0 0 7 00000111 7 7 15 00001111 17 F 42 00101010 52 2A 100 01100100 144 64 173 10101101 255 AD 255 11111111 377 FF --- Format Specifiers --- 255 → decimal 377 → octal ff → hex lowercase FF → hex uppercase 000000FF → padded hex (8 digits) #0000FF → hex colour code +255 → with sign 1,000,000 → with commas 3.1416 → 4 decimal places 1.234568e+06 → scientific notation

Best Practices for Java Number Systems

Professional Java developers follow these best practices to write clear, correct, and portable code when working with number systems and bit manipulation:

▶
✅ 1. Use Binary Literals for Bit Flags and Masks — When defining bit masks or flags, write them in binary (0b1000_0000) not decimal (128) or hex (0x80). Binary literals make the bit structure immediately visible without mental translation.
▶
✅ 2. Use Hex for Byte Values and Colour Codes — One byte (8 bits) = two hex digits. Use 0xFF not 255 when working with byte arrays, colour components, or protocol fields. Hex communicates byte boundaries clearly.
▶
✅ 3. Use Underscore Separators for Large Literals — Write 1_000_000 not 1000000, 0xFF_FF not 0xFFFF, and 0b1010_0101 not 0b10100101. Underscores dramatically improve readability for constants, bitmasks, and large numbers.
▶
✅ 4. Use >>> Instead of >> for Unsigned Operations — When shifting for bit extraction or hash computation (not arithmetic division), use >>> to avoid accidental sign extension. >>> always fills with 0; >> extends the sign bit. Java's HashMap uses >>> 16 in its hash spreading — not >>.
▶
✅ 5. Prefer Integer.toBinaryString() Over Manual Loops — Java's built-in Integer.toBinaryString(), Integer.toHexString(), and Integer.parseInt(s, radix) are faster, tested, and handles edge cases (0, negative values) correctly. Use manual algorithms only in interviews or when custom formatting is needed.
▶
✅ 6. Be Aware of Integer Overflow in Bit Operations — Left-shifting a value past the sign bit causes overflow. int max = Integer.MAX_VALUE; max << 1; wraps around. For values that might overflow, use long literals and Long arithmetic, or check bounds before shifting.
▶
✅ 7. Use EnumSet Instead of int Bitmasks for Flags in Production — While int bitmasks are fast and concise, EnumSet<MyFlags> provides type safety, readable names, and efficient bit operations under the hood. Prefer EnumSet for domain flag management in production Java code.
▶
❌ 8. Never Use Octal Literals for Non-Permission Values — A leading zero on an integer literal makes it octal: int x = 010 means 8, not 10! This is a notorious Java gotcha. Only use octal literals intentionally for file permission constants. Never write leading-zero decimal numbers.

Real-World Code Examples

Example 1 — RGB Colour Encoder/Decoder

☕ JavaRGB Colour Encoder and Decoder

public class RGBColour {

    // Pack R, G, B components into a single 32-bit int
    static int encode(int r, int g, int b) {
        return (r << 16) | (g << 8) | b;
    }

    // Extract components using bit masks
    static int getRed(int colour) {
        return (colour >> 16) & 0xFF;
    }

    static int getGreen(int colour) {
        return (colour >> 8) & 0xFF;
    }

    static int getBlue(int colour) {
        return colour & 0xFF;
    }

    static String toHexCode(int colour) {
        return String.format("#%06X", colour & 0xFFFFFF);
    }

    public static void main(String[] args) {
        // Encode colours
        int tomato     = encode(255, 99, 71);
        int steelBlue  = encode(70, 130, 180);
        int gold       = encode(255, 215, 0);

        // Display colour info
        int[] colours = {tomato, steelBlue, gold};
        String[] names = {"Tomato", "SteelBlue", "Gold"};

        System.out.printf("%-12s %-10s R    G    B%n", "Name", "HexCode");
        System.out.println("-".repeat(40));
        for (int i = 0; i < colours.length; i++) {
            System.out.printf("%-12s %-10s %-4d %-4d %d%n",
                names[i],
                toHexCode(colours[i]),
                getRed(colours[i]),
                getGreen(colours[i]),
                getBlue(colours[i]));
        }

        // Decode a hex colour code
        int parsed = Integer.parseInt("4169E1", 16); // RoyalBlue
        System.out.printf("%nRoyalBlue #4169E1 → R=%d G=%d B=%d%n",
            getRed(parsed), getGreen(parsed), getBlue(parsed));
    }
}

Output

Name HexCode R G B ---------------------------------------- Tomato #FF6347 255 99 71 SteelBlue #4682B4 70 130 180 Gold #FFD700 255 215 0 RoyalBlue #4169E1 → R=65 G=105 B=225

Example 2 — Permission Flags Using Bitmask

☕ JavaUser Permission System with Bitwise Flags

public class PermissionFlags {

    // Permission constants — each is a distinct bit
    static final int READ    = 0b0001;  // bit 0 = 1
    static final int WRITE   = 0b0010;  // bit 1 = 2
    static final int EXECUTE = 0b0100;  // bit 2 = 4
    static final int DELETE  = 0b1000;  // bit 3 = 8
    static final int ADMIN   = 0b1111;  // all permissions

    // Check if a permission is set
    static boolean hasPermission(int userPerms, int flag) {
        return (userPerms & flag) != 0;
    }

    // Grant a permission
    static int grant(int userPerms, int flag) {
        return userPerms | flag;
    }

    // Revoke a permission
    static int revoke(int userPerms, int flag) {
        return userPerms & ~flag;
    }

    static void printPermissions(String user, int perms) {
        System.out.printf("%-10s [%04d] READ:%-5b WRITE:%-5b EXEC:%-5b DEL:%b%n",
            user,
            Integer.parseInt(Integer.toBinaryString(perms)),
            hasPermission(perms, READ),
            hasPermission(perms, WRITE),
            hasPermission(perms, EXECUTE),
            hasPermission(perms, DELETE));
    }

    public static void main(String[] args) {
        int arjun  = READ | WRITE;        // 0011 = 3
        int priya  = READ | EXECUTE;      // 0101 = 5
        int admin  = ADMIN;               // 1111 = 15

        System.out.println("Initial Permissions:");
        printPermissions("Arjun",  arjun);
        printPermissions("Priya",  priya);
        printPermissions("Admin",  admin);

        arjun = grant(arjun, EXECUTE);    // add execute
        priya = revoke(priya, READ);      // remove read

        System.out.println("\nAfter Updates:");
        printPermissions("Arjun",  arjun);
        printPermissions("Priya",  priya);
    }
}

Output

Initial Permissions: Arjun [0011] READ:true WRITE:true EXEC:false DEL:false Priya [0101] READ:true WRITE:false EXEC:true DEL:false Admin [1111] READ:true WRITE:true EXEC:true DEL:true After Updates: Arjun [0111] READ:true WRITE:true EXEC:true DEL:false Priya [0100] READ:false WRITE:false EXEC:true DEL:false

Practice This Code — Live Editor

Advantages and Disadvantages of Working with Number Systems in Java

Understanding and using multiple number systems in Java brings concrete benefits — but also requires careful handling to avoid subtle bugs.

✅ Advantages

Native Multi-Base Literal SupportJava directly supports binary (0b), octal (0), and hexadecimal (0x) literals in source code. No conversion needed — write 0xFF and Java stores it identically to 255 in memory. This makes hardware, colour, and flag constants self-documenting.

Bitwise Operations Enable High PerformanceBit manipulation (AND, OR, XOR, shifts) is the fastest category of CPU instruction — no division, no branching. Checking even/odd with (n & 1), power-of-2 checks with (n & (n-1)) == 0, and bit flag operations are orders of magnitude faster than arithmetic equivalents.

Rich Integer Utility APIInteger.toBinaryString(), toHexString(), parseInt(s, radix), bitCount(), numberOfLeadingZeros() and 10+ other methods provide ready-made, tested tools for all common number-system operations without manual implementation.

Direct Hardware and Protocol CompatibilityNetwork protocols, file formats, and hardware interfaces communicate in bytes and bit fields. Binary and hex literacy lets you read and write protocol specifications directly and parse binary data formats without translation layers.

Underscore Literals Improve Code ReadabilityJava 7+ underscore separators (1_000_000, 0xFF_FF_FF, 0b1010_0101) make large constants, colour codes, and bitmasks instantly readable without magic number comments.

❌ Disadvantages

Octal Literal Gotcha — Leading ZeroA leading zero silently makes any integer literal octal: int x = 010; means x = 8, not 10. This is a notorious Java bug source. Never write decimal numbers with leading zeros — use explicit octal only for permission constants where the context is unambiguous.

Signed vs Unsigned ConfusionJava has no unsigned int type (unlike C/C++). All int operations are signed two's complement. Shifting -1 >> 1 gives -1 (sign extension), not a large positive. Using >>> instead of >> for unsigned logic is non-obvious to beginners and a common bug source.

Integer Overflow Is SilentJava does not throw an exception on integer overflow — it silently wraps around. Integer.MAX_VALUE + 1 gives Integer.MIN_VALUE with no warning. Left-shifting past the sign bit corrupts values silently. Overflow-safe arithmetic requires explicit checks or Math.addExact() / Math.multiplyExact().

Binary Manipulation Code Is Hard to ReadComplex bitmask expressions like (perms & ~(READ | WRITE)) | EXECUTE require careful documentation. Without clear constant names and comments, bitwise code becomes unmaintainable. Always use named constants (static final int READ = 0b0001) instead of raw literals.

Java Number System — Interview Questions

These are the most frequently asked interview questions on the Java Number System and related bit manipulation for Java developer and competitive programming interviews.

Java supports four number systems: Decimal (base 10) — no prefix, e.g. 255. Binary (base 2) — prefix 0b or 0B, e.g. 0b11111111. Octal (base 8) — leading zero prefix, e.g. 0377. Hexadecimal (base 16) — prefix 0x or 0X, e.g. 0xFF. All four represent the same integer in memory and are interchangeable in expressions. Java 7+ also allows underscore separators inside literals for readability: 0b1111_1111, 0xFF_FF, 1_000_000.

(1) Integer.toBinaryString(n) — built-in, returns unsigned binary string. (2) Integer.toString(n, 2) — radix-based, returns signed binary string for negatives. (3) Manual loop — repeatedly divide by 2, collect remainders, reverse: StringBuilder sb = new StringBuilder(); while (n > 0) { sb.append(n % 2); n /= 2; } sb.reverse(). For padding to 8 bits: String.format('%8s', Integer.toBinaryString(n)).replace(' ', '0').

Two's complement is the standard binary representation for negative integers. To find -n: flip all bits of n then add 1. Java uses it for all integer types (byte, short, int, long). Benefits: (1) Only one representation of zero (unlike sign-magnitude). (2) Addition and subtraction hardware works identically for positive and negative numbers — no special case logic. (3) Overflow wraps naturally. Java's int range is -2^31 to 2^31-1 because the MSB is the sign bit.

>> is the signed right shift. It shifts bits right and fills the vacated MSBs with the sign bit (0 for positive, 1 for negative). So -8 >> 1 = -4 (arithmetic division by 2, sign preserved). >>> is the unsigned right shift. It always fills vacated MSBs with 0 regardless of sign. So -8 >>> 1 gives 2147483644 (a large positive number). Use >> for arithmetic operations on signed integers; use >>> for bit manipulation, hash spreading, and unsigned byte operations.

(a) Set bit k: n | (1 << k) — ORing with a mask that has only bit k set. (b) Clear bit k: n & ~(1 << k) — ANDing with a mask that has all bits set except k. (c) Toggle bit k: n ^ (1 << k) — XORing with a mask flips bit k. (d) Check if bit k is set: (n & (1 << k)) != 0 — AND with mask; non-zero means set. These four operations form the foundation of all bit flag management and are tested in virtually every systems programming interview.

Integer.MIN_VALUE (-2147483648). This is integer overflow — a two's complement wrap-around. Integer.MAX_VALUE = 0111 1111 1111 1111 1111 1111 1111 1111 in binary. Adding 1 sets all mantissa bits to 0 and the sign bit to 1: 1000 0000 0000 0000 0000 0000 0000 0000 = Integer.MIN_VALUE. Java does not throw an exception — overflow is silent. Use Math.addExact(a, b) to get ArithmeticException on overflow, or switch to long for larger values.

Method 1: Integer.bitCount(n) — Java's built-in O(1) population count using hardware intrinsic. Method 2: Brian Kernighan's algorithm — while (n != 0) { n &= (n - 1); count++; } — each iteration clears the lowest set bit; runs in O(k) where k is number of set bits. Method 3: naive loop — check each bit: for (int i = 0; i < 32; i++) if ((n & (1 << i)) != 0) count++; — O(32). Always use Integer.bitCount() in production; know Kernighan's for interviews.

Practice Questions — Test Your Knowledge

Test your understanding of Java Number Systems with these practice questions. Attempt each before revealing the answer.

1. What are the decimal values of: (a) 0b1010 (b) 0777 (c) 0x1F (d) 0b1111_0000?

Easy

2. What is the output? int x = 0b1010; // 10 int y = 0b1100; // 12 System.out.println(x & y); // AND System.out.println(x | y); // OR System.out.println(x ^ y); // XOR

Easy

3. Why does int x = 09; cause a compile error but int y = 07; does not?

Easy

4. Write a Java expression to extract the lower byte (bits 0–7) and upper byte (bits 8–15) of an int using bitwise operators.

Medium

5. What does n & (n-1) compute? What is it useful for?

Medium

✅ Answern & (n-1) clears (turns off) the lowest set bit (rightmost 1-bit) of n. Example: n = 12 = 1100, n-1 = 11 = 1011, n & (n-1) = 1000 = 8. Uses: (1) Check if n is a power of 2: (n > 0) && (n & (n-1)) == 0. (2) Count set bits (Kernighan's algorithm): repeat n &= (n-1) until n == 0, counting iterations. (3) Check if n has exactly one set bit. This is one of the most tested bitwise tricks in interviews.

6. What is the output of Integer.toBinaryString(-5) and why does it have 32 characters?

Medium

7. A 32-bit int stores an RGBA colour as: bits 31-24 = Alpha, bits 23-16 = Red, bits 15-8 = Green, bits 7-0 = Blue. Write expressions to extract each component.

Hard

8. Without using any division operator (/) or modulo (%), determine if an integer n is even or odd using bitwise operations. Explain why it works.

Easy

✅ Answerboolean isEven = (n & 1) == 0; The binary representation of any integer ends in 0 for even numbers and 1 for odd numbers (since 2^0 = 1 is the only odd power of 2). ANDing with 1 (binary: ...0001) isolates the least significant bit. If LSB = 0, the number is even; if LSB = 1, the number is odd. This is faster than n % 2 == 0 because AND is a single CPU instruction with no division involved.

Conclusion — Mastering Java Number Systems

The number system is the bedrock of computer science — and Java's first-class support for binary, octal, decimal, and hexadecimal literals, combined with its rich Integer utility methods and bitwise operator set, gives you every tool needed to work directly at the bit level when required.

Mastering number systems in Java means knowing when to use binary literals for bit flags, hexadecimal for byte values and colour codes, and underscore separators for readable constants. It means understanding two's complement to predict overflow behaviour, using >>> correctly for unsigned shifts, and leveraging bit tricks like n & (n-1) for high-performance operations in competitive programming and systems code.

Scenario	Best Approach
Define bit flags / permission masks	✅ Binary literals: 0b0001, 0b0010, 0b0100
Colour codes / byte values / memory	✅ Hex literals: 0xFF, 0xCAFEBABE
Large numeric constants	✅ Underscore separators: 1_000_000, 0xFF_FF_FF
Decimal to binary conversion	✅ Integer.toBinaryString(n) or Integer.toString(n,2)
Any base string to decimal	✅ Integer.parseInt(str, radix)
Fast multiply/divide by power of 2	✅ Left/right bit shift: n << k, n >> k
Unsigned right shift	✅ >>> operator (not >>)
Negative binary representation	✅ Two's complement: ~n + 1
Count 1-bits in an integer	✅ Integer.bitCount(n)
Check power of 2	✅ (n > 0) && (n & (n-1)) == 0

Your next steps: explore Java's Byte and ByteBuffer classes for binary data I/O; study IEEE 754 floating-point representation to understand how float and double store fractional binary numbers; learn Java's BigInteger for arbitrary-precision arithmetic and base conversion of very large numbers; and see how bit manipulation powers Java's HashMap.hash(), UUID generation, and cryptographic operations in production systems.

Remember: Binary (0b) for flags, Hex (0x) for bytes, underscore separators for readability, >>> for unsigned shifts, and always name your bit constants. These five habits will keep your number system code correct, readable, and professional. ☕

Frequently Asked Questions (FAQ)

Java supports four number systems natively: Decimal (base 10) — the default, written as plain integers like 255; Binary (base 2) — written with the 0b or 0B prefix, e.g. 0b11111111; Octal (base 8) — written with a leading 0, e.g. 0377; Hexadecimal (base 16) — written with 0x or 0X prefix, e.g. 0xFF. All four represent the same integer value (255) and are stored identically in memory. Java 7+ also supports binary literals with underscores for readability.