Java 返回列表中的项目

给定一个字符串列表，返回一个包含不同值的列表。换句话说，在返回的列表中不能多次包含任何值。（提示：思维定势）

区分值（[“红色”、“黄色”、“绿色”、“黄色”、“蓝色”、“绿色”、“紫色”）

->

[“红色”、“黄色”、“绿色”、“蓝色”、“紫色”]

distinctValue（[“叮当”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛铛”，“铃铛”，“铃铛”，“铃铛”，“铃铛

我的代码：

public List<String> distinctValues(List<String> stringList) {
        
        Map<String, String> distinctValuesMap = new HashMap<String, String>();
         
        for (int i= 0; i < stringList.size(); i++) {
            distinctValuesMap.put(stringList.get(i), stringList.get(i));
            
        }
        Set<String>distinctValuesSet = distinctValuesMap.keySet();
        List<String>distinctValues = new ArrayList<String>(distinctValuesSet);
        System.out.println(distinctValues);
        
        return distinctValues;
    }

public List distinctvalue（List stringList）{
Map distinctValuesMap=new HashMap（）；
对于（int i=0；i

预期结果：红色、黄色、绿色、蓝色、紫色
我的结果：红，绿，蓝，黄，紫

不确定哪里出错了，但我尝试了不同的方法，但没有得到预期的结果。
您正在丢失有关插入顺序的信息，因为您使用的是无序集合
Set插入顺序保留在像LinkedList这样的数据结构中（及其集合变量LinkedHashSet或映射变量LinkedHashMap）

在LinkedList上使用LinkedHashSet或LinkedHashMap的优点是，插入时，在LinkedHashSet或LinkedHashMap中执行重复检查时，它是O（1），其中LinkedList是O（n）

您也可以使用Java8
stream.distinct（）
实现同样的功能

以下是几个选项：

public class MyApp {
  public static void main(String[] args) {

    List myList = Arrays.asList("red", "yellow", "green", "yellow", "blue", "green", "purple");
    distinctValuesUsingStreamDistinct(myList).forEach(System.out::println);

    System.out.println("==============");

    distinctValuesUsingLinkedHashSet(myList).forEach(System.out::println);
  }

  public static List<String> distinctValuesUsingStreamDistinct(List<String> stringList) {
    return stringList.stream().distinct().collect(Collectors.toList());
  }

  public static List<String> distinctValuesUsingLinkedHashSet(List<String> stringList) {
    LinkedHashSet<String> setSortedByInsertionOrder = new LinkedHashSet<String>();
    stringList.forEach(str -> setSortedByInsertionOrder.add(str));
    return new ArrayList<>(setSortedByInsertionOrder);
  }
}


公共类MyApp{
公共静态void main（字符串[]args）{
List myList=Arrays.asList（“红色”、“黄色”、“绿色”、“黄色”、“蓝色”、“绿色”、“紫色”）；
distinctValuesUsingStreamDistinct（myList）.forEach（System.out:：println）；
System.out.println（“=========================”）；
使用LinkedHashSet（myList.forEach）（System.out:：println）的distinctValue；
}
公共静态列表distinctValuesSusingstreamDistinct（列表字符串列表）{
返回stringList.stream（）.distinct（）.collect（Collectors.toList（））；
}
公共静态列表distinctValuesUsingLinkedHashSet（列表字符串列表）{
LinkedHashSet setSortedByInsertionOrder=新LinkedHashSet（）；
forEach（str->setSortedByInsertionOrder.add（str））；
返回新的ArrayList（setSortedByInsertionOrder）；
}
}
集合只是一组值。它没有索引，因此没有顺序。当您将集合转换为ArrayList时，元素的顺序可以是任意的，并且无法更改。如果您想保持元素的顺序，可以使用ArrayList的一个简洁的小函数，名为
Retainal（）
。这样，您可以只保留集合中存在的元素，但保留ArrayList的顺序。以下是您的代码，稍作修改和简化，以演示这一点：

public List<String> distinctValues(List<String> stringList) {
    Set<String> distinctValuesSet = new HashSet<>(stringList);
    List<String> distinctValues = new ArrayList<>(stringList);
    distinctValues.retainAll(distinctValuesSet);
    return distinctValues;
}

public List distinctvalue（List stringList）{
Set distinctValuesSet=新哈希集（stringList）；
List distinctValues=新的ArrayList（stringList）；
distinctValues.Retainal（distinctValuesSet）；
返回不同的值；
}
Stream:：distinct
只需使用Java stream从列表中获得一个独特的元素列表，同时保留原始顺序

在一行代码中

List result=List.stream（）.distinct（）.collect（Collectors.toList（））；

或者多行

列表结果=
列表
.stream（）
.distinct（）
.收集(
收集者
)
;

请参见此。
HashMap
/
HashSet
不维护元素的顺序。A
LinkedHashSet
does@EmmaFrost请检查答案。希望他们消除您的疑虑谢谢大家的帮助，我是一名新的编码员。每条评论都非常有用。不。此代码不起作用。请查看它的运行情况。