Convert Binary to Decimal in Java

Beginner
⏱️ 10 min read
📚 Updated: Aug 2026
🎯 3 Code Examples
🚀 Live Preview
Base conversion
Overview

What You’ll Learn

Binary (base 2) uses only bits 0 and 1; decimal (base 10) is the everyday number system. This tutorial covers place values, a live preview, algorithm steps, worked Java examples, edge cases, and complexity.

Place Values

1, 2, 4, 8…

Each bit position is a power of two, starting at 20 on the right.

Manual Loop

Sum 2^i

Walk bits right-to-left; add 2^power for every 1 bit.

parseInt(s, 2)

Built-in

Parse a binary string as base 2 and get a decimal int in one call.

Validate First

Only 0 / 1

Reject empty strings and any character outside {0, 1}.

Live Preview

Try any bits

Type a binary string and convert it to decimal instantly.

O(k)

Complexity

One pass over k bits; extra space stays O(1) beyond the input.

Introduction

Binary-to-decimal conversion turns a base-2 string into a base-10 integer. Each bit contributes a power of two: the rightmost bit is 20, then 21, 22, and so on.

You can sum those place values by hand, or call Integer.parseInt(bits, 2). Classic example: 101010 → 32 + 8 + 2 = 42.

Why it matters?

It trains place-value thinking, string loops, validation, and the habit of explaining O(k) bit complexity in interviews.

Key Highlights

Powers of Two

Only 1-bits contribute; 0-bits add nothing.

Validate Bits

Anything outside 0/1 is not a binary string.

Two Styles

Manual loop for interviews; Integer.parseInt(s, 2) for apps.

Watch Overflow

int/long can overflow; prefer BigInteger for huge bit strings.

In short: for each 1-bit at position i (from the right), add 2i — or just call Integer.parseInt(bits, 2).

Foundation

📝 Problem & Approach

Given a binary string of 0s and 1s, return its decimal integer value.

java
// Example: "101010"
// 1*32 + 0*16 + 1*8 + 0*4 + 1*2 + 0*1 = 42

Inputs & Outputs

ItemTypeDescription
bitsstrNon-empty string containing only characters 0 and 1.
Return / printintDecimal integer value of that binary number.

Minimal workflow

Pseudocode
function binaryToDecimal(s):
    if s has characters other than 0 and 1:
        return error
    total = 0
    power = 0
    for bit from right to left in s:
        if bit == '1':
            total = total + (2 ^ power)
        power = power + 1
    return total

Method comparison

MethodIdeaNotes
Place-value loopAdd 2^i for each 1-bit from the rightBest for showing interview math
Integer.parseInt(bits, 2)Built-in base-2 parseShortest production style
Cheat Sheet

⚡ Quick Reference

GoalPattern
Validate bitsall(ch in "01" for ch in bits)
Walk right-to-leftfor (i = len-1; i >= 0; i--)
Add place valuetotal += powerOfTwo
Built-in convertInteger.parseInt(bits, 2)
Doubling methodtotal = total * 2 + bit left-to-right
Classic check"101010" → 42
Compare

📋 Place Value vs parseInt vs Doubling

Same decimal answer — different clarity and interview signaling.

Place value
sum 2^i

Shows powers of two clearly; preferred whiteboard style

Integer.parseInt(s, 2)
built-in

Idiomatic Java for real applications

Doubling
2*total + bit

Left-to-right Horner form; no reverse needed

Interview tip
manual first

Explain place values, then mention Integer.parseInt(s, 2)

Context

When This Problem Shows Up

Reach for binary-to-decimal drills when base conversion and bit place values matter.

  1. Interview warm-ups

    Quick check of loops, powers, and input validation.

  2. Teaching place value

    Makes 1, 2, 4, 8… feel concrete with a famous 42 example.

  3. Gateway to other bases

    Same idea extends to octal, hex, and custom bases.

  4. Low-level / systems intros

    Bits show up constantly in networking and hardware topics.

  5. Not for float binaries alone

    Fractional binary (after a point) needs a different place-value story.

