Java - 检查 under_score 字符串是否在 lowerCamel 字符串列表中

Question

Consider the following keys (under_score) and fields (lowerCamel):

keys   = ["opened_by","ticket_owner","close_reason"]
fields = ["openedBy","ticketOwner","closeReason"]

I'm looking for an efficient way in Java to check whether key is in fields , where I expect the following to return true :

fields = ["openedBy","ticketOwner"]

return fields.contains("opened_by"))   //true

My code:

Set<String> incidentFields = Arrays
            .stream(TicketIncidentDTO.class.getDeclaredFields())
            .map(Field::getName)
            .collect(Collectors.toSet()
            );


responseJson.keySet().forEach(key ->{
           
            if (incidentFields.contains(key)) 
            {
                //Do something
            }
        });

I could just replace all lowerCase with underscore, but I'm looking for more efficient way of doing this.

Answer 1

Try with CaseUtils from Commons Text

// opened_by -> openedBy
private String toCamel(String str) {
    return CaseUtils.toCamelCase(str, false, new char[] { '_' });
}

List<String> keys = Arrays.asList("opened_by", "ticket_owner", "close_reason", "full_name");

List<String> fields = Arrays.asList("openedBy", "ticketOwner", "closeReason");

keys.forEach(t -> {
    // check
    if (fields.contains(toCamel(t))) {
        System.out.println(t);
    }
});

Answer 2

If you do not have fields like abcXyz ( abc_xyz ) and abCxyz ( ab_cxyz ) (fields with same spelling but combination of different words), then one solution would be to replace the "_" with empty "" and then compare to fieldName using equalsIgnoreCase . Another but similar solution would be to convert each fieldName to lower case and then compare it to the camel case string after replacing the "_" with "". This could possibly eliminate the use of an additional loop when compared to the first approach.

Set<String> fields= Arrays.stream(TicketIncidentDTO.class.getDeclaredFields())
                          .map(Field::getName)
                          .map(String::toLowerCase)
                          .collect(Collectors.toSet());


responseJson.keySet()
            .filter(key -> fields.contains(key.replaceAll("_","")))
            .forEach(key -> {
                // do something..
            });

Answer 3

A simple toCamel method:

private String toCamel(String str) {
    String[] parts = str.split("_");
    StringBuilder sb = new StringBuilder(parts[0]);
    for (int i=1; i < parts.length ; i++) {
        String part = parts[i];
        if (part.length() > 0) {
            sb.append(part.substring(0, 1).toUpperCase()).append(part.substring(1));
        }
    }
    return sb.toString();
}

Now use the very same approach:

keys.forEach(t -> {
    if (fields.contains(toCamel(t))) {
        System.out.println("Fields contain " + t);
    } else {
        System.out.println("Fields doesn't contain " + t);
    }
});

I could just replace all lowerCase with underscore, but I'm looking for more efficient way of doing this.

Use Set as a data structure for keys and fields that is very effective in the look-up. Moreover, it is sutable for this use case since it doesn't make sense to have duplicated keys in JSON.