Хороший способ инкапсуляции Integer.parseInt()

Question

У меня есть проект, в котором мы часто используем Integer.parseInt() для преобразования строки в int. Когда что-то пойдет не так (например, String - это не номер, а буква a или что-то еще), этот метод выдаст исключение. Однако, если мне приходится обрабатывать исключения в моем коде повсюду, это начинает выглядеть очень уродливо очень быстро. Я хотел бы поместить это в метод, однако я не знаю, как вернуть чистую ценность, чтобы показать, что преобразование пошло не так.

В C++ я мог бы создать метод, который принял указатель на int и пусть сам метод вернет true или false. Однако, насколько я знаю, это невозможно в Java. Я мог бы также создать объект, содержащий переменную true/false и преобразованное значение, но это тоже не кажется идеальным. То же самое происходит и для глобальной ценности, и это может вызвать некоторые проблемы при многопоточности.

Так есть ли чистый способ сделать это?

Answer 1

Вы можете вернуть Integer вместо int, возвращая null при сбое разбора.

Это позор. Java не предоставляет способ сделать это без исключения исключения изнутри, но вы можете скрыть исключение (путем его улова и возврата null), но это может быть проблема с производительностью, если вы «Разбирает сотни тысяч бит данных, предоставленных пользователем».

EDIT: Код для такого метода:

public static Integer tryParse(String text) { 
    try { 
    return Integer.parseInt(text); 
    } catch (NumberFormatException e) { 
    return null; 
    } 
} 

Обратите внимание, что я не уверен, с верхней части моей головы, что это будет делать, если text равно нулю. Вы должны учитывать это - если он представляет ошибку (т. Е. Ваш код может передавать недопустимое значение, но никогда не должен пропускать null), то бросание исключения является подходящим; если он не представляет ошибку, то вы, вероятно, должны просто вернуть null, как и для любого другого недопустимого значения.

Первоначально этот ответ использовал конструктор new Integer(String); теперь он использует Integer.parseInt и операцию бокса; таким образом, небольшие значения будут помещены в кешированные объекты Integer, что сделает его более эффективным в этих ситуациях.

Answer 2

Мой Java является немного ржавый, но позвольте мне увидеть, если я могу указать вам в правильном направлении:

public class Converter { 

    public static Integer parseInt(String str) { 
     Integer n = null; 

     try { 
      n = new Integer(Integer.tryParse(str)); 
     } catch (NumberFormatException ex) { 
      // leave n null, the string is invalid 
     } 

     return n; 
    } 

} 

Если возвращаемое значение null, у вас плохое значение. В противном случае у вас есть действительный Integer.

Answer 3

Вы можете использовать нуль-объект так:

public class Convert { 

    @SuppressWarnings({"UnnecessaryBoxing"}) 
    public static final Integer NULL = new Integer(0); 

    public static Integer convert(String integer) { 

     try { 
      return Integer.valueOf(integer); 
     } catch (NumberFormatException e) { 
      return NULL; 
     } 

    } 

    public static void main(String[] args) { 

     Integer a = convert("123"); 
     System.out.println("a.equals(123) = " + a.equals(123)); 
     System.out.println("a == NULL " + (a == NULL)); 

     Integer b = convert("onetwothree"); 
     System.out.println("b.equals(123) = " + b.equals(123)); 
     System.out.println("b == NULL " + (b == NULL)); 

     Integer c = convert("0"); 
     System.out.println("equals(0) = " + c.equals(0)); 
     System.out.println("c == NULL " + (c == NULL)); 

    } 

} 

Результат основной в этом примере:

a.equals(123) = true 
a == NULL false 
b.equals(123) = false 
b == NULL true 
c.equals(0) = true 
c == NULL false 

Таким образом, вы всегда можете проверить не удалось преобразования, но до сих пор работать с результатами в виде экземпляров Integer. Вы также можете настроить номер NULL представляет (≠ 0).

Answer 4

Может быть, вы можете использовать что-то вроде этого:

public class Test { 
public interface Option<T> { 
    T get(); 

    T getOrElse(T def); 

    boolean hasValue(); 
} 

final static class Some<T> implements Option<T> { 

    private final T value; 

    public Some(T value) { 
     this.value = value; 
    } 

    @Override 
    public T get() { 
     return value; 
    } 

    @Override 
    public T getOrElse(T def) { 
     return value; 
    } 

