How to Add Two Numbers in Java

Adding two numbers is the first arithmetic most people write in Java, but the "right" way depends on where the numbers come from and how large they can get. This chapter covers the idiomatic approaches: literal int math, parsing values from text, floating-point addition, and adding safely without silent overflow.

Adding two int values

The simplest case is adding two int variables with the + operator, one of Java's arithmetic operators. The result is itself an int.

int a = 7;
int b = 5;
int sum = a + b;
System.out.println(sum); // 12

This is the everyday case and the one you will write most. The only thing to watch for is the range of int: it holds values from -2,147,483,648 to 2,147,483,647. Add past that limit and the value silently wraps around instead of throwing — covered below.

Adding numbers parsed from text

When the numbers arrive as strings — from console input, a file, or an HTTP request — you must convert them before adding. Use Integer.parseInt for whole numbers or Double.parseDouble for decimals.

String first = "42";
String second = "58";
int sum = Integer.parseInt(first) + Integer.parseInt(second);
System.out.println(sum); // 100

A common beginner mistake is using + directly on the strings: "42" + "58" produces "4258" because + concatenates strings rather than adding them. Parse first, then add. If the text is not a valid number, parseInt throws NumberFormatException, so validate or wrap the call in a try/catch when the input is untrusted.

Adding decimals and handling overflow

For decimal values, add double (or float) operands. Be aware that binary floating-point cannot represent every decimal exactly, so 0.1 + 0.2 is 0.30000000000000004, not 0.3. For money, use BigDecimal instead.

For whole numbers that may exceed the int range, widen one operand to long, or use Math.addExact to turn overflow into an exception rather than a wrong answer. Picking the right numeric type up front is the cleanest defense — see Java data types for each type's range.

int big = Integer.MAX_VALUE;
System.out.println(big + 1);               // -2147483648 (wrapped!)
System.out.println((long) big + 1);        // 2147483648 (correct)
System.out.println(Math.addExact(big, 1)); // throws ArithmeticException

Adding two numbers entered by the user

In a real program the operands often come from the keyboard. A Scanner reads each line and converts it to a number in one step with nextInt (or nextDouble for decimals), so you do not have to call parseInt yourself.

import java.util.Scanner;

public class AddInput {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter first number: ");
        int a = scanner.nextInt();
        System.out.print("Enter second number: ");
        int b = scanner.nextInt();
        System.out.println("Sum: " + (a + b));
    }
}

If the user types something that is not an integer, nextInt throws InputMismatchException. Guard against it with hasNextInt() or a try/catch when the input is untrusted.

A worked example

What to take from the run:

• int sum: 12 shows the plain + operator adding two int values directly — the everyday case.
• parsed sum: 100 confirms that Integer.parseInt turns "42" and "58" into numbers before adding, rather than concatenating them into "4258".
• double sum: 0.30000000000000004 is the floating-point representation error from 0.1 + 0.2 — proof that double is not exact for decimals, so reach for BigDecimal when precision matters.
• int overflow: -2147483648 shows Integer.MAX_VALUE + 1 wrapping silently to the most negative int, while long safe: 2147483648 gives the correct answer by widening one operand to long.
• addExact: overflow detected confirms that Math.addExact throws ArithmeticException on the same overflow instead of returning a wrong value.

Practice