这是我对问题/问题陈述的理解：
您的输入是一个可能重复的数字1-n的列表，其中n永远不会大于列表的大小。
迭代列表时，数字的第一个示例（非重复）应保留在其当前索引处。
迭代列表时发现的数字的每个后续副本都应替换为“缺失集”中的一个数字。
“缺失集”包含所有数字1-n，其中n是删除现有集（从输入列表中）后列表的大小。
最终结果列表应包含所有数字1- listSize 没有重复项，任何数字的第一个示例（从列表开始迭代）与输入列表位于同一索引处。
如果上面的语句听起来正确，下面是一种方法（尽管可能有一种更优化的方法）：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class ReplaceDuplicateIntegersRunner {
    private static ArrayList<Integer> sampleIntegerList = new ArrayList<>();

    public static void main(String[] args) {
        addRandomIntegersToList(3,7);
        System.out.println("List Before: " + sampleIntegerList);
        replaceDuplicatesWithContinuedCount();
        System.out.println("List After: " + sampleIntegerList);

    }

    public static void addRandomIntegersToList(Integer maxValue, Integer numOfIntegers) {
        Random randomGen = new Random();
        for (int num = 0; num < numOfIntegers; num++) {
            sampleIntegerList.add(1 + randomGen.nextInt(maxValue));
        }
    }

    public static void replaceDuplicatesWithContinuedCount() {
        // generate a set of integers 1 - length of sampleIntegerList
        Set<Integer> integerSetToAdd = IntStream.rangeClosed(1, sampleIntegerList.size())
                .boxed().collect(Collectors.toSet());
        // remove the integers which already exist in the target sample list
        integerSetToAdd.removeAll(new HashSet<>(sampleIntegerList));
        ArrayList<Integer> integersToReplaceDuplicates = new ArrayList<>();
        integersToReplaceDuplicates.addAll(integerSetToAdd);
        int indexOfIntegersToAdd = 0;
        HashSet<Integer> duplicatesInList = new HashSet<>();
        for (int index = 0; index < sampleIntegerList.size(); index++) {
            // if our duplicate set doesn't already have this number, we don't have a duplicate, add it to the set
            // and continue on
            Integer integerAtIndex = sampleIntegerList.get(index);
            if (duplicatesInList.contains(integerAtIndex) == false) {
                duplicatesInList.add(integerAtIndex);
            } else {
                // otherwise we've found a duplicate and need to replace it with the next one to replace
                sampleIntegerList.set(index, integersToReplaceDuplicates.get(indexOfIntegersToAdd));
                indexOfIntegersToAdd++;
            }
        }
    }
}

带有上面传入参数的一些示例输出：
前列表：[3、2、3、3、1、1、1]后列表：[3、2、4、5、1、6、7]
前面的列表：[2，3，2，2，3，2，1]后面的列表：[2，3，4，5，6，7，1]

如果要获取不按特定顺序排列的数字序列，可以创建该序列并替换旧序列：

List<Integer> list = IntStream
        // from 1 to 5 inclusive
        .rangeClosed(1, 5)
        // Stream<Integer>
        .boxed()
        .collect(Collectors.toList());

// random order
Collections.shuffle(list);

System.out.println(list); // [2, 4, 3, 1, 5]

首先找出缺少的值
遍历列表并检查当前值是否重复。如果为true，则替换为缺少的值之一
假设您使用的是java 8或更高版本，下面的内容可能是一个起点：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Test {

    public static void main(String[] args) {
        List<Integer> myNumbers = new ArrayList<>();
        myNumbers.add(1);
        myNumbers.add(2);
        myNumbers.add(1);
        myNumbers.add(3);
        myNumbers.add(1);
        System.out.println("original: " + myNumbers);
        List<Integer> missing = IntStream.rangeClosed(1,myNumbers.size())
                .filter(i -> !myNumbers.contains(i))
                .boxed().collect(Collectors.toList());
        System.out.println("missing: " + missing);

        Set<Integer> unique = new HashSet<>();
        Iterator<Integer> misIterator = missing.iterator();
        for(int i = 0; i < myNumbers.size(); i++){
            if(!unique.add(myNumbers.get(i))){
                myNumbers.set(i, misIterator.next());
            }
        }
        System.out.println("modified" + myNumbers);
    }
}

您可以初始化 List 相同大小的所有元素都将设置为 0 然后更换 0 此列表的以下内容：
对于重复元素，设置 ++max 哪里 int max = Collections.max(myNumbers) .
对于不重复的数字，设置原始数字。
演示：

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> myNumbers = new ArrayList<>();
        myNumbers.add(1);
        myNumbers.add(2);
        myNumbers.add(1);
        myNumbers.add(3);
        myNumbers.add(1);

        int max = Collections.max(myNumbers);

        List<Integer> result = new ArrayList<>();
        for (int i = 0; i < myNumbers.size(); i++) {
            result.add(0);
        }

        for (int i = 0; i < myNumbers.size(); i++) {
            int n = myNumbers.get(i);
            if (result.contains(n)) {
                result.set(i, ++max);
            } else {
                result.set(i, n);
            }
        }

        System.out.println(result);
    }
}

输出：

[1, 2, 4, 3, 5]