求数字字符串的整数值

Integer.parseInt()不就完了吗，不然就是你表达有问题

这个问题没这么简单parseInt 会有异常的可以用正则或者 apache common里的NumberUtils.isDigits(); 即可

异常用try-catch处理一下就可以吧

判断字符串的长度，小一点的用parseiInt，大点的用parseLong，再大的用bigInteger..

先用regex测试是10/8/16进制或者不是数字串。

String num = "1234";
int n = Integer.parseInt(num);
System.out.println(n);

1，保证没有异常的话，可以直接parseInt
2，也可以一位位的解析，从第一个字符分析到最后一个，例如如果是8进制，要不停的乘以8
3，用正则判断也行，然后解析

用charAT(int n)就可以啦！
string s = "123";
for(int i=s.length()-1;i>=0;i--){
System.out.print(charAt(i))
}

习惯try catch parseInt的做法……

根据实际需求，先用正则判断或者在catch块中处理。

Integer.parseInt()有异常是正常的，而且只有好处，总不能把一个普通字符当数字来转换吧。
最多捕获下异常就是了。

判断一下长度，超过long的话的范围的话，就用long数组好了。

用正则判断下是否是字母或者是汉字，然后检查下长度。再用Integer.paseInt();

String str="124";
int a=Integer.valueOf(str).intValue();

判断字符串的长度，小一点的用parseiInt，大点的用parseLong，再大的用bigInteger..

抛异常就让它去抛好了。Java之所以引入异常，就是为了让异常能抛出来。

自己写一个parseInt，把字符串转下

搞复杂了吧
楼主的设题的前提是“整数字符串”
所以Integer.parseInt(整数字符串, 10).intValue();就可以了，有异常本来就不符合楼主的设题

接分
来个原始一点的，不考虑非法字符和整形溢出
int atoi(String s) {
    int result = 0;
    int base = 1;
    char[] c = s.toCharArray();
    for (int i=c.length-1; i>=0; i--) {
        result += base*((int)(c[i]-'0'));
        base *= 10;
    }
    return result;
}

俺也果断接分，Integer.parseInt()

public class Test {

public static List<Integer> convert(String s){
List<Integer> list = new ArrayList<Integer>();
int n = 0;
boolean lastEnd = false;
for(int i = 0;i < s.length();i++){
lastEnd = false;
n = n*10 + s.charAt(i) - 48;
if((i + 1) % 9 == 0){
list.add(new Integer(n));
n = 0;
lastEnd = true;
}
}
if(!lastEnd){
list.add(n);
}
int lastNumber = list.get(list.size() - 1);
int zeroNumber = s.length() % 9 -String.valueOf(lastNumber).length();
list.add(new Integer(zeroNumber));
return list;
} /**
* @param args
*/
public static void main(String[] args) { List<Integer> list = Test.convert("12344567896546");
for(int i = 0;i < list.size();i++){
System.out.print(l.get(i));
}
}
}由于2^10近似为10^3，根据int的范围所以每次处理string的9位，虽然有点浪费空间但应该不会溢出，然后将每个int放入一个arraylist里面。
这样每9位做为一个处理单元，从最高位开始处理，有两个问题要注意：
1.如果第n个处理单元(n >= 2)起始为0，那么list的第n的元素计算时要补0，补0的数量为9 - String.valueof(list.get(n)).length();
例如：处理sting s = 1234567890012345678，第二个处理单元001234567转化为int时为1234567，此时当用这个list代表的大整数运算时，第二个单元前面补两个0;
2.对于最后一个int的处理，list倒数第二个元素放最后一个处理单元，此时有两种情况导致这个int不足9位，一是前面为0，二是本身就不够9位。解决的办法是在list的最后加入一个数，表示它需要补几位0，计算方法很简单，程序中写出来了。可能有点麻烦，希望高手提出更好的方法。

楼上的没那么复杂~
       String s = "123456789123456";
       byte[] b = s.getBytes();
       long end=0;
       for(int i=0;i<b.length; i++ ){
        if(s.charAt(i)>=48 && s.charAt(i)<=57){
        end +=(s.charAt(i)-48)*java.lang.Math.pow(10,b.length-i-1);
        }else{
        System.out.println("含有非数字字符！");
}
        }
       System.out.println("end="+end);这个可以包装成任何数字类型，包括float和double

