We Keep Coding

java BigInteger manipulation

The following code is for debugging:
public static void main(String[] args) {
BigInteger n = new BigInteger("10000000001");
String sn = n.toString();
char[] array = sn.toCharArray();
//intend to change value of some char in array
//not standard math operation
BigInteger result = new BigInteger(array.toString());
}
It gives me error:
Exception in thread "main" java.lang.NumberFormatException: For input string: "[C#86c347"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
at java.lang.Integer.parseInt(Integer.java:449)
at java.math.BigInteger.<init>(BigInteger.java:316)
at java.math.BigInteger.<init>(BigInteger.java:451)
at debug.main(debug.java:14)
But it was working fine, until this case, I'm not quite sure what went wrong.

When in doubt, add more diagnostics... taking out statements which do two things. This:
array.toString()
won't do what you expect it to, because arrays don't override toString(). It'll be returning something like "[C#89ffb18". You can see this by extracting an extra local variable:
BigInteger n = new BigInteger("10000000001");
String sn = n.toString();
char[] array = sn.toCharArray();
String text = array.toString();
BigInteger result = new BigInteger(text);
Then in the debugger you should easily be able to look at the value of text before the call to BigInteger - which would show the problem quite clearly.
To convert a char array to a string containing those characters, you want:
new String(array)

Parsing long fails for large input in Java

I'm trying to read a very large input as String and then converting it into long as per follows:[The program works for short input]
The input is two int separated by a space, example: "1248614876148768372675689568324619856329856295619253291561358926935829358293587932857923857934572895729511 413241"
My Code:
import java.io.*;
import java.math.*;
import java.util.*;
public class Solution {
public static void main(String args[] ) throws Exception {
Solution obj = new Solution();
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int T = Integer.parseInt(br.readLine());
String input[]=new String[T];
for (int i=0;i<T;i++) {
input[i] = br.readLine();
}
for (int i=0;i<T;i++){
StringTokenizer st = new StringTokenizer(input[i]," ");
BigInteger N = new BigInteger(st.nextToken());
BigInteger P = new BigInteger(st.nextToken());
System.out.println(obj.result(N,P));
}
}
}
public BigInteger result(BigInteger N, BigInteger P){
BigInteger temp=1;
BigInteger c=0;
for (BigInteger i=0;i<=N;i++){
//System.out.println(nck(N,i));
if ((nck(N,i)%P) ==0)
c++;
}
return c;
}
public BigInteger nck(BigInteger N, BigInteger k){
if (k==0)
return 1;
else {
BigInteger temp=1;
BigInteger y=1;
BigInteger z=N;
while(k>=1){
temp=temp*z/y;
y++;
z--;
k--;
}
return temp;
}
}
}
I'm getting a java.lang.NumberFormatException

You can't parse this string into a long, it's too great (greater than Long.MAX_VALUE), you need BigInteger :
BigInteger bi = new BigInteger(st.nextToken());
Following your edit :
Don't try to iterate over a bigInteger : if it's too great to fit in a long, the loop will be too long for your time. Compare it with a reasonable limit and if it's smaller, then get it as int and enter your loop:
BigInteger MAX = new BigInteger("1000000");
if (bi.compareTo(MAX)<0) {
int N = bi.intValue();
for (int i=0; i<N; i++) {
Test...
}
}

If throws NumberFormatException because 248614876148768372675689568324619856329856295619253291561358926935829358293587932857923857934572895729511 is greater than Long.MAX_VALUE (which is 9223372036854775807).

As pointed out by others the valuse is too big for long However another problem is that there can be no spaces in the string which is being converted. There is a handy post on removeing white space from a string here
"The sequence of characters following an (optional) negative sign and/or radix specifier ("0x", "0X", "#", or leading zero) is parsed as by the Long.parseLong method with the indicated radix (10, 16, or 8). This sequence of characters must represent a positive value or a NumberFormatException will be thrown. The result is negated if first character of the specified String is the minus sign. No whitespace characters are permitted in the String." From the Docs

