Как избежать исключения числового формата в java?

Просто поймайте свое исключение и выполните правильную обработку исключений:

if (cost !=null && !"".equals(cost) ){
        try {
           Integer intCost = Integer.parseInt(cost);
           List<Book> books = bookService . findBooksCheaperThan(intCost);  
        } catch (NumberFormatException e) {
           System.out.println("This is not a number");
           System.out.println(e.getMessage());
        }
    }

Как всегда, у Jakarta Commons есть хотя бы часть ответа:

NumberUtils.isNumber()

Это можно использовать для проверки того, является ли данная строка числом. Вам все еще нужно выбрать, что делать, если ваша строка не является числом...

Исключения в последних версиях Java не настолько дороги, чтобы их избегать было важно. Используйте предложенный людьми блок try/catch; если вы поймаете исключение в начале процесса (т. е. сразу после того, как пользователь введет его), тогда у вас не возникнет проблемы позже в процессе (потому что это все равно будет правильный тип).

Исключения раньше стоили намного дороже, чем сейчас; не оптимизируйте производительность, пока не узнаете, что исключения действительно вызывают проблему (и здесь они не будут).

Я предлагаю сделать 2 вещи:

• проверить ввод на стороне клиента перед передачей его сервлету
• поймать исключение и показать сообщение об ошибке в пользовательском интерфейсе, как упоминал Тобиаск. Такого случая обычно не должно происходить, но никогда не доверяйте своим клиентам. ;-)

одна возможность: поймать исключение и показать сообщение об ошибке в пользовательском интерфейсе.

редактировать: добавить слушателя в поле в графическом интерфейсе и проверить там также пользовательский ввод, с этим решением случай исключения должен быть очень редким...

Документация по методу из Apache Commons Lang (отсюда):

Проверяет, является ли String допустимым числом Java.

Допустимые числа включают шестнадцатеричные числа, отмеченные квалификатором 0x, экспоненциальное представление и числа, отмеченные квалификатором типа (например, 123L).

Null и пустая строка вернут false.

Параметры:

`str` - the `String` to check

Возвраты:

`true` if the string is a correctly formatted number

isNumber из java.org.apache.commons.lang3.math.NumberUtils:

public static boolean isNumber(final String str) {
    if (StringUtils.isEmpty(str)) {
        return false;
    }
    final char[] chars = str.toCharArray();
    int sz = chars.length;
    boolean hasExp = false;
    boolean hasDecPoint = false;
    boolean allowSigns = false;
    boolean foundDigit = false;
    // deal with any possible sign up front
    final int start = (chars[0] == '-') ? 1 : 0;
    if (sz > start + 1 && chars[start] == '0' && chars[start + 1] == 'x') {
        int i = start + 2;
        if (i == sz) {
            return false; // str == "0x"
        }
        // checking hex (it can't be anything else)
        for (; i < chars.length; i++) {
            if ((chars[i] < '0' || chars[i] > '9')
                && (chars[i] < 'a' || chars[i] > 'f')
                && (chars[i] < 'A' || chars[i] > 'F')) {
                return false;
            }
        }
        return true;
    }
    sz--; // don't want to loop to the last char, check it afterwords
          // for type qualifiers
    int i = start;
    // loop to the next to last char or to the last char if we need another digit to
    // make a valid number (e.g. chars[0..5] = "1234E")
    while (i < sz || (i < sz + 1 && allowSigns && !foundDigit)) {
        if (chars[i] >= '0' && chars[i] <= '9') {
            foundDigit = true;
            allowSigns = false;

        } else if (chars[i] == '.') {
            if (hasDecPoint || hasExp) {
                // two decimal points or dec in exponent   
                return false;
            }
            hasDecPoint = true;
        } else if (chars[i] == 'e' || chars[i] == 'E') {
            // we've already taken care of hex.
            if (hasExp) {
                // two E's
                return false;
            }
            if (!foundDigit) {
                return false;
            }
            hasExp = true;
            allowSigns = true;
        } else if (chars[i] == '+' || chars[i] == '-') {
            if (!allowSigns) {
                return false;
            }
            allowSigns = false;
            foundDigit = false; // we need a digit after the E
        } else {
            return false;
        }
        i++;
    }
    if (i < chars.length) {
        if (chars[i] >= '0' && chars[i] <= '9') {
            // no type qualifier, OK
            return true;
        }
        if (chars[i] == 'e' || chars[i] == 'E') {
            // can't have an E at the last byte
            return false;
        }
        if (chars[i] == '.') {
            if (hasDecPoint || hasExp) {
                // two decimal points or dec in exponent
                return false;
            }
            // single trailing decimal point after non-exponent is ok
            return foundDigit;
        }
        if (!allowSigns
            && (chars[i] == 'd'
                || chars[i] == 'D'
                || chars[i] == 'f'
                || chars[i] == 'F')) {
            return foundDigit;
        }
        if (chars[i] == 'l'
            || chars[i] == 'L') {
            // not allowing L with an exponent or decimal point
            return foundDigit && !hasExp && !hasDecPoint;
        }
        // last character is illegal
        return false;
    }
    // allowSigns is true iff the val ends in 'E'
    // found digit it to make sure weird stuff like '.' and '1E-' doesn't pass
    return !allowSigns && foundDigit;
}