更简单，且效率高的~
       String s = "123456789123456";
       byte[] b = s.getBytes();
       long end=0;
       for(int i=0;i<b.length; i++ ){
        if(s.charAt(i)>=48 && s.charAt(i)<=57){
        System.out.print(s.charAt(i)-48);
        }else{
        System.out.println("含有非数字字符！");
}
        }获取的值可以随便处理~

如果sting s = "123456789123456789123456789123456789"呢？就不能用long存了吧。

兄弟你旦腾不
Long.MAX_VALUE=9223372036854775807
Float.MAX_VALUE=3.4028235E38
Double.MAX_VALUE=1.7976931348623157E308全中国人口加起来才多少~
String s = "123456789123456";
           byte[] b = s.getBytes();
           long end=0;
           for(int i=0;i<b.length; i++ ){
                   if(s.charAt(i)>=48 && s.charAt(i)<=57){
                       if(end+(s.charAt(i)-48)>9223372036854775806){
                         //越界后可以用状态为进行标识
                        }
                       end +=(s.charAt(i)-48)*java.lang.Math.pow(10,b.length-i-1);
                   }else{
                       System.out.println("含有非数字字符！");
                }
            }
           System.out.println("end="+end);
...

看了啊，byte能存的最大数为127，string.getbytes放入的最大是9，用了低四位吧，高四位永远为0000

在java中，BYTE是一个字节，字节也是JAVA中的数据类型中的最小单位，char是两个字节，STRING是char[]的封装类型。char和string是有编码的，byte是没有编码的，在处理速度上是最快的~那你说是用BYTE拆分好呢，还是用char拆分好呢？或者你能给出一个更高效的算法~

byte，char，short运算的时候拿到栈里都是用int的，写回去的时候才恢复原始的类型。拆分的方法也不难啊，基本思想就是一位一位的取，然后*10往下加。

第一次听说，byte在栈里是用int处理的~光说不练，拿出你的方法让大家都看看

Long.MAX_VALUE=9223372036854775807
Float.MAX_VALUE=3.4028235E38
Double.MAX_VALUE=1.7976931348623157E308
9223372036854775807
这个数是几千万亿的多少倍？
还有这个数怎么念，谁能完整的念出来，要大写~

很多加密算法用的都是byte，就是因为byte的高效性，“byte在栈里是用int处理的”在概念上都是错的~不要误导人家~

不知道的东西不代表不存在，学习c++、数据结构的时候都有大整数设计，需要设计一个数据结构表示几十甚至几百位的整数。c#，java也有大整数的封装类(java中是biginteger)。至于怎么读出来，有种东西叫科学计数法。
至于byte是按int压栈的你不知道没关系，哥今天教你了，再教你一个，boolean也是用int表示的。ps：换马夹的话改一下取名的习惯，也要改改书写的习惯，大号后面每句话加"~"了，小号就加别加了，或者加”...“什么的。

哈哈，来接分，问题不错，一般用try catch Integer 正则倒是一个新的方法，谢过了！

Java有BigInteger，费这事干什么。

1，保证没有异常的话，可以直接parseInt
2，也可以一位位的解析，从第一个字符分析到最后一个，例如如果是8进制，要不停的乘以8
3，用正则判断也行，然后解析

这样想是否可以？我就说一下思路。
先把这个字符串，一位一位的拆开，在循环中对应生成一个变量和变量值。这样就不会有数字的转换。
如下：看能不能运行。很久没有写java了。public class test_toNum {
public int toNumber(String str){ //123
if("".equals(str) || str == null){
return -1;
}
char[] ch = str.toCharArray();
int re_num = 0;
for(int i = ch.length - 1 ; i >= 0 ; i --){
int number = 0 ;
switch(ch[i]){
case 48 : number = 0; break;
case 49 : number = 1; break;
case 50 : number = 2; break;
case 51 : number = 3; break;
case 52 : number = 4; break;
case 53 : number = 5; break;
case 54 : number = 6; break;
case 55 : number = 7; break;
case 56 : number = 8; break;
case 57 : number = 9; break;
/*
case A : number = A;
case B : number = B;
case C : number = C;
case D : number = D;
case E : number = E;
case F : number = F;*/
}
re_num += number * (Math.pow(10, ch.length - i - 1));
}
return re_num;
}
public static void main(String args[]){
int num = new test_toNum().toNumber("123");
System.out.println(num);
}
}
如果数据比较大可以将int -> long 。就到这吧。

调试易

求数字字符串的整数值

解决方案 »