The value is too big for a long to hold. Primitive Data Types
I wonder what you are trying to do with so big integer but what you might be looking for is a BigInteger.
Immutable arbitrary-precision integers. All operations behave as if BigIntegers were represented in two's-complement notation (like Java's primitive integer types). BigInteger provides analogues to all of Java's primitive integer operators, and all relevant methods from java.lang.Math. Additionally, BigInteger provides operations for modular arithmetic, GCD calculation, primality testing, prime generation, bit manipulation, and a few other miscellaneous operations.
It provides methods for mathematical operations. Should also note that since it's immutable, any operation you perform on a BigInteger returns a new BigInteger.

Remember that when changing from type int to BigInteger you are then dealing with an object rather than a primitive. The BigInteger (String val) is probably the most useful constructor.
(i.e.) BigInteger temp = new BigInteger("1");

Converting strings to integers and adding them in Java

I have 4 strings:
str1 = 10110011;(length of all string is:32)
str2 = 00110000;
str3 = 01011000;
str4 = 11110000;
In my project I have to add these string and the result should be:
result[1] = str1[1]+str2[1]+str3[1]+str4[1];
result should be obtained as addition of integer numbers.
For the example above, result = 22341011
I know integer to string conversion in Java is very easy but I found string to integer conversion a little harder.

To parse Integers -2^31 < n < 2^31-1 use:
Integer value = Integer.valueOf("10110011");
For numbers that are larger, use the BigInteger class:
BigInteger value1 = new BigInteger("101100111011001110110011101100111011001110110011");
BigInteger value2 = // etc
BigInteger result = value1.add(value2).add(value3); //etc.

The simplest way to do this is with Integer.parseInt(str1). Returns an int containing the value represented by the string.
valueOf() returns an Integer object, rather than an int primitive.

Because your numbers are so big they will not fit in an int. Use the BigInteger class.

I am not known about your project and what actually your problem is. But I came to guess from your partial information that, you have multiple set of strings in bit representation as you explained.
str1 = "1000110.....11";
str1 = "1110110.....01"; etc
adding those decimal values,gives an ambiguous result as an integer can be the sum of multiple integer values. Just see an example below where there are total 5 possibilities[with positive decimal values] to yield 6.
1+5 = 6;
2+4 = 6;
3+3 = 6;
4+2 = 6;
5+1 = 6;
If you proceed in that way you just do an error,nothing else in your case.
One better solution can be,
compute the decimal values of individual strings. Instead of adding(+) them, just concat(join) them to form a single string.
I am suggesting this approach because, This gives always a unique value and later you may need to know individual strings decimal values.
String strVal1 = String.format(computeDecimal(str1));
String strVal2 = String.format(computeDecimal(str2));
String strVal3 = String.format(computeDecimal(str3));
.
.
.
String strValn = String.format(computeDecimal(strn));
String myVal = String.concate(strVal1,strVal1,strVal1,....strValn);
Now you can treat your string as your wish.
//This will give you a non conflicting result.
Better to implement above approach than BigIntegers.
Hope this helps you greatly.

java convert to int

I am trying to convert to int like this, but I am getting an exception.
String strHexNumber = "0x1";
int decimalNumber = Integer.parseInt(strHexNumber, 16);
Exception in thread "main" java.lang.NumberFormatException: For input string: "0x1"
at java.lang.NumberFormatException.forInputString(NumberFormatException.java:48)
at java.lang.Integer.parseInt(Integer.java:458)
It would be a great help if someone can fix it.
Thanks.

That's because the 0x prefix is not allowed. It's only a Java language thing.
String strHexNumber = "F777";
int decimalNumber = Integer.parseInt(strHexNumber, 16);
System.out.println(decimalNumber);
If you want to parse strings with leading 0x then use the .decode methods available on Integer, Long etc.
int value = Integer.decode("0x12AF");
System.out.println(value);

Sure - you need to get rid of the "0x" part if you want to use parseInt:
int parsed = Integer.parseInt("100", 16);
System.out.println(parsed); // 256
If you know your value will start with "0x" you can just use:
String prefixStripped = hexNumber.substring(2);
Otherwise, just test for it:
number = number.startsWith("0x") ? number.substring(2) : number;
Note that you should think about how negative numbers will be represented too.
EDIT: Adam's solution using decode will certainly work, but if you already know the radix then IMO it's clearer to state it explicitly than to have it inferred - particularly if it would surprise people for "035" to be treated as octal, for example. Each method is appropriate at different times, of course, so it's worth knowing about both. Pick whichever one handles your particular situation most cleanly and clearly.

