CODEWITHSUNDEEP
javalong-integernumberformatexception
Julie P
Julie P

Reputation: 29

Any datatype for integers longer than a Long?

I want to convert binary to an integer, multiply it by 17, then convert it back to binary. This is my code:

Scanner scan = new Scanner(System.in);
String n = scan.nextLine();
long j = Long.parseLong(n, 2);
j = j * 17;
System.out.println(Long.toBinaryString(j));

I originally made j an int but changed it once I got a bigger test case:

10001111110001000101000001000100111100110101100011000011011001111000100110110000110101110101100001001100010111000101000100010010011000000010010

It had a NumberFormatException, which makes sense because longs can only store a limited amount of digits, so are there any datatypes for very long integers?

Upvotes: 0

Views: 1139

Answers (3)

Andreas
Andreas

Reputation: 159135

Use BigInteger when calculations exceeds capacity of long, e.g.

String input = "10001111110001000101000001000100111100110101100011000011011001111000100110110000110101110101100001001100010111000101000100010010011000000010010";

// parse binary string
BigInteger num1 = new BigInteger(input, 2);

// multiply by 17
BigInteger num2 = num1.multiply(BigInteger.valueOf(17));

// format as binary string
String output = num2.toString(2);

System.out.println(output);

Output

100110001100000010010101010010010100001010001110010011111001111000000010010010111110010011001101110100010010001000010110001000111000011000100110010

Upvotes: 0

Alaric Dobson
Alaric Dobson

Reputation: 302

For example:

import org.junit.Test;

import java.util.function.Function;

public class BinTest
{
    String binNo1 = "100011111100010001010000010001001111001101011000";
    String binNo2 = "10001111110001000101000001000100111100110101100011000011011001111000100110110000110101110101100001001100010111000101000100010010011000000010010";

    @Test
    public void testIt()
    {
        //System.out.println( bin17A( binNo1 ) );
        System.out.println( bin17S( binNo2 ) );
    }



    public static String bin17S( String bin )
    {
        // * 16
        String bin16 = bin + "0000";
        String bin01 = "0000" + bin;
        StringBuilder result = new StringBuilder();

        Function<Character, Integer> parser = c -> (c == '1') ? 1 : 0;

        int carry = 0;
        for ( int i = bin16.length() - 1; i >= 0; i-- )
        {
            int value = parser.apply( bin16.charAt( i ) )
                    + parser.apply( bin01.charAt( i ) )
                    + carry;

            carry = value / 2;

            result.insert(0, value % 2 );
        }
        while (carry > 0)
        {
            result.insert(0,carry % 2 );
            carry = carry / 2;
        }
        return result.toString();
    }


    public static String bin17A( String bin )
    {
        long j = Long.parseLong( bin, 2 );
        j = j * 17;
        return Long.toBinaryString( j );
    }

}

Upvotes: -1

Aravind.HU
Aravind.HU

Reputation: 9472

Did you tried BigInteger or BigDecimal.

https://www.baeldung.com/java-bigdecimal-biginteger

These two types are specifically meant for situations where numbers are required to have a large or arbitrary range like some value > or = to 1x10^307 and less than 1x10^-307

public void whenBigDecimalCreated_thenValueMatches() {
    BigDecimal bdFromString = new BigDecimal("0.1");
    BigDecimal bdFromCharArray = new BigDecimal(new char[] {'3','.','1','6','1','5'});
    BigDecimal bdlFromInt = new BigDecimal(42);
    BigDecimal bdFromLong = new BigDecimal(123412345678901L);
    BigInteger bigInteger = BigInteger.probablePrime(100, new Random());
    BigDecimal bdFromBigInteger = new BigDecimal(bigInteger);
        
    assertEquals("0.1",bdFromString.toString());
    assertEquals("3.1615",bdFromCharArray.toString());
    assertEquals("42",bdlFromInt.toString());
    assertEquals("123412345678901",bdFromLong.toString());
    assertEquals(bigInteger.toString(),bdFromBigInteger.toString());
}

That should help you .

Upvotes: 3

Related Questions