Key benefit: one short problem that covers powers of two, string loops, validation, and O(k) reasoning.

Interactive

🔮 Live Preview

Enter a binary string (0 and 1 only) and convert it to decimal.

Use only characters 0 and 1 (preview limited to JS safe integers).

Live result
Press "Convert" to see the decimal value.
Hands-On

Examples Gallery

Three complete Java programs — place-value loop, Integer.parseInt(..., 2), and the doubling method. Click View Output to reveal sample console results.

📚 Getting Started

Powers of two from the right — the interview classic.

Example 1 — Manual Conversion Using Powers of 2

Validate bits, walk right-to-left, and add a power of 2 for every 1 (no Math.pow).

java
public class Main {
    static long binaryToDecimalManual(String bits) {
        bits = bits.trim();
        if (bits.isEmpty()) {
            throw new IllegalArgumentException("Binary string must contain only 0 and 1");
        }

        long total = 0;
        long powerOfTwo = 1;

        for (int i = bits.length() - 1; i >= 0; i--) {
            char ch = bits.charAt(i);
            if (ch != '0' && ch != '1') {
                throw new IllegalArgumentException("Binary string must contain only 0 and 1");
            }
            if (ch == '1') {
                total += powerOfTwo;
            }
            powerOfTwo *= 2;
        }
        return total;
    }

    public static void main(String[] args) {
        String binaryNumber = "101010";
        long decimalNumber = binaryToDecimalManual(binaryNumber);
        System.out.println("Binary: " + binaryNumber);
        System.out.println("Decimal: " + decimalNumber);
    }
}

How It Works

After validation, the loop starts at the rightmost bit with weight 1. Each 1 contributes the current power of two; zeros are skipped. Doubling the weight avoids Math.pow.

⚡ Idiomatic Java

Same answer with the built-in parser.

Example 2 — Using Integer.parseInt(..., 2)

Validate first, then let Java parse the base-2 string.

java
public class Main {
    static int binaryToDecimalBuiltin(String bits) {
        bits = bits.trim();
        if (bits.isEmpty()) {
            throw new IllegalArgumentException("Binary string must contain only 0 and 1");
        }
        for (int i = 0; i < bits.length(); i++) {
            char ch = bits.charAt(i);
            if (ch != '0' && ch != '1') {
                throw new IllegalArgumentException("Binary string must contain only 0 and 1");
            }
        }
        return Integer.parseInt(bits, 2);
    }

    public static void main(String[] args) {
        String binaryNumber = "101010";
        System.out.println("Binary: " + binaryNumber);
        System.out.println("Decimal: " + binaryToDecimalBuiltin(binaryNumber));
    }
}

How It Works

Integer.parseInt(bits, 2) interprets the string in base 2. Keeping your own validation gives clearer error messages than a bare NumberFormatException.

🔁 Left-to-Right Variant

Horner / doubling form — no reverse needed.

Example 3 — Doubling Method

For each bit from the left: total = total * 2 + bit.

