Java 从长十六进制字符串到四字符十六进制字符串的转换

2016年1月28日更新的问题：

/* TEST COORDINATES */
mLat = 42.281422;
mLon = -83.748552;

/* Convert values from degrees to milliarcseconds*/
long convLat = (long)(mLat * 3600000.0);
long convLon = (long)(mLon * 3600000.0);

/* Account for negative values */
if(convLat < 0) convLat = convLat & 0x00000000ffffffffL;
if(convLon < 0) convLon = convLon & 0x00000000ffffffffL;

/* Split into four values */
byte[] dataLat = new byte[4];
dataLat[0] = (byte) ( ( convLat >>> 24 ) & 0xff );
dataLat[1] = (byte) ( ( convLat >>> 16 ) & 0xff );
dataLat[2] = (byte) ( ( convLat >>> 8 ) & 0xff );
dataLat[3] = (byte) ( ( convLat >>> 0 ) & 0xff );

/* Convert to 1 hex string per component */
String hexLat = Long.toHexString(convLat);
String hexLon = Long.toHexString(convLon);

/* Convert to 4 hex strings per component */
String[] hexStringLat = new String[4];
hexStringLat[0] = Integer.toHexString(dataLat[0]);
hexStringLat[1] = Integer.toHexString(dataLat[1]);
hexStringLat[2] = Integer.toHexString(dataLat[2]);
hexStringLat[3] = Integer.toHexString(dataLat[3]);

因为我的问题以前不是很清楚（我还在学习），这里是我的文章的重述：

以下是我所处的情景：

我编写了一些代码，可以从包含GPS坐标的日志文件中读取数据，这些坐标的格式如下所示：

“X1 X2 X3 X4 Y1 Y2 Y3 Y4”

其中X是纬度分量，Y是经度分量。我的代码基本上通过执行以下顺序将这些消息转换为纬度/经度值（以度为单位）：

String strHexLat = X1 + X2 + X3 + X4; //(X1X2X3X4 viewed as one hex value)
String strHexLon = Y1 + Y2 + Y3 + Y4; //(Y1Y2Y3Y4 viewed as one hex value)

int intLat = Integer.decode(strHexLat);
int intLon = Integer.decode(strHexLon);

if ((intLat & 0x40000000) != 0) {
    intLat |= 0x80000000;
}
if ((intLon  & 0x40000000) != 0) {
    intLon  |= 0x80000000;
}

double lat = (double) intLat / 3600000; // convert from MAS to DEG
double lon = (double) intLon / 3600000; // convert from MAS to DEG

尽管不是特别优雅，但上面的代码实现了我想要的功能。我真正的麻烦开始于逆转这个过程。我正在尝试编写一些代码，现在将以与现有文件相同的格式创建日志文件，从坐标开始，生成代表坐标的8个字符的十六进制数组

下面是我当前必须执行此转换的代码段，以及示例输入、结果输出和所需输出：

（1）将以度为单位的坐标转换为毫秒：

/* TEST COORDINATES */
mLat = 42.281422;
mLon = -83.748552;

/* Convert values from degrees to milliarcseconds*/
long convLat = (long)(mLat * 3600000.0);
long convLon = (long)(mLon * 3600000.0);

/* Account for negative values */
if(convLat < 0) convLat = convLat & 0x00000000ffffffffL;
if(convLon < 0) convLon = convLon & 0x00000000ffffffffL;

/* Split into four values */
byte[] dataLat = new byte[4];
dataLat[0] = (byte) ( ( convLat >>> 24 ) & 0xff );
dataLat[1] = (byte) ( ( convLat >>> 16 ) & 0xff );
dataLat[2] = (byte) ( ( convLat >>> 8 ) & 0xff );
dataLat[3] = (byte) ( ( convLat >>> 0 ) & 0xff );

/* Convert to 1 hex string per component */
String hexLat = Long.toHexString(convLat);
String hexLon = Long.toHexString(convLon);

/* Convert to 4 hex strings per component */
String[] hexStringLat = new String[4];
hexStringLat[0] = Integer.toHexString(dataLat[0]);
hexStringLat[1] = Integer.toHexString(dataLat[1]);
hexStringLat[2] = Integer.toHexString(dataLat[2]);
hexStringLat[3] = Integer.toHexString(dataLat[3]);

