Develop Reference

Why am I getting a number format exception when the data type accepts the values im parsing?

I do not want the answer, I would just like guidance and for someone to point to why my code is not performing as expected
My task is to flip an integer into binary, reformat the binary to a 32 bit number and then return the unsigned integer. So far my code successfully makes the conversions and flips the bits however I am getting a NumberFormatException when I attempt to parse the string value into a long that ill convert to an unsigned integer.
What is the issue with my code? What have I got misconstrued here? I know there are loads of solutions to this problem online but I prefer working things out my own way?
Could I please get some guidance? Thank you
public class flippingBits {
public static void main(String[] args) {
//change the number to bits
long bits = Long.parseLong(Long.toBinaryString(9));
String tempBits = String.valueOf(bits);
//reformat so that you get 32 bits
tempBits = String.format("%" + (32) + "s", tempBits).replace(" ", "0");
//flip the bits
tempBits = tempBits.replace("1", "5");
tempBits = tempBits.replace("0", "1");
tempBits = tempBits.replace("5", "0");
//Pass this to a long data type so that you can then eventually convert the new bits
// to an unsigned integer
long backToNum = Long.parseLong(tempBits);
}
}

You're directly parsing the bits into a long value instead of converting the bits into an equivalent value.
You need to use the following method (Long.parseUnsignedLong()):
long backToNum = Long.parseUnsignedLong(tempBits, 2); //output: 4294967286
The second argument represents radix:
To interpret a number written in a particular representation, it is necessary to know the radix or base of that representation. This allows the number to be converted into a real value.
See the representation of each radix (From Wikipedia):

Trying to find length of INT, converted to String but errors after anything > 10

I'm having trouble trying to find the length of a int inputted. I converted the int value into a string and it works perfectly up until the user inputs any int that has more than 10 digits. The program will print out how many digits were inputted but it gives some boundary error once I put anything >10 digits
answer = in.nextInt();
answerString = String.valueOf(answer);
answerLength = answerString.length();
System.out.println(answerLength);

The reason for this is because the max value for an Integer is 2147483647. If you need more digits than that consider using long.

take input as String even if it is integer value, see below code.
String answer = in.nextLine();
System.out.println(answer.length());

Using more than 10 digits goes over Integer.MAX_VALUE. BigInteger would be more suitable in your case, but be aware of its memory restrictions as mentioned here.

Just use Long answer = in.nextLong(); instead

Java - Multiplication not working as expected

the below code gives me -1894967296 as result but this is not expected. What is exactly happening? I can't figure it out. The result has to be 2400000000 as per my calculator :(
import java.util.List;
import java.util.ArrayList;
public class Calculate{
public static void main(String []args){
int result = 1;
List<Integer> integer = new ArrayList<Integer>();
integer.add(100);
integer.add(200);
integer.add(300);
integer.add(400);
for (Integer value : integer) {
result *= value;
}
System.out.println(result);
}
}
When I debug, it works correctly till the third iteration.
Update:
As per the answers, the int primitive type range has been exceeded but what will happen to the int variable? It will be defaulted to some value?

The largest number Java can store in an int is 2^31 - 2147483648
2400000000 is larger than that so "wraps around".
You need to use a 64 bit data type such as long.

2400000000 is too large to store in an int. It would be more appropriate to use a long which has a minimum value of -2^63 and maximum value of 2^63 - 1 which your number is well within the range of.
more info here

The expected result 2400000000 > Integer.MAX_VALUE. So, use long instead of int to store result.

Use BigInteger instead of int because the int is limited
Java doc:
int: By default, the int data type is a 32-bit signed two's complement integer, which has a > minimum value of -231 and a maximum value of 231-1. In Java SE 8 and later, you can use the int data type to represent an unsigned 32-bit integer, which has a minimum value of 0 and a maximum value of 232-1. Use the Integer class to use int data type as an unsigned integer. See the section The Number Classes for more information. Static methods like compareUnsigned, divideUnsigned etc have been added to the Integer class to support the arithmetic operations for unsigned integers.

That's what most programmer call Pillage. You shouldn't save a long value inside a small variable, don't expect an Int to save a value 2^31+.
For what you want to do there's a long

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().

Why does trying to parse this value result in a NumberFormatException?

Code:
String myVar = "1255763710960";
int myTempVar=0;
try
{
myTempVar = Integer.valueOf(myVar);
}
catch (NumberFormatException nfe)
{
System.out.println(nfe.toString());
}
Output:
java.lang.NumberFormatException:
For input string: "1255763710960"
I have absolutely no idea why this is.

The value you're trying to store is too big to fit in an integer. The maximum value for an Integer is 231-1, or about 2 billion. This number exceeds that by several orders of magnitude.
Try using a Long and parseLong() instead.

Java Integer maximun value is 2^31-1=2147483647
You should use Long.valueof()

Your String representation is too big (>Integer.MAX_VALUE) for parsing to an int. Try a long instead.

1255763710960 is more than Integer.MAX_VALUE which is 2147483647, so that value doesn't fit in an int.
You'll need to use a long and Long.valueOf() (or better yet Long.parseLong() to avoid unnecessary auto-unboxing) to parse that value.