如何将String转换为基本类型或标准java Wrapper类型 [英] How to convert from String to a primitive type or standard java Wrapper types

问题描述

我有一个 java.lang.reflect.InvocationHandler ，我需要实现方法invoke（）

I have a java.lang.reflect.InvocationHandler and I need to implement the method invoke()

我的详细说明中有一个 java.lang.String 类型的值，我需要将此值转换为该方法所需的相应returnType（它可以是原始的int，boolean，double或包装类，如Boolean，Integer，Double，Float等）。

I have a value of type java.lang.String from my elaboration and I need to convert this value to the appropriate returnType expected by the method (it can be a primitive like int, boolean, double or wrapper classes like Boolean, Integer, Double, Float, etc).

示例：

public Object invoke(Object proxy, Method method, Object[] args) 
        throws Throwable {
    String computedValue = compute(...);
    return convert(method.getReturnType(), computedValue);
}

private Object convert(Class<?> returnType, String stringValue) {
    return ...; // what's the simplest way?
}

我不希望简单地在复杂对象之间实现自动转换，但是我期待一种简单的方法从String转换为标准的java类型。

I am not expecting to simply implement an automatic conversion between complex objects, but I expect a simple way to convert from String to the standard java types.

我已经看过很多次这样的东西，但它似乎不适合我：

I've seen (too) many times stuff like this, but it doesn't seem appropriate to me:

public static Object toObject( Class clazz, String value ) {
    if( Boolean.class.isAssignableFrom( clazz ) ) return Boolean.parseBoolean( value );
    if( Byte.class.isAssignableFrom( clazz ) ) return Byte.parseByte( value );
    if( Short.class.isAssignableFrom( clazz ) ) return Short.parseShort( value );
    if( Integer.class.isAssignableFrom( clazz ) ) return Integer.parseInteger( value );
    if( Long.class.isAssignableFrom( clazz ) ) return Long.parseLong( value );
    if( Float.class.isAssignableFrom( clazz ) ) return Float.parseFloat( value );
    if( Double.class.isAssignableFrom( clazz ) ) return Double.parseDouble( value );
    return value;
}

以上甚至不是我看到的更糟糕的，到目前为止:)

and the above is not even the worse one I saw, so far :)

这里有人有秘密技巧吗？

Does anybody have a secret trick here?

推荐答案

目前为止我知道，你提供的版本没有真正的替代品。你可以稍微简化一下（因为包装类型都是 final ），但你基本上需要使用 if 或切换或散列以打开课程。

As far as I'm aware, there is no real alternative to the version you presented. You can simplify it a bit (since the wrapper types are all final), but you essentially need to use if or switch or hashing to switch on the class.

我的建议是像上面那样对其进行编码。丑陋的代码只是一个问题本身如果你必须看它。所以把它放在一个实用工具方法中，不要再看了。

My advice is to code it like the above. Ugly code is only a problem per se if you have to look at it. So put it inside a utility method and don't look at it again.

FWIW - 这就是我简化方法的方法：

FWIW - this is how I'd simplify the method:

public static Object toObject( Class clazz, String value ) {
    if( Boolean.class == clazz ) return Boolean.parseBoolean( value );
    if( Byte.class == clazz ) return Byte.parseByte( value );
    if( Short.class == clazz ) return Short.parseShort( value );
    if( Integer.class == clazz ) return Integer.parseInt( value );
    if( Long.class == clazz ) return Long.parseLong( value );
    if( Float.class == clazz ) return Float.parseFloat( value );
    if( Double.class == clazz ) return Double.parseDouble( value );
    return value;
}

这更简单，更有效。它等同于原始版本，因为类都是 final ，因为规范声明了 Class 对象的相等性是对象标识。

This is simpler and more efficient. And it is equivalent to the original version because the classes are all final and because the specs state that equality for Class objects is object identity.

可以说，我们应该使用< wrapper> .valueOf（String）方法直接返回包装器对象。

Arguably, we should be using the <wrapper>.valueOf(String) methods which return the wrapper objects directly.

我没有声称这不那么丑陋...但美并不是衡量代码质量的有用方法，因为它是主观的并且因为它没有告诉您代码是否易于理解和/或维护。

I make no claim that this is less ugly ... but "beauty" is not a useful measure of code quality, because it is subjective and because it doesn't tell you whether the code is easy to understand and / or maintain.

更新

为了支持原始类型，将相应的类添加到 if 条件;例如

To support primitive types as well, add the corresponding classes to the if conditions; e.g.

    if (Boolean.class == clazz || Boolean.TYPE == clazz) {
        return Boolean.parseBoolean(value);
    }

现在可能已达到对类型进行字符串切换的程度名称更有效，尽管有一些类型标识的问题需要仔细考虑。 （理论上，您可以使用由不同类加载器加载的具有相同全名的多个类型。我认为您需要在类加载器中快速且松散地使用原始包装类来执行此操作...但是我认为它仍有可能。）

It may now be getting to the point where doing a String switch on the type's name is more efficient, though there are some slightly knotty issues of type identity that need to be thought through. (In theory, you can have multiple types with the same full name that have been loaded by different classloaders. I think you'd need to "play fast and loose" in a classloader to do that with the primitive wrapper classes ... but I think it might still be possible.)

这篇关于如何将String转换为基本类型或标准java Wrapper类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！