Java如何从来自多个源的数据推断类型

我正在开发一个java服务器，它从多个传感器收集数据。这些传感器通常以字符串值的形式返回查询的值。在标题中，它指示服务器必须使用的数据类型来强制转换接收到的值。这些值可以是整型、布尔型、双精度、浮点型和长型

传感器可能不提供值的“数据类型描述”，因此： 我想通过分析接收到的字符串来了解数据类型

---

我在考虑使用正则表达式，但也许还有其他更好的方法。有什么建议吗？

我将创建一个数据验证器责任链，其每个元素将尝试将输入数据从限制性最强的类型转换为限制性最小的类型：

boolean
integer
long
float
double
String

---

如果一个解析器解析数据失败，链会将其传播到下一个解析器，如果所有操作都失败，则抛出异常或将其用作字符串。

有几种方法可以做到这一点。 一种是尝试按不同的标准java类型以适当的顺序解析值，即

Boolean.parseBoolean(s)
Integer.parseInteger(s)
Long.parseLong(s)
... 
(and so on)

并捕捉每一步的异常 第二种方法-使用ApacheCommons库，可以检测类型，即

BooleanUtils.isBoolean(s)    
StringUtils.IsNumeric(s)
StringUtils.IsAlpha(s)

---

这篇文章激发了我的灵感，让我写出了自己的作品。它真的很容易使用。用于删除前导空格和尾随空格，因此以下操作很好：

jshell> Typifier.typify(" 23  \t\n")
$206 ==> String[2] { "Byte", "23" }

jshell> Typifier.typify("\r\n 3.4")
$207 ==> String[2] { "Float", "3.4" }

但如果用户只输入空白，也可以：

jshell> Typifier.typify(" ")
$298 ==> String[2] { "String", " " }

true/false的各种表示用于确定布尔性：

jshell> Typifier.typify(" F ")
$208 ==> String[2] { "Boolean", "false" }

jshell> Typifier.typify(" 1 ")
$209 ==> String[2] { "Boolean", "true" }

jshell> Typifier.typify(" TRUE ")
$210 ==> String[2] { "Boolean", "true" }

Byte、Short和Float的范围用于以最窄的可用类型框装值：

jshell> Typifier.typify(" 2 ")
$212 ==> String[2] { "Byte", "2" }

jshell> Typifier.typify(" 200 ")
$213 ==> String[2] { "Short", "200" }

jshell> Typifier.typify(" 2e9 ")
$214 ==> String[2] { "Float", "2.0E9" }

jshell> Typifier.typify(" 2e99 ")
$215 ==> String[2] { "Double", "2.0E99" }

默认类型为String，但如果表达式为，则将解析if并返回结果

jshell> Typifier.typify("var a = 3; var b = 6; a*b")
$230 ==> String[2] { "Float", "18.0" }

jshell> Typifier.typify("2*(2.4e2 + 34.8)")
$231 ==> String[2] { "Float", "549.6" }

如果输入字符串的长度为1且不是布尔值或字节，则将为其指定字符类型：

jshell> Typifier.typify("4")
$232 ==> String[2] { "Byte", "4" }

jshell> Typifier.typify("-")
$233 ==> String[2] { "Character", "-" }

jshell> Typifier.typify("a")
$234 ==> String[2] { "Character", "a" }

可能的扩展可能包括为公式求值设置标志，或将返回的类型限制为“公共”类型（布尔、整数、双精度、字符串）的标志。此代码也可以在中找到。无论如何，这是：

代码

---

你说的“传感器”是什么意思？如果它是您可以控制的东西，则会有不好的API/代码味道。是否要根据内容将字符串转换为这些类型之一？这是不明确的。是

3.5

a

double

还是

float

