有这样一个问题。我有一个方法，将文件中的字节读入数组，以及搜索此数组中最长字节序列的方法。
private int element;
private int lastElement;
private int length;
private byte[] readByteFromFile(File name) throws IOException {
return Files.readAllBytes(name.toPath());
}
private void searchByte(byte[] byteMass) {
for (int i = 0; i < byteMass.length; i++) {
int count = 0;
for (int j = i + 1; j < byteMass.length; j++) {
if (byteMass[i + count] == byteMass[j]) {
if (count >= length) {
length = count + 1;
element = i;
lastElement = j - count;
}
count++;
} else {
count = 0;
}
}
}
}
假设我的文件包含这样一个数字序列：
444478126354444
在处理的情况下，我的方法将推断第一次出现在0，第二次出现在11和序列长度= 4
但如果我有这样的序列
133333444478126354444
然后我的方法将推断第一次出现在1，第二次出现在2，以及序列4的长度
如何修复，该方法继续正常工作？
它没有经过测试。不要让我面前的IDE。原始代码的变化是。第二个循环迭代一个元素。如果下一个元素不等于前一个元素，则循环退出。
private void searchByte(byte[] byteMass) {
int maxLength = 0
int element;
for (int i = 0; i < byteMass.length; i++) {
int count = 0;
for (int j = i + 1; j < byteMass.length-1; j++) {
if (byteMass[i] == byteMass[j]) {
if (count > length) {
maxLength = count;
element = i;
}
count++;
} else {
break;
}
}
}
如果您还没有，我认为找出代码的逻辑是非常重要的！在寻求帮助之前尝试这样做非常重要。如果你依赖别人来制定你自己的逻辑，那么你作为程序员就不会有太大的进步。
话虽这么说，让我们深入研究并跟踪你的代码，当它运行问题输入时（这不是实际代码，我们只是在程序运行时查看值）
byteMass = 133333444478126354444
(byteMass.length = 21)
length = 0
0 (i) < 21 (byteMass.length): true
count = 0
1 (j) < 21: true
1 (byteMass[0 (i + count)]) == 3 (byteMass[1 (j)]): false
count = 0
2 (j) < 21: true
1 (byteMass[0 (i + count)]) == 3 (byteMass[2 (j)]): false
count = 0
3 (j) < 21: true
1 == 3: false
它继续这样，但当j = 12时会发生一些有趣的事情
12 (j) < 21: true
1 (byteMass[0 (i + count)]) == 1 (byteMass[12 (j)]): true
0 (count) >= 0 (length): true
length = 1 (count + 1)
element = 0 (i)
lastElement = 12 (j - count)
count = 1
至少对我而言，这看起来像是出乎意料的行为！我们想要计算重复的数字，但是这个1比前一个1位数！我们可以通过编辑内部for循环来解决这个问题
for (int j = i + 1; j < byteMass.length && byteMass[i] == byteMass[j]; j++) {
这样，一旦byteMass[i] == byteMass[j]评估为false，内部循环就会中断。现在让我们用新的内部for循环重启我们的进程
byteMass = 133333444478126354444
(byteMass.length = 21)
length = 0
0 (i) < 21 (byteMass.length): true
count = 0
1 (j) < 21 && 1 (byteMass[0 (i)]) == 3 (byteMass[1 (j)]): false
1 (i) < 21: true
count = 0
2 (j) < 21 && 3 (byteMass[1 (i)]) == 3 (byteMass[2 (j)]): true
0 (count) >= 0 (length): true
length = 1 (0 (count) + 1)
element = 1 (i)
lastElement = 2 (2 (j) - 0 (count))
count = 1 (0 (count) + 1)
3 (j) < 21 && 3 (byteMass[2 (1 (i) + 1 (count))]) == 3 (byteMass[3 (j)]): true
1 (count) >= 1 (length): true
length = 2 (1 (count) + 1)
element = 1 (i)
lastElement = 2 (3 (j) - 1 (count))
这对我来说似乎是意想不到的行为，但我不会解决它，因为我不知道如何：我不知道什么元素和lastElement代表。代码继续这样，直到j = 6：
6 (j) < 21 && 3 (byteMass[5 (1 (i) + 4 (count))]) == 4 (bteMass[3 (j)]): false
2 (i) < 21: true
count = 0
3 (j) < 21: true
3 (byteMass[2 (2 (i) + 0 (count))]) == 3 (byteMass[3 (j)]): true
length = 1 (0 (count) + 1)
element = 2 (i)
lastElement = 3 (3 (j) - 1 (count))
count = 1 (0 (count) + 1)
这再次以同样的方式继续，直到j = 6.在这一点上，希望你能看到为什么你的程序没有按预期工作。但我仍然没有回答如何修复它的问题。我真的不明白你如何解决这个问题的思考过程，但我会和你分享我自己的想法
首先，我们需要将问题分解成更小的块！
你可以用你想要的任何方式做到这一点，但这是我的方式：我们的目标是找到最长的重复模式。那么为了做到这一点，我们需要弄清楚
它实际上是一个复杂的问题，并且可能更容易用辅助函数来解决。我希望这有帮助！