Regex, чтобы найти поплавок - PullRequest
Новая
       1

Regex, чтобы найти поплавок

6 голосов
/ 20 июля 2011

Я никогда раньше не использовал регулярные выражения, но эта функция Java требует этого (показано здесь: Как настроить представление Edittext, разрешить только два числовых значения и два десятичных значения, например ##. ## )

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

String re1="([+-]?\\d*\\.\\d+)(?![-+0-9\\.])";

Но, похоже, он не работает, он не позволяет мне что-либо помещать в текстовое поле.

Какой правильный способ сделать это?Спасибо

Ответы [ 5 ]

10 голосов
/ 20 июля 2011

Попробуйте это: 

String re1="^([+-]?\\d*\\.?\\d*)$";
7 голосов
/ 20 июля 2011

Правильный способ решения этой проблемы - не использовать регулярные выражения, а просто использовать: 

try {
     Float.parseFloat(string)
     return true;
}
catch (NumberFormatException ex) {
     return false;
}

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

3 голосов
/ 24 августа 2018

После отказа от принятого ответа (и двух других соответствующих) я решил предоставить новый.Затем я обнаружил, что 1 сентября 16-го Кристофера Хаммарстрёма в 8:40 в основном скрытый комментарий к ответу Паулпро (который был принят).

Вот принятый ответ:

String re1 = "^([+ -]? \ d * \.? \ d *) $ ";

Вот комментарий Кристоффера:

Это соответствует пустой строке или одиночномуточка, либо плюс, либо минус сам по себе.

Фактически, ни один из 3 ответов, которые соответствуют требованию ФП, не справляются с поставленной задачей, то есть он должен предоставить RE длянекоторый другой объект класса и позволяет конечному пользователю вводить любое допустимое число с плавающей запятой.

Вот мой случай для нового ответа.

Таким образом, мой ответ - [+-]?(\d+|\d+\.\d+|\.\d+|\d+\.)([eE]\d+)?.Вы должны добавить ^ в начале и $ в конце выражения, если объект класса мог бы иначе передать недопустимый начальный или конечный символы.

Вот как я прочитал выражение, как написано выше:

[+-]?

Это означает, что символ начального знака разрешен, но не обязателен.

( \d+ | \d+\.\d+ | \.\d+ | \d+\. )

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

([eE]\d+)?

Эта последняя часть означает, что суффикс научной нотации допускается как необязательный.

Вот весь код. 

$ cat Tester.java | sed 's/^/    /'

import java.util.*;
import java.util.regex.*;

public class Tester {

    private class TestVal {
        private String  val;
        private boolean accepted;
        private boolean expect;
        private boolean tested;
        public TestVal (String testValue, boolean expectedResult) {
            val = testValue;
            expect = expectedResult;
            reset();
        }
        public String   getValue    () { return val; }
        public boolean  getExpect   () { return expect; }
        public void     reset       () { tested = false; accepted = false; }
        public boolean  getAccepted () { return accepted; }
        public boolean  getTested   () { return tested; }
        public void     setAccepted (boolean newAccept) { tested = true; accepted = newAccept; }
    }

    private ArrayList<TestVal> tests = new ArrayList<TestVal>();

    public void doRETest (Pattern re, TestVal tv) {
            boolean matches = re.matcher(tv.getValue()).matches();
            boolean ok = matches == tv.getExpect();
            String result = ok ? "success" : "fail";
            System.out.println(String.format("%10s matches=%5s: %s", tv.getValue(), matches, result));
            tv.setAccepted(ok);
    }

    private void testsSummary () {
        int skipped = 0;
        int passes = 0;
        int failures = 0;
        for (TestVal tv : tests)
            if (tv.getTested())
                if (tv.getAccepted())
                    passes++;
                else
                    failures++;
            else
                skipped++;
        System.out.println(String.format("\npassed %d tests, failed %d tests, and %d tests skipped\n\n", passes, failures, skipped));
    }

    public void doRETests (String re) {
        Pattern p = Pattern.compile(re);
        System.out.println(String.format("testing %s", re));
        for (TestVal tv : tests) {
            tv.reset();
            doRETest(p, tv);
        }
        testsSummary();
    }

    public Tester () {
        tests.add(new TestVal("1", true));
        tests.add(new TestVal(".1", true));
        tests.add(new TestVal("1.", true));
        tests.add(new TestVal("1.0", true));

        tests.add(new TestVal("+1", true));
        tests.add(new TestVal("+.1", true));
        tests.add(new TestVal("+1.", true));
        tests.add(new TestVal("+1.0", true));

        tests.add(new TestVal("-1", true));
        tests.add(new TestVal("-.1", true));
        tests.add(new TestVal("-1.", true));
        tests.add(new TestVal("-1.0", true));

        tests.add(new TestVal("1e2", true));
        tests.add(new TestVal(".1e2", true));
        tests.add(new TestVal("1.e2", true));
        tests.add(new TestVal("1.0e2", true));

        tests.add(new TestVal("1.0e2.3", false));
        tests.add(new TestVal(".", false));
        tests.add(new TestVal("", false));
        tests.add(new TestVal("+", false));
        tests.add(new TestVal("-", false));
        tests.add(new TestVal("a", false));
    }

    public static void main (String args[]) {
        Tester t = new Tester();

        String paulpro  = "^([+-]?\\d*\\.?\\d*)$";
        String lucac    = "^([+-]?(\\d+\\.)?\\d+)$";
        String armaj    = "\\d+\\.\\d+";
        String j6t7     = "[+-]?(\\d+|\\d+\\.\\d+|\\.\\d+|\\d+\\.)([eE]\\d+)?";

        t.doRETests(paulpro);
        t.doRETests(lucac);
        t.doRETests(armaj);
        t.doRETests(j6t7);

    }

}

И вот что случилось, когда я его выполнил. 

$ javac Tester.java && java Tester | sed 's/^/    /'

testing ^([+-]?\d*\.?\d*)$
         1 matches= true: success
        .1 matches= true: success
        1. matches= true: success
       1.0 matches= true: success
        +1 matches= true: success
       +.1 matches= true: success
       +1. matches= true: success
      +1.0 matches= true: success
        -1 matches= true: success
       -.1 matches= true: success
       -1. matches= true: success
      -1.0 matches= true: success
       1e2 matches=false: fail
      .1e2 matches=false: fail
      1.e2 matches=false: fail
     1.0e2 matches=false: fail
   1.0e2.3 matches=false: success
         . matches= true: fail
           matches= true: fail
         + matches= true: fail
         - matches= true: fail
         a matches=false: success

passed 14 tests, failed 8 tests, and 0 tests skipped


testing ^([+-]?(\d+\.)?\d+)$
         1 matches= true: success
        .1 matches=false: fail
        1. matches=false: fail
       1.0 matches= true: success
        +1 matches= true: success
       +.1 matches=false: fail
       +1. matches=false: fail
      +1.0 matches= true: success
        -1 matches= true: success
       -.1 matches=false: fail
       -1. matches=false: fail
      -1.0 matches= true: success
       1e2 matches=false: fail
      .1e2 matches=false: fail
      1.e2 matches=false: fail
     1.0e2 matches=false: fail
   1.0e2.3 matches=false: success
         . matches=false: success
           matches=false: success
         + matches=false: success
         - matches=false: success
         a matches=false: success

passed 12 tests, failed 10 tests, and 0 tests skipped


testing \d+\.\d+
         1 matches=false: fail
        .1 matches=false: fail
        1. matches=false: fail
       1.0 matches= true: success
        +1 matches=false: fail
       +.1 matches=false: fail
       +1. matches=false: fail
      +1.0 matches=false: fail
        -1 matches=false: fail
       -.1 matches=false: fail
       -1. matches=false: fail
      -1.0 matches=false: fail
       1e2 matches=false: fail
      .1e2 matches=false: fail
      1.e2 matches=false: fail
     1.0e2 matches=false: fail
   1.0e2.3 matches=false: success
         . matches=false: success
           matches=false: success
         + matches=false: success
         - matches=false: success
         a matches=false: success

passed 7 tests, failed 15 tests, and 0 tests skipped


testing [+-]?(\d+|\d+\.\d+|\.\d+|\d+\.)([eE]\d+)?
         1 matches= true: success
        .1 matches= true: success
        1. matches= true: success
       1.0 matches= true: success
        +1 matches= true: success
       +.1 matches= true: success
       +1. matches= true: success
      +1.0 matches= true: success
        -1 matches= true: success
       -.1 matches= true: success
       -1. matches= true: success
      -1.0 matches= true: success
       1e2 matches= true: success
      .1e2 matches= true: success
      1.e2 matches= true: success
     1.0e2 matches= true: success
   1.0e2.3 matches=false: success
         . matches=false: success
           matches=false: success
         + matches=false: success
         - matches=false: success
         a matches=false: success

passed 22 tests, failed 0 tests, and 0 tests skipped
3 голосов
/ 08 января 2014

Это правильный путь: 

String floatRegexp="^([+-]?(\\d+\\.)?\\d+)$";

или если вы смотрите также в середине другого текста: 

String floatRegexp="([+-]?(\\d+\\.)?\\d+)";

и если вы не ищете минус /знак плюс: 

String floatRegexp="^(\\d+\\.)?\\d+$";
0 голосов
/ 23 мая 2017

этот ответ от Йохана Шёберга https://stackoverflow.com/a/12235002/4035655

Вы можете попробовать сопоставить цифры с помощью регулярного выражения 

\\d+\\.\\d+

Это может выглядеть примерно так: 

Pattern p = Pattern.compile("\\d+\\.\\d+");
Matcher m = p.matcher("Sstring>26.0.[2.3.2.3D] .352.(f) 1)"503B"(\1.67>>Sstring");
while (m.find()) {
    System.out.println(Float.parseFloat(m.group()));
}

вывод: 

26.0
2.3
2.4
1.67

часть [2.3.2.3D] строки разбита на два отдельных числа с плавающей точкой

Добро пожаловать на сайт PullRequest, где вы можете задавать вопросы и получать ответы от других членов сообщества.

Нет похожих вопросов

...