Develop Reference

Why doesn't java store large value in long datatype directly but allows to store it indirectly (without using literals)? [duplicate]

This question already has answers here:
Initialize a long in Java
(4 answers)
The literal xyz of type int is out of range
(5 answers)
Why, In Java arithmetic, overflow or underflow will never throw an Exception?
(4 answers)
Closed 4 years ago.
Here are my 2 examples:
1. Directly assigned value to long data type:
long a = 12243221112432;
I get an error:
integer number too large
But when assisgned like this:
ArrayList<Integer> al = new ArrayList<Integer>();
al.add(12);
al.add(24);
al.add(32);
al.add(21);
al.add(11);
al.add(24);
al.add(32);
long a=0;
for(int i=0; i<al.size(); i++){
a = a*100 + al.get(i);
}
System.out.println(a);
I get this output:
12243221112432
Why doesn't java throw an error in second example?
It isn't allowing to assign large value directly(example 1) but indirectly(example 2) it stores it and also allows me to use it too!
What is the reason for this to occur?
Is it because i am using integer in arraylist or something else?
UPDATE
Why is the large value stored in 'long a' in second example without using literal L?
It should have given me an error during 5th or 6th iteration of for loop...
Note
My question is not regarding the first example... I am asking why it worked for the second example...
Dont mark the question duplicate, since the other questions do not have my answer..stated above

For your assignment to work, you need to write it that way
long a = 12243221112432L;
This will indicate the compiler that your input is a long, not an int

integer number too large
as the error said, the number 12243221112432 is too large for an integer, it does not says that this number cannot fit into a long
Te be able to have this number, you have to make it a long by using the l or L indice : 12243221112432L
long : l L : 1716L
float : f F : 3.69F
double : d D : 6936D

Number Format Exception Errors

I get this error whenever I run my program:
Exception in thread "main" java.lang.NumberFormatException: For input string: "9999997560"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
at java.lang.Integer.parseInt(Integer.java:461)
at java.lang.Integer.valueOf(Integer.java:554)
at jsobcpuburnerpd3.Main.main(Main.java:22)
Java Result: 1
The program has two do-while loops that are nearly identical, and the first works perfectly. I only have problems with the second one.
BigDecimal lower = new BigDecimal("1000001520");
BigDecimal upper = new BigDecimal("9999997560");
int var = 2520;
String strL = lower.toString();
Integer intL = Integer.valueOf(strL);
String strU = upper.toString();
Integer intU = Integer.valueOf(strU);
Both numbers have the same amount of digits, and are converted to Integer the same way. Both are handled nearly the same way in the loops.
intL = intL + var;
intU = intU - var;
I have also attempted this without converting from BigDecimal to String, and inputting the number directly to String, but still got the same error.
EDIT I am using BigDecimal because it's a part of what my teacher wanted us to use in our work. I know it's not needed.

Obviously you will get a number format exception because the maximum value that can be store in an Integer is 2,147,483,647 which is less than 9,999,997,560.
On the other hand 1,000,001,520 is less than 2,147,483,647 which is why that works fine.
(Edit Based on Tunaki's suggestion) FYI - Moreover you really don't have to use a BigDecimal because it seems that the only reason you need it is to convert it to an Integer. So it is not required.
Also an Integer is not required because you don't seem to be requiring a reference type and hence the primitive type int should be apt. Moreover in your for loop you are adding and subtracting values from Integer which will lead to unnecessary boxing and unboxing and will be very inefficient. So use the primitive type int which would be better.

Convert the BigInteger to Integer using intValue() Method
BigDecimal lower = new BigDecimal("1000001520");
BigDecimal upper = new BigDecimal("9999997560");
Integer intBL = lower.intValue();
Integer intBU = upper.intValue();

Exception in thread "AWT-EventQueue-0" java.lang.NumberFormatException: For input string: "11101110110100011110111011010001"

I wanna convert String to Binary Integer like this int k = 0B1101.....0111
and the error showen is :
Exception in thread "AWT-EventQueue-0" java.lang.NumberFormatException: For input string: "11101110110100011110111011010001"
String a = "1110111011010001",
b = "11101110110101010110111011010001";
int K = Integer.parseInt(a.trim(),2);
int T = Integer.parseInt(b.trim(),2);

You get an exception because the 32-bit number that you pass represents a negative integer, so from parseInt's perspective it overflows an int.
You have two solutions to parse the number:
(1) Pass a negative representation with a minus sign, i.e.
System.out.println(Integer.parseInt("-0010001001011100001000100101111", 2));
or (2) pass the original number to parseLong, and cast the result to int, i.e.
System.out.println((int)Long.parseLong("11101110110100011110111011010001", 2));
Both snippets produce a negative value of -288231727 (demo).

This is because its above the Integer Limits of java.
Try using long instead of int.

parseInt throws error

I have this small piece of code in java which throws the following error when the code is run
Exception in thread "main" java.lang.NumberFormatException: For input string: "10000000000"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
at java.lang.Integer.parseInt(Integer.java:495)
at java.lang.Integer.parseInt(Integer.java:527)
at hello.main(hello.java:6)
public class hello {
public static void main(String args[])
{
int x = 1024;
String h = Integer.toString(x, 2);
int xx = 9*(Integer.parseInt(h));
System.out.println(xx);
}
}
I suspect that this problem is related to the size of the values/parseInt. Can you please explain the reason for this error to me in detail.

This is because this surpasses the maximum value for an integer of 2,147,483,647

You are getting java.lang.NumberFormatException: For input string: "10000000000" because it exceed the range of int.
integer is a signed 32-bit type that has a range from –2,147,483,648 to 2,147,483,647.
long is a signed 64-bit type and is useful for those occasions where an int type is not large enough to hold the desired value, range is from –9,223,372,036,854,775,808 to
9 ,223,372,036,854,775,807. This makes it useful when big, whole numbers are needed.
Try this line of code-
long xx = 9*(Long.parseLong(h));

You are receiving this error because you are trying to parse a value too large for the Integer type. Try using Long instead.

Cannot convert String to Integer in Java [duplicate]

This question already has answers here:
How do I convert a String to an int in Java?
(47 answers)
Closed 5 years ago.
I have written a function to convert string to integer
if ( data != null )
{
int theValue = Integer.parseInt( data.trim(), 16 );
return theValue;
}
else
return null;
I have a string which is 6042076399 and it gave me errors:
Exception in thread "main" java.lang.NumberFormatException: For input string: "6042076399"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
at java.lang.Integer.parseInt(Integer.java:461)
Is this not the correct way to convert string to integer?

Here's the way I prefer to do it:
Edit (08/04/2015):
As noted in the comment below, this is actually better done like this:
String numStr = "123";
int num = Integer.parseInt(numStr);

An Integer can't hold that value. 6042076399 (413424640921 in decimal) is greater than 2147483647, the maximum an integer can hold.
Try using Long.parseLong.

That's the correct method, but your value is larger than the maximum size of an int.
The maximum size an int can hold is 231 - 1, or 2,147,483,647. Your value is 6,042,076,399. You should look at storing it as a long if you want a primitive type. The maximum value of a long is significantly larger - 263 - 1. Another option might be BigInteger.

That string is greater than Integer.MAX_VALUE. You can't parse something that is out of range of integers. (they go up to 2^31-1, I believe).

In addition to what the others answered, if you have a string of more than 8 hexadecimal digits (but up to 16 hexadecimal digits), you could convert it to a long using Long.parseLong() instead of to an int using Integer.parseInt().