投入：

产出：

所需输出：
以上输出符合要求

（2）负值的解释：

/* TEST COORDINATES */
mLat = 42.281422;
mLon = -83.748552;

/* Convert values from degrees to milliarcseconds*/
long convLat = (long)(mLat * 3600000.0);
long convLon = (long)(mLon * 3600000.0);

/* Account for negative values */
if(convLat < 0) convLat = convLat & 0x00000000ffffffffL;
if(convLon < 0) convLon = convLon & 0x00000000ffffffffL;

/* Split into four values */
byte[] dataLat = new byte[4];
dataLat[0] = (byte) ( ( convLat >>> 24 ) & 0xff );
dataLat[1] = (byte) ( ( convLat >>> 16 ) & 0xff );
dataLat[2] = (byte) ( ( convLat >>> 8 ) & 0xff );
dataLat[3] = (byte) ( ( convLat >>> 0 ) & 0xff );

/* Convert to 1 hex string per component */
String hexLat = Long.toHexString(convLat);
String hexLon = Long.toHexString(convLon);

/* Convert to 4 hex strings per component */
String[] hexStringLat = new String[4];
hexStringLat[0] = Integer.toHexString(dataLat[0]);
hexStringLat[1] = Integer.toHexString(dataLat[1]);
hexStringLat[2] = Integer.toHexString(dataLat[2]);
hexStringLat[3] = Integer.toHexString(dataLat[3]);

产出：

所需输出：
以上输出符合要求

（3）将值拆分为4个值（现在只需尝试纬度分量）：

/* TEST COORDINATES */
mLat = 42.281422;
mLon = -83.748552;

/* Convert values from degrees to milliarcseconds*/
long convLat = (long)(mLat * 3600000.0);
long convLon = (long)(mLon * 3600000.0);

/* Account for negative values */
if(convLat < 0) convLat = convLat & 0x00000000ffffffffL;
if(convLon < 0) convLon = convLon & 0x00000000ffffffffL;

/* Split into four values */
byte[] dataLat = new byte[4];
dataLat[0] = (byte) ( ( convLat >>> 24 ) & 0xff );
dataLat[1] = (byte) ( ( convLat >>> 16 ) & 0xff );
dataLat[2] = (byte) ( ( convLat >>> 8 ) & 0xff );
dataLat[3] = (byte) ( ( convLat >>> 0 ) & 0xff );

/* Convert to 1 hex string per component */
String hexLat = Long.toHexString(convLat);
String hexLon = Long.toHexString(convLon);

/* Convert to 4 hex strings per component */
String[] hexStringLat = new String[4];
hexStringLat[0] = Integer.toHexString(dataLat[0]);
hexStringLat[1] = Integer.toHexString(dataLat[1]);
hexStringLat[2] = Integer.toHexString(dataLat[2]);
hexStringLat[3] = Integer.toHexString(dataLat[3]);

投入：

产出：

所需输出：
*****我不能完全肯定负值

（4）将值转换为单个十六进制字符串：

/* TEST COORDINATES */
mLat = 42.281422;
mLon = -83.748552;

/* Convert values from degrees to milliarcseconds*/
long convLat = (long)(mLat * 3600000.0);
long convLon = (long)(mLon * 3600000.0);

/* Account for negative values */
if(convLat < 0) convLat = convLat & 0x00000000ffffffffL;
if(convLon < 0) convLon = convLon & 0x00000000ffffffffL;

/* Split into four values */
byte[] dataLat = new byte[4];
dataLat[0] = (byte) ( ( convLat >>> 24 ) & 0xff );
dataLat[1] = (byte) ( ( convLat >>> 16 ) & 0xff );
dataLat[2] = (byte) ( ( convLat >>> 8 ) & 0xff );
dataLat[3] = (byte) ( ( convLat >>> 0 ) & 0xff );

/* Convert to 1 hex string per component */
String hexLat = Long.toHexString(convLat);
String hexLon = Long.toHexString(convLon);

/* Convert to 4 hex strings per component */
String[] hexStringLat = new String[4];
hexStringLat[0] = Integer.toHexString(dataLat[0]);
hexStringLat[1] = Integer.toHexString(dataLat[1]);
hexStringLat[2] = Integer.toHexString(dataLat[2]);
hexStringLat[3] = Integer.toHexString(dataLat[3]);