Integer.parseInt can only parse strings that are formatted to look just like an int. So you can parse "0" or "12343" or "-56" but not "0x1".

You need to strip off the 0x from the front of the string before you ask the Integer class to parse it. The parseInt method expects the string passed in to be only numbers/letters of the specified radix.

try using this code here:-
import java.io.*;
import java.lang.*;
public class HexaToInteger{
public static void main(String[] args) throws IOException{
BufferedReader read =
new BufferedReader(new InputStreamReader(System.in));
System.out.println("Enter the hexadecimal value:!");
String s = read.readLine();
int i = Integer.valueOf(s, 16).intValue();
System.out.println("Integer:=" + i);
}
}

Yeah, Integer is still expecting some kind of String of numbers. that x is really going to mess things up.

Depending on the size of the hex, you may need to use a BigInteger (you can probably skip the "L" check and trim in yours ;-) ):
// Convert HEX to decimal
if (category.startsWith("0X") && category.endsWith("L")) {
category = new BigInteger(category.substring(2, category.length() - 1), 16).toString();
} else if (category.startsWith("0X")) {
category = new BigInteger(category.substring(2, category.length()), 16).toString();
}

How to convert BigInteger to String in java

I converted a String to BigInteger as follows:
Scanner sc=new Scanner(System.in);
System.out.println("enter the message");
String msg=sc.next();
byte[] bytemsg=msg.getBytes();
BigInteger m=new BigInteger(bytemsg);
Now I want my string back. I'm using m.toString() but that's giving me the desired result.
Why? Where is the bug and what can I do about it?

You want to use BigInteger.toByteArray()
String msg = "Hello there!";
BigInteger bi = new BigInteger(msg.getBytes());
System.out.println(new String(bi.toByteArray())); // prints "Hello there!"
The way I understand it is that you're doing the following transformations:
String -----------------> byte[] ------------------> BigInteger
String.getBytes() BigInteger(byte[])
And you want the reverse:
BigInteger ------------------------> byte[] ------------------> String
BigInteger.toByteArray() String(byte[])
Note that you probably want to use overloads of String.getBytes() and String(byte[]) that specifies an explicit encoding, otherwise you may run into encoding issues.

Use m.toString() or String.valueOf(m). String.valueOf uses toString() but is null safe.

Why don't you use the BigInteger(String) constructor ? That way, round-tripping via toString() should work fine.
(note also that your conversion to bytes doesn't explicitly specify a character-encoding and is platform-dependent - that could be source of grief further down the line)

You can also use Java's implicit conversion:
BigInteger m = new BigInteger(bytemsg);
String mStr = "" + m; // mStr now contains string representation of m.

When constructing a BigInteger with a string, the string must be formatted as a decimal number. You cannot use letters, unless you specify a radix in the second argument, you can specify up to 36 in the radix. 36 will give you alphanumeric characters only [0-9,a-z], so if you use this, you will have no formatting. You can create: new BigInteger("ihavenospaces", 36)
Then to convert back, use a .toString(36)
BUT TO KEEP FORMATTING:
Use the byte[] method that a couple people mentioned. That will pack the data with formatting into the smallest size, and allow you to keep track of number of bytes easily
That should be perfect for an RSA public key crypto system example program, assuming you keep the number of bytes in the message smaller than the number of bytes of PQ
(I realize this thread is old)

To reverse
byte[] bytemsg=msg.getBytes();
you can use
String text = new String(bytemsg);
using a BigInteger just complicates things, in fact it not clear why you want a byte[]. What are planing to do with the BigInteger or byte[]? What is the point?

String input = "0101";
BigInteger x = new BigInteger ( input , 2 );
String output = x.toString(2);

//How to solve BigDecimal & BigInteger and return a String.
BigDecimal x = new BigDecimal( a );
BigDecimal y = new BigDecimal( b );
BigDecimal result = BigDecimal.ZERO;
BigDecimal result = x.add(y);
return String.valueOf(result);

https://docs.oracle.com/javase/1.5.0/docs/api/java/lang/Object.html.
Every object has a toString() method in Java.