    @Override 
    public boolean hasValue() { 
     return true; 
    } 
} 

final static class None<T> implements Option<T> { 

    @Override 
    public T get() { 
     throw new UnsupportedOperationException(); 
    } 

    @Override 
    public T getOrElse(T def) { 
     return def; 
    } 

    @Override 
    public boolean hasValue() { 
     return false; 
    } 

} 

public static Option<Integer> parseInt(String s) { 
    Option<Integer> result = new None<Integer>(); 
    try { 
     Integer value = Integer.parseInt(s); 
     result = new Some<Integer>(value); 
    } catch (NumberFormatException e) { 
    } 
    return result; 
} 

} 

Answer 5

Вы также могли бы повторить C++ поведение, которое вы хотите очень просто

public static boolean parseInt(String str, int[] byRef) { 
    if(byRef==null) return false; 
    try { 
     byRef[0] = Integer.parseInt(prop); 
     return true; 
    } catch (NumberFormatException ex) { 
     return false; 
    } 
} 

Вы бы использовать метод, как так:

int[] byRef = new int[1]; 
boolean result = parseInt("123",byRef); 

После этого переменная result это правда, если все прошло хорошо и byRef[0] содержит анализируемое значение.

Лично я бы придерживался исключения.

Answer 6

После прочтения ответов на вопрос, я думаю, что инкапсуляция или упаковка метода parseInt не нужна, может быть, даже не очень хорошая идея.

Вы можете вернуть 'null', как предложил Джон, но это более или менее заменит конструкцию try/catch с помощью null-check. Есть небольшое различие в поведении, если вы «забыли» обработку ошибок: если вы не поймаете исключение, то нет назначения, а переменная с левой стороны сохраняет старое значение. Если вы не проверите значение null, вы, вероятно, попадете в JVM (NPE).

Предложение yawn выглядит более элегантно для меня, потому что мне не нравится возвращать нуль, чтобы сигнализировать о некоторых ошибках или исключительных состояниях. Теперь вам нужно проверить ссылочное равенство с предопределенным объектом, что указывает на проблему. Но, как утверждают другие, если вы снова забыли «проверить», а String не поддается анализу, программа будет продолжена с завернутым int внутри вашего объекта «ERROR» или «NULL».

Решение Николая является еще более ориентированным на объект и будет работать с методами parseXXX и других классов-оболочек. Но, в конце концов, он просто заменил исключение NumberFormatException исключением OperationNotSupported - снова вам понадобится try/catch для обработки несрабатываемых входов.

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

Answer 7

Какое поведение вы ожидаете, когда это не число?

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

public static int parseWithDefault(String number, int defaultVal) { 
    try { 
    return Integer.parseInt(number); 
    } catch (NumberFormatException e) { 
    return defaultVal; 
    } 
} 

Подобные методы могут быть написаны для разных по умолчанию когда вход не может быть проанализирован.

Answer 8

Я хотел бы предложить вам рассмотреть метод, как

IntegerUtilities.isValidInteger(String s) 

который затем реализовать, как вы считаете нужным. Если вы хотите вернуть результат - возможно, потому, что вы используете Integer.parseInt(), вы можете использовать трюк массива.

IntegerUtilities.isValidInteger(String s, int[] result) 

, где вы устанавливаете результат [0] на целое значение, найденное в процессе.

Answer 9

Это несколько похоже на решение Николая:

private static class Box<T> { 
    T me; 
    public Box() {} 
    public T get() { return me; } 
    public void set(T fromParse) { me = fromParse; } 
} 

private interface Parser<T> { 
    public void setExclusion(String regex); 
    public boolean isExcluded(String s); 
    public T parse(String s); 
} 

public static <T> boolean parser(Box<T> ref, Parser<T> p, String toParse) { 
    if (!p.isExcluded(toParse)) { 
    ref.set(p.parse(toParse)); 
    return true; 
    } else return false; 
} 

public static void main(String args[]) { 
    Box<Integer> a = new Box<Integer>(); 
    Parser<Integer> intParser = new Parser<Integer>() { 
    String myExclusion; 
    public void setExclusion(String regex) { 
    myExclusion = regex; 
    } 
    public boolean isExcluded(String s) { 
    return s.matches(myExclusion); 
    } 
    public Integer parse(String s) { 
    return new Integer(s); 
    } 
    }; 
    intParser.setExclusion("\\D+"); 
    if (parser(a,intParser,"123")) System.out.println(a.get()); 
    if (!parser(a,intParser,"abc")) System.out.println("didn't parse "+a.get()); 
} 