java
public class Main {
    static long binaryToDecimalDoubling(String bits) {
        bits = bits.trim();
        if (bits.isEmpty()) {
            throw new IllegalArgumentException("Binary string must contain only 0 and 1");
        }

        long total = 0;
        for (int i = 0; i < bits.length(); i++) {
            char ch = bits.charAt(i);
            if (ch != '0' && ch != '1') {
                throw new IllegalArgumentException("Binary string must contain only 0 and 1");
            }
            total = total * 2 + (ch == '1' ? 1 : 0);
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(binaryToDecimalDoubling("1010"));
        System.out.println(binaryToDecimalDoubling("00101"));
    }
}

How It Works

Each step shifts the previous total one bit left (multiply by 2) and adds the next bit. Leading zeros do not change the value — 00101 is still 5.

🧠 How the Algorithm Converts

1

Validate

Reject empty strings and any character that is not 0 or 1.

Guard
2

Walk the bits

Right-to-left with powers, left-to-right with doubling, or call Integer.parseInt(s, 2).

Scan
3

Accumulate

Add each 1-bit’s contribution into a running total.

Sum
=

Decimal result

Return the total — that is the base-10 value of the binary string.

Trace

🔎 Worked Walkthrough — 101010

Trace the place-value method from the right. Positions: 0 … 5.

Bit (right→left)PowerContributiontotal
0000
1122
0202
13810
04010
153242

Final decimal: 42 (= 32 + 8 + 2).

Use Cases

Where binary-to-decimal conversion shows up beyond the interview prompt.

1. Interview Warm-Ups

Tests place value, loops, and validation together.

Example: write binaryToDecimal(s).

2. Teaching Powers of Two

Makes 1, 2, 4, 8… memorable with 101010 → 42.

Example: chalkboard bit positions.

3. Config / Flag Strings

Some tools store compact bit masks as binary text.

Example: parse a permission bit string.

4. Gateway to Hex / Octal

Same place-value idea with different bases.

Example: Integer.parseInt(s, 16) for hex.

5. Complexity Practice

Argue O(k) from the bit length convincingly.

Example: “how many loop iterations?”

6. Big-Integer Awareness

Java int/long can overflow; use BigInteger for huge bit strings.

Example: discuss fixed-width overflow.

Pro Tip: keep validation in one helper so manual, doubling, and built-in paths share the same rules.

Advantages

Why this pattern works well in interviews and classwork.

  1. 1. Math Maps Cleanly

    Place values are exactly what the loop computes.

  2. 2. Easy Built-in Shortcut

    Integer.parseInt(s, 2) keeps application code short after you know the theory.

  3. 3. Tiny Extra Memory

    A few integers suffice — O(1) extra space beyond the input string.

  4. 4. Clear Validation Story

    Empty / invalid-character cases give interviewers easy follow-ups.

Pro Tip: say “rightmost bit is 20” before coding — it prevents off-by-one power mistakes.

Usage Tips

Small habits that keep binary conversion interview-ready.

  1. 1. Validate Before Converting

    Check non-empty and only 0/1 characters first.

  2. 2. Lead with Place Values

    In interviews, show the manual sum before Integer.parseInt(s, 2).

  3. 3. Strip Whitespace

    Call trim() so accidental spaces do not fail validation.

  4. 4. Spot-Check 101010

    Assert the result is 42 — a fast golden test.

  5. 5. Allow Leading Zeros

    They are valid padding; do not strip them as invalid.

Pro Tip: dry-run 101010 on paper once — it locks in right-to-left powers faster than guessing.

Common Pitfalls

Mistakes that commonly break binary-to-decimal solutions.

  1. 1. Starting Power from the Left

    Treating the leftmost bit as 20 reverses place values.

    → Rightmost bit is power 0 for the classic method.

  2. 2. Skipping Validation

    Digits like 2 or letters produce wrong results or cryptic errors.

    → Reject anything outside {0, 1} early.

  3. 3. Treating the String as an Integer

    Integer.parseInt("101010") without base 2 reads it as decimal one-hundred-one-thousand…

    → Always pass base 2: Integer.parseInt(bits, 2).

  4. 4. Rejecting Leading Zeros

    Padding zeros are valid binary.

    → Allow them; they do not change the value.

  5. 5. Ignoring Empty Input

    An empty string should error, not convert to 0 silently in every design.

    → Decide the policy and document it.

Edge Cases

Check these inputs before calling the solution done.

Invalid chars

Contains 2 or letters

Reject strings like 1021 or 10a1.

Empty input

No bits provided

Return a clear error instead of converting.

Leading zeros

Allowed

00101 is still valid and equals 5.

Single bit

0 or 1

Smallest non-empty cases — return 0 or 1.

Long strings

Use long / BigInteger

int/long can overflow; JS live preview is capped for safety.

Whitespace

Strip ends

Trim spaces before validating characters.

Math

⚖️ Facts Worth Knowing

Handy follow-ups interviewers sometimes ask.

