如何在java中反转不可修改的列表

我正在尝试反转一个不可修改的列表。然而，我试图实现它，但是否有可能更新或逆转和不可修改的列表？我知道我们可以用谷歌不可变列表做到这一点

import java.util.*;

public class ImmutableList 
 {

public static void main(String args[])
{
    String[] mylist = {"Apple","Orange","Mango","Kiwi","Banana"};
    List reverselist = new ArrayList();
    List<String> strList = Arrays.asList(mylist);
    List<String> unmodifiableList = Collections.unmodifiableList(strList);
    for(int i=unmodifiableList.size();i>0;i--)
    {
        reverselist.add(unmodifiableList.get(i-1));

    }
    List<String> reverse = Collections.unmodifiableList(reverselist);
    System.out.println(reverse);
  }

 }

import java.util.*；
公共类不可变列表
{
公共静态void main（字符串参数[]）
{
字符串[]mylist={“苹果”、“橘子”、“芒果”、“猕猴桃”、“香蕉”}；
List reverselist=新建ArrayList（）；
List strList=Arrays.asList（mylist）；
列表不可修改列表=集合。不可修改列表（strList）；
对于（int i=unmodifiableList.size（）；i>0；i--）
{
reverselist.add（不可修改列表.get（i-1））；
}
列表反向=集合。不可修改列表（反向列表）；
系统输出打印项次（反向）；
}
}

---

在上面的程序中，我只是从后面遍历不可修改列表，然后将它们放入一个数组中，然后将该数组添加到新的不可修改列表中。我们能否以更好的方式进行优化？

可能不是最好的解决方案，但最好是逆转我们自己：

public List<T> reverseUnModList(List<T> unModListOrig) {
    List<T> tmpList = new ArrayList<T>(unModListOrig); 
    Collections.reverse(tmpList);
    return Collections.unmodifiableList(unModListOrig);
    //return tmpList; //if the result not need to be unmodifieable
}

public List reverseUnModList（List unModListOrig）{
List tmpList=新的ArrayList（unModListOrig）；
集合。反向（tmpList）；
返回集合。不可修改列表（unModListOrig）；
//返回tmpList；//如果结果不需要不可修改
}

当列表无论如何都不可修改时，您可以在列表上创建一个反向视图

这在性能和存储方面是最佳的：创建此列表需要O（1）个时间和O（1）个额外空间

import java.util.AbstractList;
import java.util.Arrays;
import java.util.List;

public class ReversedListViewTest
{
    public static void main(String[] args)
    {
        String[] array = {"Apple","Orange","Mango","Kiwi","Banana"};

        List<String> list = Arrays.asList(array);
        System.out.println("List         : "+list);

        List<String> reversedView = reversedView(list);
        System.out.println("Reversed view: "+reversedView);
    }

    private static <T> List<T> reversedView(final List<T> list)
    {
        return new AbstractList<T>()
        {
            @Override
            public T get(int index)
            {
                return list.get(list.size()-1-index);
            }

            @Override
            public int size()
            {
                return list.size();
            }
        };
    }

}

import java.util.AbstractList；
导入java.util.array；
导入java.util.List；
公共类ReversedListViewTest
{
公共静态void main（字符串[]args）
{
String[]数组={“苹果”、“橘子”、“芒果”、“猕猴桃”、“香蕉”}；
列表=数组。asList（数组）；
System.out.println（“列表：+List”）；
列表反向视图=反向视图（列表）；
System.out.println（“反转视图：”+reversedView）；
}
私有静态列表反转视图（最终列表）
{
返回新的AbstractList（）
{
@凌驾
公共T获取（整数索引）
{
返回list.get（list.size（）-1-index）；
}
@凌驾
公共整数大小（）
{
返回list.size（）；
}
};
}
}

Guava的

列表。reverse（List）

返回原始列表的反向视图，不进行任何复制。

Guava的

不可变列表

方法只需将原始

不可变列表

的内容复制到可变列表中，调用

Collections.reverse

并返回一个新的

ImmutableList

。它不会修改原始的

不可修改列表

（就像你看起来的那样）。是的，我知道番石榴，但它可以实现不可修改吗？因为如果我做任何操作，我会在不可修改的列表中得到不受支持的操作异常。唯一的方法是复制原始不可修改列表的内容，反转列表（或者如果你正在反向循环，不要做任何事情），然后使其不可修改，就像Guava做的那样。我不认为这是一个更好的反向循环解决方案，复制列表一次，然后反转列表。这肯定比反向循环和直接分配有更多的访问。这与访问量无关，与总的持续时间有关。复制列表很痛苦，没错。但是Collections.reverse只是关于使用set（）进行索引操作。除此之外，Vikram的原始代码可以通过不在每个循环中调用来优化。size（）：final int size=unmodifiableList.size（）；对于（inti=size；i>0；i--）很抱歉我的困惑，但我不明白。Vikram的方法只需在列表中循环一次，并将值添加到目标列表中，因此两个列表的所有值都只被触摸一次。这和复制是一样的，但是在你的方法中，你在复制后会做额外的步骤，那么如何在更短的时间内完成呢？你可以自己测量。我的建议快一点。Vikram的代码在我的机器上需要一个10000000个字符串的列表245ms，我的提案需要61ms。但速度只是优化的一个方面。内存消耗是另一个因素，但这里的Collections.reverse也稍微好一点。