[код находится под версией 2 лицензии Apache]

Чтобы определить, является ли строка целочисленной или плавающей, и представить ее в более длинном формате.

Целое число

 String  cost=Long.MAX_VALUE+"";
  if (isNumeric (cost))    // returns false for non numeric
  {  
      BigInteger bi  = new BigInteger(cost);

  }

public static boolean isNumeric(String str) 
{ 
  NumberFormat formatter = NumberFormat.getInstance(); 
  ParsePosition pos = new ParsePosition(0); 
  formatter.parse(str, pos); 
  return str.length() == pos.getIndex(); 
} 

Вы можете избежать неприятного вида try/catch или регулярного выражения, используя класс Scanner:

String input = "123";
Scanner sc = new Scanner(input);
if (sc.hasNextInt())
    System.out.println("an int: " + sc.nextInt());
else {
    //handle the bad input
}

Попробуйте преобразовать Приз в десятичный формат...

import java.math.BigDecimal;
import java.math.RoundingMode;

public class Bigdecimal {
    public static boolean isEmpty (String st) {
        return st == null || st.length() < 1; 
    }
    public static BigDecimal bigDecimalFormat(String Preis){        
        //MathContext   mi = new MathContext(2);
        BigDecimal bd = new BigDecimal(0.00);

                         bd = new BigDecimal(Preis);


            return bd.setScale(2, RoundingMode.HALF_UP);

        }
    public static void main(String[] args) {
        String cost = "12.12";
        if (!isEmpty(cost) ){
            try {
               BigDecimal intCost = bigDecimalFormat(cost);
               System.out.println(intCost);
               List<Book> books = bookService.findBooksCheaperThan(intCost);  
            } catch (NumberFormatException e) {
               System.out.println("This is not a number");
               System.out.println(e.getMessage());
            }
        }

}
}

Я не знаю о недостатках времени выполнения в следующем, но вы можете запустить совпадение регулярного выражения в своей строке, чтобы убедиться, что это число, прежде чем пытаться его проанализировать, таким образом

cost.matches("-?\\d+\\.?\\d+")

для поплавка

а также

cost.matches("-?\\d+")

для целого числа

ИЗМЕНИТЬ

пожалуйста, обратите внимание на комментарий @Voo о max int

К сожалению, в Java нет способа избежать использования функции parseInt и просто перехватить исключение. Ну, теоретически вы могли бы написать свой собственный синтаксический анализатор, который проверяет, является ли это числом, но тогда вам вообще не нужен parseInt.

Метод регулярного выражения проблематичен, потому что ничто не мешает кому-то включить число > INTEGER.MAX_VALUE, которое пройдет тест регулярного выражения, но все равно не сработает.

Это зависит от вашего окружения. JSF, например, возьмет на себя бремя ручной проверки и преобразования строк ‹-> чисел от вас, еще одним вариантом является проверка бинов.

Что вы можете сделать немедленно в предоставленном фрагменте:

1. Извлеките метод getAsInt(String param), в нем:
2. Используйте String.isEmpty() (так как Java 6< /а>),
3. окружить try / catch

public void myBusinessMethod(@ValidNumber String numberInput) {
// ...    
}