  • Horner form. The doubling method is the same polynomial evaluation used in base conversion generally.
  • Unique representation. Every non-negative integer has a unique binary form without leading zeros (except 0 itself).
  • Inverse. Decimal-to-binary uses repeated division by 2 and collecting remainders.
  • Other bases. Integer.parseInt(s, radix) works for any base from 2 to 36.
Drill

🎯 Practice Problems

Try these variations to lock in the pattern.

1. Verify classics

  • 1010 → 10
  • 111 → 7
  • 101010 → 42

2. Reject invalid input

  • Raise on 1021 and empty string
  • Accept 00101

3. Implement both styles

  • Place-value and doubling
  • Assert they match Integer.parseInt(s, 2)

4. Decimal to binary

  • Write the inverse conversion
  • Round-trip test with the same helpers
Important

Notes

  • Place values. Add powers of two for every 1-bit from the right.
  • Always validate that the string contains only 0 and 1.
  • In interviews, show the manual method first; mention Integer.parseInt(bits, 2) second.
  • State O(k) time for k bits and O(1) extra space.

Quick Takeaway: sum 2i for each 1-bit (or call Integer.parseInt(bits, 2)) after validating the string.

Analysis

⏱️ Time and Space Complexity

ProgramTimeExtra space
Manual loop over bitsO(k)O(1)
Integer.parseInt(bits, 2)O(k)O(1)
Doubling methodO(k)O(1)
Wrap Up

🎉 Conclusion

Binary-to-decimal conversion is a clean place-value exercise: validate the bits, then sum powers of two (or use Integer.parseInt(s, 2)). Master the manual loop first, then the doubling and built-in shortcuts.

Practice the three examples above, then continue to common divisors for another classic number-theory warm-up.

Always validate 0/1 input, remember the rightmost bit is 20, and state O(k) for k bits.

View Examples Gallery Continue to Common Divisors
Pro Tips

💡 Best Practices

✅ Do

  • Validate non-empty 0/1 strings
  • Explain place values before coding
  • Test 101010 → 42 and leading zeros
  • Mention Integer.parseInt(bits, 2) as a shortcut
  • State O(k) time for k bits

❌ Don’t

  • Call Integer.parseInt(bits) without radix 2
  • Start powers from the left by accident
  • Accept digits other than 0 and 1
  • Reject leading zeros as invalid
  • Skip empty-string handling
Summary

Key Takeaways

Knowledge Unlocked

Five things to remember about binary to decimal

Convert base 2 the interview-friendly way.

5
Core concepts
2 01

Rule

Sum 2^i for 1-bits

Definition
← 02

Direction

Rightmost is 2^0

Math
V 03

Validate

Only 0 and 1

Guard
i 04

Built-in

Integer.parseInt(s, 2)

Code
O 05

Complexity

O(k) time

Analysis
🎯 You’re ready to convert binary to decimal in Java
Review Quick Reference →

❓ Frequently Asked Questions

You can use Integer.parseInt(binaryString, 2) or Long.parseLong(binaryString, 2), or convert manually by adding powers of 2 for each bit position.
Binary numbers can only contain 0 and 1. Validation prevents wrong answers and NumberFormatException from parseInt.
It parses the string s as a base-2 number and returns its decimal int value. Use Long.parseLong for larger bit strings.
O(k), where k is the number of bits.
Yes. int and long have fixed ranges. Use BigInteger for arbitrarily long binary strings, or reject inputs that exceed your type.
Yes. Values like 00101 are valid and equal to 5 in decimal.
For the place-value method, start from the rightmost bit as power 0. The doubling method walks left to right instead.
Treat it as invalid. Throw an exception or return a documented sentinel — do not convert silently.

Did you Know? 🔊

Binary 101010 means 32 + 8 + 2, so its decimal value is 42.

Continue to Common Divisors

Learn how to find all positive integers that divide two numbers evenly.

Common divisors tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

9 people found this page helpful

Java Program to find Biggest of three numbers Java Program to find Common Divisors