假设您使用的是json.org库：一旦您有了JSONObject，为什么不这样做呢？

obj.put("longitude", obj.get("serviceCentreLon"));
obj.remove("serviceCentreLon");
obj.put("latitude", obj.get("serviceCentreLat"));
obj.remove("serviceCentreLat");

您可以创建一个rename方法来执行此操作（然后调用它两次），但如果这些是您要重命名的 * 唯一 * 字段，那么这样做可能有些过头。

String data= json.toString();
data=data.replace("serviceCentreLon","longitude");
data=data.replace("serviceCentreLat","latitude");

转换回json对象

我不知道我是否理解你的问题是正确的，但下面的工作不应该吗？
您可以使用正则表达式替换密钥，例如：

String str = myJsonObject.toString();
str = str.replace(/"serviceCentreLon":/g, '"longitude":');
str = str.replace(/"serviceCentreLat":/g, '"latitude":');

它不是那么“干净”，但它可能会很快完成工作。

以Danyal Sandeelo的方法为基础，而不是：

data=data.replace("serviceCentreLon","longitude");

使用

data=data.replace("\"serviceCentreLon\":","\"longitude\":");

此方法显式地匹配JSON键语法，并避免了键值在JSON字符串的其他地方作为有效数据出现的模糊错误。

解决这个问题的最佳方法是解析JSON数据，然后替换密钥。有许多解析器可用-- google gson、Jacksonserializer、deserializer、org.json.me就是处理JSON数据的几个这样的java库。
http://www.mkyong.com/java/how-do-convert-java-object-to-from-json-format-gson-api/
如果你有一个非常通用的和相对庞大的JSON数据，这是一个很好的处理方法。当然，你必须花时间学习这个库，以及如何很好地使用它。
X1 E1 F1 X是另一种这样的解析器。
https://stleary.github.io/JSON-java/是最简单的一种，特别是当您不需要任何严重的序列化或反序列化时

具有Map到此对象数据结构的对象。
使用GSON解析器或Jackson解析器将此json转换为POJO。
然后将此对象Map到另一个具有所需配置的Java对象
使用相同的GSON解析器将该POJO转换回json。
把这个作为进一步的参考
http://www.mkyong.com/java/how-do-convert-java-object-to-from-json-format-gson-api/

我在工作中遇到过这个问题，所以我做了一个有用的Utils类，我想和大家分享一下。

package net.so.json;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import org.json.JSONObject;

public class Utils {
    
    /**
     * replace json object keys with the new one
     * @param jsonString represents json object as string
     * @param oldJsonKeyNewJsonKeyMap map its key old json key & its value new key name if nested json key you have traverse
     * through it using . example (root.coutry, count) "root.country" means country is a key inside root object
     * and "count" is the new name for country key
     * Also, if the value for the map key is null, this key will be removed from json
     */
    public static void replaceJsonKeys(final JSONObject jsonObject, final Map<String, String> oldJsonKeyNewJsonKeyMap) {
        if (null == jsonObject || null == oldJsonKeyNewJsonKeyMap) {
            return;
        }
        
        
        // sort the old json keys descending because we want to replace the name of the inner most key first, then 
        // the outer one
        final List<String> oldJsonKeys = oldJsonKeyNewJsonKeyMap.keySet().stream().sorted((k2, k1) -> k1.compareTo(k2)).collect(Collectors.toList());
        
        oldJsonKeys.forEach(k -> {
            // split old key, remember old key is something like than root.country
            final String[] oldJsonKeyArr = k.split("\\.");
            
            final int N = oldJsonKeyArr.length;
            
            
            // get the object hold that old key
            JSONObject tempJsonObject = jsonObject;
            for (int i = 0; i < N - 1; i++)
                tempJsonObject = tempJsonObject.getJSONObject(oldJsonKeyArr[i]);
            
            final String newJsonKey = oldJsonKeyNewJsonKeyMap.get(k);
            
            // if value of the map for a give old json key is null, we just remove that key from json object
            if (!"null".equalsIgnoreCase(newJsonKey))
                tempJsonObject.put(newJsonKey, tempJsonObject.get(oldJsonKeyArr[N - 1]));
            
            // remove the old json key
            tempJsonObject.remove(oldJsonKeyArr[N - 1]);
        
        });
        
            
        
    }

}

可以通过运行App来测试此类

package net.so.json;

import java.util.HashMap;
import java.util.Map;

import org.json.JSONObject;

public class App {
    
    public static void main(String[] args) {
        final String jsonString = "{\"root\":{\"country\": \"test-country\", \"city\": \"test-city\"}}";
        final JSONObject jsonObject = new JSONObject(jsonString);
        
        System.out.println("json before replacement: " + jsonObject);
        /* will get >>
           {
              "root": {
                  "country": "test-country",
                  "city": "test-city"
               }
            }
        */
        
        // construct map of key replacements
        final Map<String, String> map = new HashMap<>();
        map.put("root", "root2");
        map.put("root.country", "count");
        map.put("root.city", "null"); // null as a value means we want to remove this key
        
        
        Utils.replaceJsonKeys(jsonObject, map);
        
        System.out.println("json after replacement: " + jsonObject);
        /* will get >>    
          {
             "root2": {
               "count": "test-country"
             }
          }
        */
                
    }

}

我遇到过这样一个场景：我想从嵌套对象中的未知数目的键中删除一个连字符。
所以这个：

{
    "-frame": {
        "-shape": {
            "-rectangle": {
                "-version": "1"
            }
        },
        "-path": {
            "-geometry": {
                "-start": {
                    "-x": "26.883513064453602",
                    "-y": "31.986310940359715"
                }
            },
            "-id": 1,
            "-type": "dribble",
            "-name": "MultiSegmentStencil",
            "-arrowhead": "0"
        }
    }
}

会是这样的：

{
    "frame": {
        "shape": {
            "rectangle": {
                "version": "1"
            }
        },
        "path": {
            "geometry": {
                "start": {
                    "x": "26.883513064453602",
                    "y": "31.986310940359715"
                }
            },
            "id": 1,
            "type": "dribble",
            "name": "MultiSegmentStencil",
            "arrowhead": "0"
        }
    }
}

一个递归方法（kotlin）..通过Jackson使用了一个列表

fun normalizeKeys(tree: JsonNode, fieldsToBeRemoved: MutableList<String>) {

        val  node = tree as ContainerNode<*>

        val firstClassFields = node.fields()
        while(firstClassFields.hasNext()) {
            val field = firstClassFields.next()
            if(field.key.substring(0,1) == "-") {
                fieldsToBeRemoved.add(field.key)
            }
            if(field.value.isContainerNode) {
                normalizeKeys(field.value, fieldsToBeRemoved)
            }
        }

        fieldsToBeRemoved.forEach {
            val fieldByKey: MutableMap.MutableEntry<String, JsonNode>? = getFieldByKey(tree, it)
            if(fieldByKey != null) {
                (tree as ObjectNode)[fieldByKey!!.key.replaceFirst("-","")] = fieldByKey.value
                (tree as ObjectNode).remove(fieldByKey!!.key)
                }
        }
    }