Java – Need easy way to force all DynaBean property names to lower case

apache-commons-beanutilshibernatejava

I'm developing functionality that can operate on concrete data beans returned via Hibernate, or DynaBeans returned by using Jakarta Commons/BeanUtils' RowSetDynaClass (which wraps a JDBC result set). RowSetDynaClass by default forces all bean property names to lower case, and I need to convert all my concrete beans from Hibernate to DynaBeans using WrapDynaBean. The default lower casing by RowSetDynaClass seems like a good idea, however I may not know ahead of time how the property names of the concrete beans will be cased; due to Hibernate configuration, they need not be cased identically to their corresponding table column names.

Is there built in functionality for forcing property names to lower case using BeanUtils? I can't find it documented other than for RowSetDynaClass. In lieu of something built in to BeanUtils, can anybody suggest the best way to acheive this myself?

Best Answer

Here's a quick/dirty method I've devised in the meantime for converting the DynaBeans to a Map where the (String) keys are coerced to lower case:

private Map asLowerCaseIndexedMap(DynaBean bean) {
    Map lowerCaseIndexedMap = new HashMap();
    DynaProperty[] dynaProperties = bean.getDynaClass().getDynaProperties();

    for (int i=0, n=dynaProperties.length; i<n; i++) {
        String propertyName = dynaProperties[i].getName();
        lowerCaseIndexedMap.put(propertyName.toLowerCase(), bean.get(propertyName));
    }

    return lowerCaseIndexedMap;
}

Unfortunately this has forced me to jump through other hoops. Whereas I had been dealing with the beans thusly:

public void header(List<DynaBean> headerColumns) throws WriteException {
    for (DynaBean column : headerColumns) {
        int col = (Integer)column.get("columnNumber");
        int width = (Integer)column.get("columnWidth");

    //etcetera

Now I have to do so in this manner:

public void header(List<DynaBean> headerColumns) throws WriteException {
    for (DynaBean column : headerColumns) {
        /*
         * RowSetDynaClass returns beans with lower case properties by default
         * but this is not guaranteed if beans are coming from Hibernate.
         * 
         * Converting from the bean to a map however loses DynaBeans' inherent
         * type conversions, which in turn entails the converting back and forth
         * from String, to BigDecimal, to int as seen below
         */
        Map columnMap = asLowerCaseIndexedMap(column);

        int col = (new BigDecimal(columnMap.get("columnnbr").toString())).intValue();
        int width = (new BigDecimal(columnMap.get("columnwdth").toString())).intValue();

Results

Benchmark           Mode  Cnt         Score        Error  Units
MyBenchmark.test1  thrpt   20  10463220.493 ± 288805.068  ops/s
MyBenchmark.test2  thrpt   20  14730158.709 ± 530444.444  ops/s
MyBenchmark.test3  thrpt   20  16079551.751 ±  56884.357  ops/s
MyBenchmark.test4  thrpt   20   9762578.446 ± 584316.582  ops/s
MyBenchmark.test5  thrpt   20   6093216.066 ± 180062.872  ops/s
MyBenchmark.test6  thrpt   20   2104102.578 ±  18705.805  ops/s

The score are operations per second, the more the better.

Tests

test1 was first Andy's and Hllink's approach:

string = Character.toLowerCase(string.charAt(0)) + string.substring(1);

test2 was second Andy's approach. It is also Introspector.decapitalize() suggested by Daniel, but without two if statements. First if was removed because of the testing assumption. The second one was removed, because it was violating correctness (i.e. input "HI" would return "HI"). This was almost the fastest.
```
char c[] = string.toCharArray();
c[0] = Character.toLowerCase(c[0]);
string = new String(c);
```
test3 was a modification of test2, but instead of Character.toLowerCase(), I was adding 32, which works correctly if and only if the string is in ASCII. This was the fastest. c[0] |= ' ' from Mike's comment gave the same performance.
```
char c[] = string.toCharArray();
c[0] += 32;
string = new String(c);
```

test4 used StringBuilder.

StringBuilder sb = new StringBuilder(string);
sb.setCharAt(0, Character.toLowerCase(sb.charAt(0)));
string = sb.toString();

test5 used two substring() calls.

string = string.substring(0, 1).toLowerCase() + string.substring(1);

test6 uses reflection to change char value[] directly in String. This was the slowest.

try {
    Field field = String.class.getDeclaredField("value");
    field.setAccessible(true);
    char[] value = (char[]) field.get(string);
    value[0] = Character.toLowerCase(value[0]);
} catch (IllegalAccessException e) {
    e.printStackTrace();
} catch (NoSuchFieldException e) {
    e.printStackTrace();
}

Conclusions

If the String length is always greater than 0, use test2.

If not, we have to check the corner cases:

public static String decapitalize(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }

    char c[] = string.toCharArray();
    c[0] = Character.toLowerCase(c[0]);

    return new String(c);
}

If you are sure that your text will be always in ASCII and you are looking for extreme performance because you found this code in the bottleneck, use test3.

Best Answer

Related Solutions

Java – Easy way to write contents of a Java InputStream to an OutputStream

Java – Most efficient way to make the first character of a String lower case

Results

Tests

Conclusions

Related Topic