投入：

产出：

所需输出：
这些值有效，可以转换回所需的度值

如果：
convLat=152213119已转换为“912967f”
我想要：
convLat=152213119变为“09 12 96 7f”
其中：
四个十六进制值中的任何一个都可以是1或2位，并将在左侧用0填充，在这种情况下，它只是第一个数字，但可以是四个数字中的任何一个

（5）将值转换为4个十六进制字符串：

/* TEST COORDINATES */
mLat = 42.281422;
mLon = -83.748552;

/* Convert values from degrees to milliarcseconds*/
long convLat = (long)(mLat * 3600000.0);
long convLon = (long)(mLon * 3600000.0);

/* Account for negative values */
if(convLat < 0) convLat = convLat & 0x00000000ffffffffL;
if(convLon < 0) convLon = convLon & 0x00000000ffffffffL;

/* Split into four values */
byte[] dataLat = new byte[4];
dataLat[0] = (byte) ( ( convLat >>> 24 ) & 0xff );
dataLat[1] = (byte) ( ( convLat >>> 16 ) & 0xff );
dataLat[2] = (byte) ( ( convLat >>> 8 ) & 0xff );
dataLat[3] = (byte) ( ( convLat >>> 0 ) & 0xff );

/* Convert to 1 hex string per component */
String hexLat = Long.toHexString(convLat);
String hexLon = Long.toHexString(convLon);

/* Convert to 4 hex strings per component */
String[] hexStringLat = new String[4];
hexStringLat[0] = Integer.toHexString(dataLat[0]);
hexStringLat[1] = Integer.toHexString(dataLat[1]);
hexStringLat[2] = Integer.toHexString(dataLat[2]);
hexStringLat[3] = Integer.toHexString(dataLat[3]);

投入：

产出：

所需输出：
当转换为单个十六进制字符串时，我们得到值“912967f”

我希望是四个字符串的形式，如上所述，“09 12 96 7f”

然而，当直接转换为四个十六进制值时，我得到了“9 12 FFFFFF 96 7f”。
在本例中，填充操作很简单，但是我不希望3值为负值

问题：
为什么第三个值在直接转换为四个十六进制字符时为负值，而在转换为一个十六进制字符串时为负值

是否有一种“简单”的方法将单个字符串转换为我想要的格式？
我可以编写一些草率的代码来运行单个代码，尝试不同的方法来拆分值，然后测试字符串是否能转换回来，但这样做似乎是错误的

注意： 我发现以下内容对我所处的场景有所帮助，但并不完整：

---

提前感谢您的帮助，如果我再次遗漏了任何必要的细节，我深表歉意。如果您需要更多信息，请询问，我将尽快再次更新。

既然您已经有了用于lat和long的十六进制字符串，为什么不简单地拆分它呢

Matcher m = Pattern.compile(".{1,2}").matcher(hexLat.toUpperCase());
String s1 = m.find() ? hexLat.substring(m.start(), m.end()) : "";
String s2 = m.find() ? hexLat.substring(m.start(), m.end()) : "";
String s3 = m.find() ? hexLat.substring(m.start(), m.end()) : "";
String s4 = m.find() ? hexLat.substring(m.start(), m.end()) : "";

---

我还没有测试过这个，但是你不能使用String.format吗

String.format（“%02X%02X%02X%02X%02X”），（字节）（（convLat>>24）和0xff），

等

也就是说，分解每个字节，正如您已经通过移位和屏蔽所做的那样，并将它们作为参数传递给String.format

---

02确保两位数字，必要时添加前导零。大写X表示使用十六进制，大写a-F。

Hi jpgrem，请在您的帖子中添加一个有效值的示例，您一直说“十六进制”然后你在帖子中显示非十六进制字符。很难判断你是否真的正确使用了这个术语。你的问题是什么？请重写这个问题，使其简洁明了。给我们一个具体的问题我为我的措辞不够清晰而道歉，这里还是有点新，我会尽快更新帖子/问题！我很抱歉我们还没有测试过这个，但是你不能使用String.format吗？String.format（“%02X%02X%02X%02X%02X”），（byte）（（convLat>>>24）和0xff）等…@BryanT这很简单，不是吗，完全有效！你能输入你的建议作为答案吗？（除非有更正确的方法让我确认他的答案）