任何人都可以告诉我以下代码的作用吗？更具体地说，（！复制）部分。究竟是什么if语句检查？
for (int i = 0; i < list.length; i++) {
boolean duplicate = false;
for (int x = 0; x < list.length; x++) {
if (integer[x] == list[i]) {
duplicate = true;
//If integer is new, duplicate = false, if it's repeated in
//list, duplicate = true
}
}
if (!duplicate) {
integer[value++] = list[i];
}
答案 0 :(得分：0)
您提供的示例代码将不会执行任何操作，因为它充满了错误。我不知道你在哪里得到这个代码，但需要重新考虑。代码的原始意图实际上非常明显，它是创建一个新的整数数组，其中包含所有 distinct 和 unique 提供的名为 list 的整数数组中包含的整数值（无重复项），它可能包含或不包含重复值 - 重复的值会被忽略，并且它只是该副本的第一个实例将应用于新数组以及＆＃39;列表中的任何值。没有重复的数组，因此被认为是唯一的。
布尔重复变量只是在外部 for 循环中用作标记，表示在＆＃39;列表中找到了重复值＆＃39 ;内部 for 循环迭代期间的数组。当内部 for 循环结束时，将检查此标志的状态，如果发现 false ，则将该值添加到＆＃39;整数＆＃39;阵列。如果确定当前正在处理的值确实是重复的，则退出内部 for 循环（使用 break 语句）会更有效一点并且重复变量设置为布尔 true ，因为不再需要进一步处理初始整数值，并且外部 for 循环的处理可以继续。
您的示例中显示的代码意图是执行此类操作的一种方法（有几种方法，只有Google：＆＃34; 使用Java ＆＃34;从整数数组中删除重复项; ）
由于您正在处理数组，因此必须使用为该数组保留元素所需的长度正确声明和初始化它们，例如：
int[] integer = new int[12];
通常，对于这个特定任务（以及许多其他任务），许多新程序员会将新数组（整数本身）声明并初始化为相同的长度作为原始数组，他们正在检查重复（或反对），例如：
int[] integer = int[list.length];
这实际上是做这种事情的错误方法，因为如果遇到重复项，新数组中可能会有很多元素可能包含0。对于 list 数组中遇到的每个重复值，整数数组将包含 1 更少的元素，但因为整数数组被初始化为与原始列表数组相同的长度，您认为不存在的元素实际上将存在，并且它将包含 0 ，因为 int ＆＃39; s默认为0（无论是单个整数变量还是整数数组中的元素）。如果您准备好在代码的进展过程中处理这种情况，或者实际上没有重复的值包含在 list 数组中，那么这样做就没有问题了。在多数情况下。这就是为什么大多数程序员在执行这种特定类型的任务时都会停留在Array上，而是使用其他类和/或方法。
要演示上述方案，请将以下代码输入到新Java Application项目的 main（）方法中并运行它：
// Our Hard Coded Integer 'list' Array.
int[] list = {1, 3, 5, 2, 4, 5, 6, 3, 6, 7,
2, 9, 5, 8, 0, 0, 1, 5, 8, 2};
// Declare & initialize the 'integer' Array
int[] integer = new int[list.length]; // Premature initialization
boolean duplicate;
idxCnt = 0;
for (int i = 0; i < list.length; i++) {
duplicate = false;
for (int x = (i + 1); x < list.length; x++) {
if (list[i] == list[x]) {
duplicate = true;
break;
}
}
if (!duplicate) {
integer[idxCnt] = list[i];
idxCnt++;
}
}
System.out.println(Arrays.toString(integer));
控制台窗口将显示：
[4, 3, 6, 7, 9, 0, 1, 5, 8, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
通过查看＆＃39;列表的内容＆＃39;数组我们已经可以看到有10个不同的数字，即使有20个元素，因此显然也有10个重复值。请注意，在控制台显示中，只有第一个实例和＆＃39;列表中的唯一值。数组确实被放入了整数＆＃39;数组，但在整数＆＃39;的末尾。数组有10个零（0），根本不需要。这是因为整数＆＃39;声明并初始化数组的长度与＆＃39; list＆＃39;相同。我们已经知道的数组包含20个元素。
注意：您可能还注意到上面的代码显示了您在帖子中显示的意图的工作版本。
在我看来，当你要填充一个数组时，一定要声明并初始化该数组到所需的确切长度。为了在这种情况下执行此操作，您需要遍历＆＃39;列表＆＃39;首先是数组，以确定实际存在多少重复值，这是你可以做到的一种方法（坚持已经建立的原始编码格式）：
// Our Hard Coded Integer 'list' Array.
int[] list = {1, 3, 5, 2, 4, 5, 6, 3, 6, 7,
2, 9, 5, 8, 0, 0, 1, 5, 8, 2};
int idxCnt = 0; // To eventually hold the number of duplicates.
// Find out how many duplicates there are within
// the 'list' int Array.
for (int i = 0; i < list.length; i++) {
for (int x = (i + 1); x < list.length; x++) {
if (list[i] == list[x]) {
idxCnt++;
break;
}
}
}
System.out.println("There are " + idxCnt + " duplicate values "
+ "contained within the 'list' Array of\n"
+ list.length + " elements. We only "
+ "need " + (list.length - idxCnt) + " elements "
+ "for our 'integer' Array.");
如果您要运行上面的示例代码，您将在控制台窗口中看到如下代码：
There are 10 duplicate values contained within the 'list' Array of
20 elements. We only need 10 elements for our 'integer' Array.
20个元素 - 10个重复项= 10个元素，用于将不同的值放入＆＃39;整数＆＃39;阵列。
现在我们知道我们的整数＆＃39;需要多少元素。数组我们可以这样初始化它：
int[] integer = new int[idxCnt];
当所有内容放在一起时，代码看起来像这样：
// Our Hard Coded Integer 'list' Array.
int[] list = {1, 3, 5, 2, 4, 5, 6, 3, 6, 7,
2, 9, 5, 8, 0, 0, 1, 5, 8, 2};
boolean duplicate; // Flag to indicate duplicate encountered.
int[] integer; // Declare the 'integer' Array
int idxCnt = 0; // To eventually hold the number of duplicates.
// Find out how many duplicates there are within
// the 'list' int Array.
for (int i = 0; i < list.length; i++) {
for (int x = i+1; x < list.length; x++) {
if (list[i] == list[x]) {
idxCnt++;
break; // No need to continue inner loop
}
}
}
// Initialize the new 'integer' Array
integer = new int[list.length - idxCnt];
// Retrieve distinct values from 'list' Array
// and place them into the 'integer' Array.
idxCnt = 0; // Used as Index Counter.
for (int i = 0; i < list.length; i++) {
duplicate = false;
for (int x = (i + 1); x < list.length; x++) {
if (list[i] == list[x]) {
duplicate = true;
break; // No need to continue inner loop
}
}
if (!duplicate) {
// Deemed as not duplicate so add the value
// to the 'integer' Array
integer[idxCnt] = list[i];
idxCnt++; // Increment the index for 'integer' Array.
}
}
// Sort the 'integer Array.
Arrays.sort(integer);
// Display the 'integer' Array to Console Window
System.out.println(Arrays.toString(integer));
运行时，上面的鳕鱼将显示在控制台窗口中：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
相当抽出并非如此。这就是为什么大多数必须处理数组的程序员喜欢在这样的眼睛上做一些更容易的事情：
使用Java 8 ：
// Our Hard Coded Integer 'list' Array.
int[] list = {1, 3, 5, 2, 4, 5, 6, 3, 6, 7,
2, 9, 5, 8, 0, 0, 1, 5, 8, 2};
// Convert Array to ArrayList (List Object)
List<Integer> lst = Arrays.stream(list).boxed().collect(Collectors.toList());
// Remove duplicates.
lst = new ArrayList<>(new HashSet<>(lst));
// Sort the List
Collections.sort(lst); // If you want the List sorted.
// Display List in console.
System.out.println(lst);
更好的是，只处理一个List对象而不是一个数组（下面假设所有整数值都已包含在名为 list 的List对象中）：
list = new ArrayList<>(new HashSet<>(list)); // To remove duplicates
Collections.sort(list); // To sort the List.
System.out.println(list); // Display List to console
控制台输出将与之前提供的所有代码示例完全相同，并且基本上使用两行代码完成：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]