long

About

• Definition: The long data type is a primitive data type in Java used to represent a 64-bit signed integer. It is typically used when a wider range of integer values is needed, beyond the limits of the int type.

• Size: Occupies 8 bytes (64 bits) in memory.

• Value Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 (-2^63 to 2^63 - 1).

• Default Value: The default value of long is 0L.

• Wrapper Class: The wrapper class for long is Long, located in java.lang.

Characteristics of long

1. Signed Integer Representation:

   • The long type is signed, allowing both positive and negative values.

2. Memory Usage:

   • It consumes 8 bytes (64 bits) of memory, which provides a much larger range than int.

3. Default Choice for Large Numbers:

   • long is chosen when working with numbers that exceed the limits of the int type, particularly in financial calculations, timestamps, and large data processing.

4. Promotion in Expressions: In expressions involving long and other numeric types, Java promotes the long to a larger type (double) when necessary, but long is not promoted to int to avoid loss of precision. Example:

   long a = 10L;
   double result = a / 2.0; // Promoted to double

5. Performance: Although long requires more memory (8 bytes compared to int's 4 bytes), it is still quite efficient in most modern systems and is optimized for use in operations that require large numbers.

6. Interoperability: long is used in many systems for time-based calculations (e.g., Unix timestamps), database IDs, and large counters that go beyond the capacity of int.

Memory

• Memory Usage: Each long occupies 8 bytes of memory (64 bits). This allows for a significantly larger range of values compared to int.

Operations with long

Arithmetic and Logical Operations

Operation	Example	Description
Arithmetic Operations	long sum = a + b;	Addition, subtraction, multiplication, division.
Comparison Operations	a == b, a > b, etc.	Compares two long values.
Bitwise Operations	a & b, `a	b`, etc.

Conversion Methods

Conversion	Method	Example
long to String	String.valueOf(long)	String.valueOf(123456L) → "123456"
String to long	Long.parseLong(String)	Long.parseLong("123456") → 123456
long to int	Explicit cast (int)	(int) 123456L → 123456
int to long	Implicit conversion	long largeValue = 123456;

Wrapper Class Example (Long)

Method	Description
Long.valueOf(long l)	Returns a Long object for the given long value.
Long.parseLong(String s)	Parses the string argument as a long.
Long.toString(long l)	Converts long to its String representation.
Long.compare(long x, y)	Compares two long values.
Long.MIN_VALUE	Minimum value of long (-9,223,372,036,854,775,808).
Long.MAX_VALUE	Maximum value of long (9,223,372,036,854,775,807).

Common Mistakes

1. Integer Overflow: If an operation exceeds the range of long, it can cause overflow:

   long max = Long.MAX_VALUE;
   max = max + 1; // Overflow
   System.out.println(max); // Output: -9223372036854775808

2. Implicit Type Conversion: When performing operations involving long and other types, Java will promote long to a double if mixed with floating-point numbers:

   long a = 10L;
   double b = 5.5;
   double result = a + b; // Promoted to double
   System.out.println(result); // Output: 15.5

Examples

Basic Example

public class LongExample {
    public static void main(String[] args) {
        long num1 = 100000L;
        long num2 = 200000L;

        // Arithmetic operations
        long sum = num1 + num2; 
        System.out.println("Sum: " + sum); // Sum: 300000

        // Comparing values
        System.out.println("Is num1 greater than num2? " + (num1 > num2)); // Is num1 greater than num2? false

        // Casting
        int smallerValue = (int) num1; // Cast long to int
        System.out.println("Casted Value: " + smallerValue); // Casted Value: 100000
    }
}

Using long in Arrays

public class LongArrayExample {
    public static void main(String[] args) {
        long[] longArray = {10L, 20L, 30L};

        for (long value : longArray) {
            System.out.println(value); // 10, 20, 30
        }
    }
}

Converting long to String

public class LongConversion {
    public static void main(String[] args) {
        long num = 123456L;
        String str = Long.toString(num); 
        System.out.println("Long as String: " + str); // Long as String: 123456
    }
}

Using long in Streams

import java.util.stream.LongStream;

public class LongStreamExample {
    public static void main(String[] args) {
        long[] longArray = {100L, 200L, 300L};

        LongStream.of(longArray)
                  .map(x -> x * 2)
                  .forEach(System.out::println); // 200, 400, 600
    }
}

Bitwise Operations with long

public class LongBitwiseExample {
    public static void main(String[] args) {
        long a = 5L;  // 0101 in binary
        long b = 3L;  // 0011 in binary

        System.out.println("Bitwise AND: " + (a & b)); // Bitwise AND: 1
        System.out.println("Bitwise OR: " + (a | b));  // Bitwise OR: 7
        System.out.println("Bitwise XOR: " + (a ^ b)); // Bitwise XOR: 6
    }
}

Using long with Collections (Boxed Long)

import java.util.*;

public class LongCollectionExample {
    public static void main(String[] args) {
        List<Long> list = Arrays.asList(100L, 200L, 300L);
        list.forEach(System.out::println); // 100, 200, 300
    }
}

Wrapper Class Example

public class LongWrapperExample {
    public static void main(String[] args) {
        String strValue = "123456789";
        long parsedValue = Long.parseLong(strValue); 
        System.out.println("Parsed Value: " + parsedValue); // Parsed Value: 123456789

        long minValue = Long.MIN_VALUE; 
        long maxValue = Long.MAX_VALUE; 
        System.out.println("Min Value: " + minValue); // Min Value: -9223372036854775808
        System.out.println("Max Value: " + maxValue); // Max Value: 9223372036854775807
    }
}