Java long Keyword

The long keyword in Java is used to declare a variable that can hold a 64-bit signed two’s complement integer. This data type is used when a wider range than int is needed.

Table of Contents

1. Introduction
2. long Keyword Syntax
3. Understanding long
4. Examples
   • Basic Usage
   • Arithmetic Operations
   • Array of Longs
5. Real-World Use Case
6. Conclusion

Introduction

The long data type is a 64-bit signed integer. It is used when a larger range than int is required, providing a vast range suitable for large numerical values.

long Keyword Syntax

The syntax for declaring a long variable is as follows:

long variableName;

Example:

long distance;

Understanding long

The long data type is a 64-bit signed integer. Its size is 8 bytes. The long data type can be used to store numeric values ranging from -2^63 to 2^63-1.

Minimum Value:

• -9,223,372,036,854,775,808

Maximum Value:

• 9,223,372,036,854,775,807

Examples

Basic Usage

To demonstrate the basic usage of the long keyword, we will declare a long variable and assign it a value.

Example

public class LongExample {
    public static void main(String[] args) {
        long population = 7830000000L;
        System.out.println("World population: " + population);
    }
}

Output:

World population: 7830000000

Arithmetic Operations

You can perform arithmetic operations on long variables just like with any other numeric data type.

Example

public class LongArithmetic {
    public static void main(String[] args) {
        long a = 10000000000L;
        long b = 20000000000L;
        long sum = a + b;
        long diff = a - b;
        long product = a * b;
        long quotient = a / b;
        long remainder = a % b;

        System.out.println("Sum: " + sum);
        System.out.println("Difference: " + diff);
        System.out.println("Product: " + product);
        System.out.println("Quotient: " + quotient);
        System.out.println("Remainder: " + remainder);
    }
}

Output:

Sum: 30000000000
Difference: -10000000000
Product: -2914184810805067776
Quotient: 0
Remainder: 10000000000

Array of Longs

An array of long can be declared and used to store a sequence of long values.

Example

public class LongArrayExample {
    public static void main(String[] args) {
        long[] longArray = {1000000000L, 2000000000L, 3000000000L, 4000000000L, 5000000000L};
        for (long l : longArray) {
            System.out.println("Long value: " + l);
        }
    }
}

Output:

Long value: 1000000000
Long value: 2000000000
Long value: 3000000000
Long value: 4000000000
Long value: 5000000000

Real-World Use Case

Handling Large Numerical Data

In real-world applications, the long data type is useful for handling large numerical data, such as financial calculations, timestamps, and large counts.

Example

public class FinancialCalculations {
    public static void main(String[] args) {
        long principal = 1000000000L; // 1 billion
        double rate = 0.05; // 5% interest rate
        int years = 10;

        long amount = principal;
        for (int i = 1; i <= years; i++) {
            amount += (long) (amount * rate);
        }

        System.out.println("Total amount after " + years + " years: " + amount);
    }
}

Output:

Total amount after 10 years: 1628894625

Conclusion

The long keyword in Java is a powerful data type for storing 64-bit signed integer values. It provides a significantly larger range than int, making it suitable for applications that require large numerical values. By understanding and using the long data type, you can efficiently manage and perform various operations on large integer values in your Java applications.