Получить Integer из конца строки (переменной длины)

Question

У меня есть строка переменной длины и в конце строки несколько цифр.Каков наилучший / эффективный способ, чтобы проанализировать строку и получить число с конца как целое число?

Строка и цифры в конце могут быть любой длины.Например:

abcd123 --> 123
abc12345 --> 12345
ab4cd1 --> 1

Answer 1

Что-то вроде:

final static Pattern lastIntPattern = Pattern.compile("[^0-9]+([0-9]+)$");
String input = "...";
Matcher matcher = lastIntPattern.matcher(input);
if (matcher.find()) {
    String someNumberStr = matcher.group(1);
    int lastNumberInt = Integer.parseInt(someNumberStr);
}

может это сделать.

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

Answer 2

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

public static BigInteger lastBigInteger(String s) {
    int i = s.length();
    while (i > 0 && Character.isDigit(s.charAt(i - 1))) {
        i--;
    }
    return new BigInteger(s.substring(i));
}

• Он вручную ищет позицию последнего не- Character.isDigit(char)
  • Это все еще работает, если на входе все цифры
• Используется BigInteger, поэтому он может обрабатывать действительно большие числа в конце действительно длинных строк.
  • Используйте Integer.parseInt или Long.parseLong, если достаточно либо

Answer 3

int getTrailingInteger(String str)
{
    int positionOfLastDigit = getPositionOfLastDigit(str);
    if (positionOfLastDigit == str.length())
    {
        // string does not end in digits
        return -1;
    }
    return Integer.parseInt(str.substring(positionOfLastDigit));
}

int getPositionOfLastDigit(String str)
{
    int pos;
    for (pos=str.length()-1; pos>=0; --pos)
    {
        char c = str.charAt(pos);
        if (!Character.isDigit(c)) break;
    }
    return pos + 1;
}

Answer 4

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

int n = 0;
try {
    n = Integer.parseInt (str.replaceFirst("^.*\\D",""));
} catch (Exception e) {}

Answer 5

Я собираюсь сделать это без регулярных выражений!

Проверьте мое обновление!

public static int getLastInt(String line)
{
    int offset = line.length();
    for (int i = line.length() - 1; i >= 0; i--)
    {
        char c = line.charAt(i);
        if (Character.isDigit(c))
        {
            offset--;
        }
        else
        {
            if (offset == line.length())
            {
                 // No int at the end
                 return Integer.MIN_VALUE;
            }
            return Integer.parseInt(line.substring(offset));
        }
    }
    return Integer.parseInt(line.substring(offset));
}

Это прекрасно работает.

Answer 6

Хороших ответов уже много, я просто хотел дать свои два цента.

Я знаю, что запуск parseInt () в цикле не эффективный способ, но ради простота .

public static int getIntFromEnd (String string) {
  for (int a = string.length()-1; a >=0; a--)
  try {
    int result = Integer.parseInt(string.substring(a,string.length()));
    // the whole string is integer
    if(a == 0) return result;
  } catch (Exception e) {
    // there is no numbers at the end
    if(a == string.length()-1) break;
    return Integer.parseInt(string.substring(a+1,string.length()));
  }
  // there is no numbers
  return -1;
}

ИСПЫТАНО ПРОТИВ ДРУГИХ ОТВЕТОВ:

Я провел несколько тестов против принятого ответа , и этот код работает от 7 до 10 раз быстрее .

Затем я попробовал его против второго ответа с наибольшим количеством голосов , и этот код выполняется в 3–4 раза быстрее .

Answer 7

private int intAtEnd(String string) {
        int i, j;
        i = j = string.length();
        while (--i > 0) {
            if (Character.isDigit(string.charAt(i))) continue;
            i++;
            break;
        } 
        if (j - i > 1) return Integer.parseInt(string.substring(i));
        return -1;
    }

Answer 8

public int getIntFromEndOfString(String inpStr){
    int revVal = 0;
    boolean flag = false;
    String reverseNo  = "", result = "";
    for (int i = inpStr.length()-1; i >= 0 ; i--) {
        reverseNo = String.valueOf(inpStr.charAt(i));
        if(!flag)
        if(reverseNo.equals("0") ||reverseNo.equals("1") || reverseNo.equals("2") || reverseNo.equals("3")
                | reverseNo.equals("4") || reverseNo.equals("5") || reverseNo.equals("6") || reverseNo.equals("7")
                || reverseNo.equals("8") || reverseNo.equals("9")){
            revVal = Integer.parseInt(reverseNo);
            result+= String.valueOf(revVal);
        }else{
            inpStr = result;
            i = inpStr.length();
            flag = true;
            result = "";
        }else{
            result += reverseNo;
        }
    }
    revVal = Integer.parseInt(result);
    return revVal;
}

Answer 9

В целом я предпочитаю четкий и короткий код, но если производительность действительно является вашим первым приоритетом, рассмотрите что-то вроде:

private static int getNum(String s){
    int res = 0;
    int p = 1;
    int i = s.length()-1;
    while(i >= 0){
        int d = s.charAt(i) - '0';
        if (d>=0 && d<=9)
            res += d * p;
        else
            break;
        i--;
        p *= 10;
    }

    return res;     
}

Он не использует никаких сложных операций со строками / регулярными выражениями. Но опять же - если производительность не является проблемой, пожалуйста, используйте другие методы, представленные выше.

Answer 10

Перебирайте каждый символ в поисках нечисловых символов. Когда кто-то найден, порежьте его и все перед ним. После запуска цикла приведите результат к int.