？我必须处理设备/传感器的微型化。如果设备/传感器服务器未正确配置DN.m，我希望能够自己理解数据类型。为了使它更简单，我只能使用两倍……我认为他无法控制他的“传感器”，我将使用这两种解决方案。首先使用apache commons函数，然后在我理解它是一个数字后更改integer/float和float/double（就像foampile建议的那样）。实际上，我在apache commons中没有找到BooleanUtils.isBoolean。此外，IsAlpha仅在字符串包含字母时进行检查，像“32.3”这样的字符串由于“.”而不被视为Alpha。是的，您是对的，但您可以编写自己的公共布尔值isBoolean（字符串s）{try{BooleanUtils.toBoolean（“true”，“true”，“false”）；return true}catch（illegargumentException）{return false}

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;
import javax.script.ScriptException;

import java.util.Arrays;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Typifier {

  public Typifier() {
    // nothing special to do here
  }

  public static String[] typify (String data) {

    String s = data.trim();

    // -1. if the input data is only whitespace, return String
    if (s.length() == 0) return new String[]{"String", data};

    // 0. check if the data is Boolean (true or false)
    if (Arrays.asList("0", "f", "F", "false", "False", "FALSE").contains(s))
      return new String[]{"Boolean", "false"};
    else if (Arrays.asList("1", "t", "T", "true",  "True",  "TRUE" ).contains(s))
      return new String[]{"Boolean", "true"};

    // 1. check if data is a Byte (1-byte integer with range [-(2e7) = -128, ((2e7)-1) = 127])
    try {
      Byte b = Byte.parseByte(s);
      return new String[]{"Byte", b.toString()}; // if we make it to this line, the data parsed fine as a Byte
    } catch (java.lang.NumberFormatException ex) {
      // okay, guess it's not a Byte
    }

    // 2. check if data is a Short (2-byte integer with range [-(2e15) = -32768, ((2e15)-1) = 32767])
    try {
      Short h = Short.parseShort(s);
      return new String[]{"Short", h.toString()}; // if we make it to this line, the data parsed fine as a Short
    } catch (java.lang.NumberFormatException ex) {
      // okay, guess it's not a Short
    }

    // 3. check if data is an Integer (4-byte integer with range [-(2e31), (2e31)-1])
    try {
      Integer i = Integer.parseInt(s);
      return new String[]{"Integer", i.toString()}; // if we make it to this line, the data parsed fine as an Integer
    } catch (java.lang.NumberFormatException ex) {
      // okay, guess it's not an Integer
    }

    String s_L_trimmed = s;

    // 4. check if data is a Long (8-byte integer with range [-(2e63), (2e63)-1])

    //    ...first, see if the last character of the string is "L" or "l"
    if (Arrays.asList("L", "l").contains(s.substring(s.length() - 1)) && s.length() > 1)
      s_L_trimmed = s.substring(0, s.length() - 1);

    try {
      Long l = Long.parseLong(s_L_trimmed);
      return new String[]{"Long", l.toString()}; // if we make it to this line, the data parsed fine as a Long
    } catch (java.lang.NumberFormatException ex) {
      // okay, guess it's not a Long
    }

    // 5. check if data is a Float (32-bit IEEE 754 floating point with approximate extents +/- 3.4028235e38)
    try {
      Float f = Float.parseFloat(s);

      if (!f.isInfinite()) // if it's beyond the range of Float, maybe it's not beyond the range of Double
        return new String[]{"Float", f.toString()}; // if we make it to this line, the data parsed fine as a Float and is finite

    } catch (java.lang.NumberFormatException ex) {
      // okay, guess it's not a Float
    }

    // 6. check if data is a Double (64-bit IEEE 754 floating point with approximate extents +/- 1.797693134862315e308 )
    try {
      Double d = Double.parseDouble(s);

      if (!d.isInfinite())
        return new String[]{"Double", d.toString()}; // if we make it to this line, the data parsed fine as a Double
      else // if it's beyond the range of Double, just return a String and let the user decide what to do
        return new String[]{"String", s};

    } catch (java.lang.NumberFormatException ex) {
      // okay, guess it's not a Double
    }

    // 7. revert to String by default, with caveats...

    //   a. if string has length 1, it is a single character
    if (s.length() == 1) return new String[]{"Character", s};

    //   b. if string contains any of {+, -, /, *, =}, attempt to parse equation
    Pattern pattern = Pattern.compile("[+-/*=]");
    Matcher matcher = pattern.matcher(s);

    //   ...evaluate the equation and send the result back to typify() to get the type
    if (matcher.find()) {
      ScriptEngineManager manager = new ScriptEngineManager();
      ScriptEngine engine = manager.getEngineByName("JavaScript");

      try {
        String evaluated = engine.eval(s).toString();
        return typify(evaluated);
      } catch (javax.script.ScriptException ex) {
        // okay, guess it's not an equation
      }
    }

    // ...if we've made it all the way to here without returning, give up and return "String"

    return new String[]{"String", s};

  }

}