Основной метод демки кода. Другим способом реализации интерфейса Parser, очевидно, было бы просто установить «\ D +» из конструирования, и методы не делают ничего.

Answer 10

Вы могли свернуть свой собственный, но это так же легко использовать обыкновенные Ланга StringUtils.isNumeric()method. Он использует Character.isDigit() для повторения каждого символа в строке.

Answer 11

Эти способы рекурсивно решают эту проблему. Например, при чтении данных из консоли:

Java.util.Scanner keyboard = new Java.util.Scanner(System.in); 

public int GetMyInt(){ 
    int ret; 
    System.out.print("Give me an Int: "); 
    try{ 
     ret = Integer.parseInt(keyboard.NextLine()); 

    } 
    catch(Exception e){ 
     System.out.println("\nThere was an error try again.\n"); 
     ret = GetMyInt(); 
    } 
    return ret; 
} 

Answer 12

Чтобы избежать исключения, вы можете использовать метод в Java Format.parseObject. Код ниже - это в основном упрощенная версия класса Apache Common IntegerValidator.

public static boolean tryParse(String s, int[] result) 
{ 
    NumberFormat format = NumberFormat.getIntegerInstance(); 
    ParsePosition position = new ParsePosition(0); 
    Object parsedValue = format.parseObject(s, position); 

    if (position.getErrorIndex() > -1) 
    { 
     return false; 
    } 

    if (position.getIndex() < s.length()) 
    { 
     return false; 
    } 

    result[0] = ((Long) parsedValue).intValue(); 
    return true; 
} 

Вы можете использовать AtomicInteger или трюк int[] массива в зависимости от ваших предпочтений.

Вот мой тест, который использует это -

int[] i = new int[1]; 
Assert.assertTrue(IntUtils.tryParse("123", i)); 
Assert.assertEquals(123, i[0]); 

Answer 13

Чтобы избежать обработок исключений использовать регулярные выражения, чтобы убедиться, что у вас есть все цифры первых:

if(value.matches("\\d+") { 
    Integer.parseInt(value); 
} 

Answer 14

В некоторых случаях вы должны обрабатывать разбор ошибки в ситуациях с отказом, но в других случаях, таких как конфигурация приложения, я предпочитаю обрабатывать отсутствующие данные со значениями по умолчанию, используя Apache Commons Lang 3 NumberUtils.

int port = NumberUtils.toInt(properties.getProperty("port"), 8080); 

Answer 15

Существует в GuavaInts.tryParse(). Он не генерирует исключение для нечисловой строки, однако он генерирует исключение в нулевой строке.

Answer 16

У меня также была такая же проблема. Это метод, который я написал, чтобы спросить пользователя о вводе и не принимать входные данные, если это не целое число. Обратите внимание, что я новичок, поэтому, если код не работает должным образом, обвините мою неопытность!

private int numberValue(String value, boolean val) throws IOException { 
    //prints the value passed by the code implementer 
    System.out.println(value); 
    //returns 0 is val is passed as false 
    Object num = 0; 
    while (val) { 
     num = br.readLine(); 
     try { 
      Integer numVal = Integer.parseInt((String) num); 
      if (numVal instanceof Integer) { 
       val = false; 
       num = numVal; 
      } 
     } catch (Exception e) { 
      System.out.println("Error. Please input a valid number :-"); 
     } 
    } 
    return ((Integer) num).intValue(); 
} 

Answer 17

Ответ дается Jon тарелочкам это хорошо, но я не хотел отдать объект null Integer. Мне кажется, что это сбивает с толку. Поскольку Java 8 есть лучший вариант (на мой взгляд), используя OptionalInt:

public static OptionalInt tryParse(String value) { 
try { 
    return OptionalInt.of(Integer.parseInt(value)); 
    } catch (NumberFormatException e) { 
    return OptionalInt.empty(); 
    } 
} 

Это делает его явным, что вы должны обрабатывать случай, когда значение не доступно. Я бы предпочел, чтобы в будущем эта функция была добавлена ​​в java-библиотеку, но я не знаю, случится ли это когда-нибудь.

Answer 18

Это ответ на вопрос 8391979: «Есть ли у java int.tryparse, который не генерирует исключение для плохих данных? [Duplicate]», который закрыт и связан с этим вопросом.

Редактировать 2016 08 17: Добавлены методы ltrimZeroes и вызваны их в tryParse(). Без начальных нулей в numberString могут появляться ложные результаты (см. Комментарии в коде).В настоящее время существует публичный статический метод String ltrimZeroes (String numberString), который работает для положительных и отрицательных «чисел» (END Edit)

Ниже вы найдете рудиментарный класс Wrapper (бокс) для int с оптимизированной по скорости скоростью tryParse() метод (подобно тому, как в C#), который анализирует саму строку и немного быстрее, чем Integer.parseInt (String) из Java:

public class IntBoxSimple { 
    // IntBoxSimple - Rudimentary class to implement a C#-like tryParse() method for int 
    // A full blown IntBox class implementation can be found in my Github project 
    // Copyright (c) 2016, Peter Sulzer, Fürth 
    // Program is published under the GNU General Public License (GPL) Version 1 or newer 

    protected int _n; // this "boxes" the int value 

    // BEGIN The following statements are only executed at the 
    // first instantiation of an IntBox (i. e. only once) or 
    // already compiled into the code at compile time: 
    public static final int MAX_INT_LEN = 
      String.valueOf(Integer.MAX_VALUE).length(); 
    public static final int MIN_INT_LEN = 
      String.valueOf(Integer.MIN_VALUE).length(); 
    public static final int MAX_INT_LASTDEC = 
      Integer.parseInt(String.valueOf(Integer.MAX_VALUE).substring(1)); 
    public static final int MAX_INT_FIRSTDIGIT = 
      Integer.parseInt(String.valueOf(Integer.MAX_VALUE).substring(0, 1)); 
    public static final int MIN_INT_LASTDEC = 
      -Integer.parseInt(String.valueOf(Integer.MIN_VALUE).substring(2)); 
    public static final int MIN_INT_FIRSTDIGIT = 
      Integer.parseInt(String.valueOf(Integer.MIN_VALUE).substring(1,2)); 
    // END The following statements... 

    // ltrimZeroes() methods added 2016 08 16 (are required by tryParse() methods) 
    public static String ltrimZeroes(String s) { 
     if (s.charAt(0) == '-') 
      return ltrimZeroesNegative(s); 
     else 
      return ltrimZeroesPositive(s); 
    } 
    protected static String ltrimZeroesNegative(String s) { 
     int i=1; 
     for (; s.charAt(i) == '0'; i++); 
     return ("-"+s.substring(i)); 
    } 
    protected static String ltrimZeroesPositive(String s) { 
     int i=0; 
     for (; s.charAt(i) == '0'; i++); 
     return (s.substring(i)); 
    } 

    public static boolean tryParse(String s,IntBoxSimple intBox) { 
     if (intBox == null) 
      // intBoxSimple=new IntBoxSimple(); // This doesn't work, as 
      // intBoxSimple itself is passed by value and cannot changed 
      // for the caller. I. e. "out"-arguments of C# cannot be simulated in Java. 
      return false; // so we simply return false 
     s=s.trim(); // leading and trailing whitespace is allowed for String s 
     int len=s.length(); 
     int rslt=0, d, dfirst=0, i, j; 
     char c=s.charAt(0); 
     if (c == '-') { 
      if (len > MIN_INT_LEN) { // corrected (added) 2016 08 17 
       s = ltrimZeroesNegative(s); 
       len = s.length(); 
      } 
      if (len >= MIN_INT_LEN) { 
       c = s.charAt(1); 
       if (!Character.isDigit(c)) 
        return false; 
       dfirst = c-'0'; 
       if (len > MIN_INT_LEN || dfirst > MIN_INT_FIRSTDIGIT) 
        return false; 
      } 
      for (i = len - 1, j = 1; i >= 2; --i, j *= 10) { 
       c = s.charAt(i); 
       if (!Character.isDigit(c)) 
        return false; 
       rslt -= (c-'0')*j; 
      } 
      if (len < MIN_INT_LEN) { 
       c = s.charAt(i); 
       if (!Character.isDigit(c)) 
        return false; 
       rslt -= (c-'0')*j; 
      } else { 
       if (dfirst >= MIN_INT_FIRSTDIGIT && rslt < MIN_INT_LASTDEC) 
        return false; 
       rslt -= dfirst * j; 
      } 
     } else { 
      if (len > MAX_INT_LEN) { // corrected (added) 2016 08 16 
       s = ltrimZeroesPositive(s); 
       len=s.length(); 
      } 
      if (len >= MAX_INT_LEN) { 
       c = s.charAt(0); 
       if (!Character.isDigit(c)) 
        return false; 
       dfirst = c-'0'; 
       if (len > MAX_INT_LEN || dfirst > MAX_INT_FIRSTDIGIT) 
        return false; 
      } 
      for (i = len - 1, j = 1; i >= 1; --i, j *= 10) { 
       c = s.charAt(i); 
       if (!Character.isDigit(c)) 
        return false; 
       rslt += (c-'0')*j; 
      } 
      if (len < MAX_INT_LEN) { 
       c = s.charAt(i); 
       if (!Character.isDigit(c)) 
        return false; 
       rslt += (c-'0')*j; 
      } 
      if (dfirst >= MAX_INT_FIRSTDIGIT && rslt > MAX_INT_LASTDEC) 
       return false; 
      rslt += dfirst*j; 
     } 
     intBox._n=rslt; 
     return true; 
    } 

    // Get the value stored in an IntBoxSimple: 
    public int get_n() { 
     return _n; 
    } 
    public int v() { // alternative shorter version, v for "value" 
     return _n; 
    } 
    // Make objects of IntBoxSimple (needed as constructors are not public): 
    public static IntBoxSimple makeIntBoxSimple() { 
     return new IntBoxSimple(); 
    } 
    public static IntBoxSimple makeIntBoxSimple(int integerNumber) { 
     return new IntBoxSimple(integerNumber); 
    } 

    // constructors are not public(!=: 
    protected IntBoxSimple() {} { 
     _n=0; // default value an IntBoxSimple holds 
    } 
    protected IntBoxSimple(int integerNumber) { 
     _n=integerNumber; 
    } 
} 

Test/пример программы для класса IntBoxSimple:

import java.io.BufferedReader; 
import java.io.IOException; 
import java.io.InputStreamReader; 
public class IntBoxSimpleTest { 
    public static void main (String args[]) { 
     IntBoxSimple ibs = IntBoxSimple.makeIntBoxSimple(); 
     String in = null; 
     BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
     do { 
      System.out.printf(
        "Enter an integer number in the range %d to %d:%n", 
         Integer.MIN_VALUE, Integer.MAX_VALUE); 
      try { in = br.readLine(); } catch (IOException ex) {} 
     } while(! IntBoxSimple.tryParse(in, ibs)); 
     System.out.printf("The number you have entered was: %d%n", ibs.v()); 
    } 
} 

Answer 19

Что относительно нарисовать метод parseInt?

Это просто, просто скопируйте содержимое в новую утилиту, которая возвращает Integer или Optional<Integer> и заменяет броски с возвратами. Кажется, нет никаких исключений в базовом коде, , но лучше проверить.

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

Answer 20

Try с регулярными выражениями и по умолчанию параметры аргумента

public static int parseIntWithDefault(String str, int defaultInt) { 
    return str.matches("-?\\d+") ? Integer.parseInt(str) : defaultInt; 
} 


int testId = parseIntWithDefault("1001", 0); 
System.out.print(testId); // 1001 

int testId = parseIntWithDefault("test1001", 0); 
System.out.print(testId); // 1001 

int testId = parseIntWithDefault("-1001", 0); 
System.out.print(testId); // -1001 

int testId = parseIntWithDefault("test", 0); 
System.out.print(testId); // 0 

если вы используете apache.commons.lang3 затем с помощью NumberUtils:

int testId = NumberUtils.toInt("test", 0); 
System.out.print(testId); // 0 

Answer 21

Я хотел бы бросить в другое предложение о том, работает, если конкретный запрос целых чисел: просто используйте long и используйте Long.MIN_VALUE для случаев ошибок. Это похоже на подход, который используется для символов в Reader, где Reader.read() возвращает целое число в диапазоне символов char или -1, если читатель пуст.

Для Float и Double NaN можно использовать аналогичным образом.

public static long parseInteger(String s) { 
    try { 
     return Integer.parseInt(s); 
    } catch (NumberFormatException e) { 
     return Long.MIN_VALUE; 
    } 
} 


// ... 
long l = parseInteger("ABC"); 
if (l == Long.MIN_VALUE) { 
    // ... error 
} else { 
    int i = (int) l; 
}