Java 遍历对象列表，跳过一个索引，稍后再读取

我有一个ArrayList，它包含字符串名称、字符串描述和字符串url。 我正在反复浏览列表

我有网站列表

名称--域

在迭代上述列表时，我想跳过“希尔顿”一次，让“墨水”在迭代之前消失

List<Domain> dmn = new ArrayList<Domain>();
for(Domain names:dmn) {
    if(dmn.get(0).getName().equalsIgnoreCase("Hilton")) {
        int index = 0;
        dmn.subList(index, index+1);                       
    }
}

List dmn=new ArrayList（）；
for（域名：dmn）{
if（dmn.get（0.getName（）.equalsIgnoreCase（“希尔顿”））{
int指数=0；
dmn.子列表（索引，索引+1）；
}
}

基本上我想把希尔顿的指数改为1。如何使用列表实现。

int hiltonIndex；
int hiltonIndex;
Domain hilton;
for (int i = 0; i < dmn.size(); i++) {
    Domain d = dmn.get(i);
    if(...) {
        hiltonIndex = i; //Save the index of the Hilton Domain
        hilton = d;
    }
    else {
        //I assume you want to do stuff
    }
}
dmn.remove(hiltonIndex);
dmn.add(hilton);

希尔顿酒店；
对于（int i=0；i

或者，基本上我只是找到希尔顿的索引，删除它，然后把它放回列表的末尾

如果你只想这样做一次，那么不要删除并重新输入，只要在迭代后对“希尔顿”做你想做的事情就行了

int-hiltonIndex；
希尔顿酒店；
对于（int i=0；i

或者，基本上我只是找到希尔顿的索引，删除它，然后把它放回列表的末尾

如果你只想这样做一次，那么不要删除并重新输入，只要在迭代后对“希尔顿”做你想做的事情就行了

代码：

   List<String> list = Arrays.asList("Apple  www.apple.com", "Bing   www.bing.com",
            "Google www.google.com", "Hilton www.hiltonhotels.com ", "Ink    www.ink.com");

    List<String> list2 = new ArrayList<>();
    int index = 0;
    for (int i = 0; i < list.size()-1; i++) { 
        if (list.get(i).contains("Hilton") ) {
           index = i;
           String  s = list.get(i);
           list2.add(list.get(i+1));
        } else {
            list2.add(list.get(i));
        }

    }
    list2.add(index+1, list.get(index));
    for (String st : list2) {
        System.out.println(st + " ");
    }

如果您不想使用列表副本，您可以这样做

代码：

代码：

如果您不想使用列表副本，您可以这样做

代码：

---

也许我低估了/简化了这个问题，但一个可能的解决方案是：

    List<Domain> dmn = new ArrayList<Domain>();
    Iterator<Domain> it = dmn.iterator();
    while(it.hasNext()){
        Domain dom = it.next();
        if(dom.getName().equalsIgnoreCase("Hilton") && it.hasNext()) { // prevents problems if "Hilton" is the last element
        {
            Domain domAfter = it.next();
            System.out.println(domAfter); //do something with the next after Hilton first
            System.out.println(dom);  //do something with Hilton then
        }
        else System.out.println(dom); //else do something with the current element
    }

List dmn=new ArrayList（）；
迭代器it=dmn.Iterator（）；
while（it.hasNext（））{
Domain dom=it.next（）；
if（dom.getName（）.equalsIgnoreCase（“Hilton”）和&it.hasNext（））{//如果“Hilton”是最后一个元素，则防止出现问题
{
Domain domAfter=it.next（）；
System.out.println（domAfter）；//先对希尔顿后面的下一个做点什么
System.out.println（dom）；//那就和希尔顿做点什么吧
}
else System.out.println（dom）；//else对当前元素执行某些操作
}

---

问题中我缺少的是，您与

数组列表的元素有什么关系。这不是一种非常优雅的方式，您不需要使用其他列表。
也许我低估了/简化了问题，但有一个可能的解决方案：

    List<Domain> dmn = new ArrayList<Domain>();
    Iterator<Domain> it = dmn.iterator();
    while(it.hasNext()){
        Domain dom = it.next();
        if(dom.getName().equalsIgnoreCase("Hilton") && it.hasNext()) { // prevents problems if "Hilton" is the last element
        {
            Domain domAfter = it.next();
            System.out.println(domAfter); //do something with the next after Hilton first
            System.out.println(dom);  //do something with Hilton then
        }
        else System.out.println(dom); //else do something with the current element
    }

List dmn=new ArrayList（）；
迭代器it=dmn.Iterator（）；
while（it.hasNext（））{
Domain dom=it.next（）；
if（dom.getName（）.equalsIgnoreCase（“Hilton”）和&it.hasNext（））{//如果“Hilton”是最后一个元素，则防止出现问题
{
Domain domAfter=it.next（）；
System.out.println（domAfter）；//先对希尔顿后面的下一个做点什么
System.out.println（dom）；//那就和希尔顿做点什么吧
}
else System.out.println（dom）；//else对当前元素执行某些操作
}

我在这个问题中遗漏的是，您必须如何处理
数组列表的元素。这不是一种非常优雅的方式，您不需要使用另一个列表。
一种解决方案就是您尝试过的：

//i've encapsulated the sorting code in a method that receives a list as a parameter.
private List<Domain> sortDomains1(final List<Domain> domains)
{
    //this is a tempList that will be returned from subList method.
    List<Domain> tempList = null;
    //as your using iterator anonymously, you have to implement an index
    int i = 0;
    for(final Domain domain : domains) 
    {
        //looking for 'Hilton'.
        if(domain.getName().equalsIgnoreCase("Hilton")) 
        {
            //here we're getting a sublist of 2 elements that need to be switched in positions
            tempList = domains.subList(i, i+2); //have to get 2 elements
            break; //if we'have found it, then we leaven the loop and switch positions;
        }
        //increasing an index of the array
        i++;
    }

    //having a subList we can change the order. It will also change it in the original list.
    Domain tempDomain; //we have to make a switch, so we need a temp Domain.
    tempDomain = tempList.get(1); //the one after hilton will be temp.
    tempList.set(1, tempList.get(0));  //put hilton in second position
    tempList.set(0, tempDomain);       //put temp in first.

    return domains;
}

这个方法更灵活，因为你可以做更多的更改+我上面写的所有内容。
在这两种情况下，您都可以向这些方法添加其他参数—要移动的元素名称或要移动的域，即：

private List<Domain> sortDomains2(final List<Domain> domains, final String elementToMove)
{
    for(int i = 0; i < domains.size(); i++) 
    {
        if(domains.get(i).getName().equalsIgnoreCase(elementToMove)) 
        {
            Domain temp = domains.get(i);
            domains.set(i, domains.get(i+1));
            domains.set(i+1, temp);
            i++;
        }
    }

    return domains;
}

一种解决方案是您尝试过的：

//i've encapsulated the sorting code in a method that receives a list as a parameter.
private List<Domain> sortDomains1(final List<Domain> domains)
{
    //this is a tempList that will be returned from subList method.
    List<Domain> tempList = null;
    //as your using iterator anonymously, you have to implement an index
    int i = 0;
    for(final Domain domain : domains) 
    {
        //looking for 'Hilton'.
        if(domain.getName().equalsIgnoreCase("Hilton")) 
        {
            //here we're getting a sublist of 2 elements that need to be switched in positions
            tempList = domains.subList(i, i+2); //have to get 2 elements
            break; //if we'have found it, then we leaven the loop and switch positions;
        }
        //increasing an index of the array
        i++;
    }

    //having a subList we can change the order. It will also change it in the original list.
    Domain tempDomain; //we have to make a switch, so we need a temp Domain.
    tempDomain = tempList.get(1); //the one after hilton will be temp.
    tempList.set(1, tempList.get(0));  //put hilton in second position
    tempList.set(0, tempDomain);       //put temp in first.

    return domains;
}

这个方法更灵活，因为你可以做更多的更改+我上面写的所有内容。
在这两种情况下，您都可以向这些方法添加其他参数—要移动的元素名称或要移动的域，即：

private List<Domain> sortDomains2(final List<Domain> domains, final String elementToMove)
{
    for(int i = 0; i < domains.size(); i++) 
    {
        if(domains.get(i).getName().equalsIgnoreCase(elementToMove)) 
        {
            Domain temp = domains.get(i);
            domains.set(i, domains.get(i+1));
            domains.set(i+1, temp);
            i++;
        }
    }

    return domains;
}

至于你在另一条评论中提出的问题，它是有效的，所以没有问题。但是，第二个例子并没有改变列表的顺序。这个答案与OP建议的解决方案没有关系——这是subList（）方法。没有解释——只是代码。subList（）而已从另一条注释中返回问题的列表-它可以工作，所以没问题。但是，第二个示例并没有改变列表的顺序。这个答案与OP建议的解决方案没有关系-这是subList（）方法。没有解释-只有code.subList（）返回一个列表我认为这并不能解决问题，问题是：基本上我想把希尔顿的索引改成1个值。如何使用列表。它按OP要求的顺序打印，但没有按正确的顺序返回数组。但可能是我过度解释了这个问题；）嗨，请详细说明我哪里出错了。这不过，s只是一个临时的解决方法。谢谢你的帮助。我缺少的是你这一次的意思。我知道你只想为一次迭代使用不同的顺序，但也许你想要两个元素（希尔顿和下一个）的索引以一种永久性的方式切换。我认为这并不能解决以下问题：基本上我想将希尔顿的索引更改1个值。我如何实现使用列表。它按OP要求的顺序打印，但没有按正确的顺序返回数组。但可能是我过度解释了这个问题；）嗨，请详细说明我在做什么一个错误。不过这只是一个暂时的解决办法。谢谢你的帮助。我缺少的是你这一次的意思。我明白你想要的是不同的
private List<Domain> sortDomains2(final List<Domain> domains)
{
    for(int i = 0; i < domains.size(); i++) {
        if(domains.get(i).getName().equalsIgnoreCase("Hilton")) 
        {
            Domain temp = domains.get(i);
            domains.set(i, domains.get(i+1));
            domains.set(i+1, temp);
            i++;
        }
    }

    return domains;
}

private List<Domain> sortDomains2(final List<Domain> domains, final String elementToMove)
{
    for(int i = 0; i < domains.size(); i++) 
    {
        if(domains.get(i).getName().equalsIgnoreCase(elementToMove)) 
        {
            Domain temp = domains.get(i);
            domains.set(i, domains.get(i+1));
            domains.set(i+1, temp);
            i++;
        }
    }

    return domains;
}

List<Domain> sortedDomains2 = sortDomains2(new ArrayList<Domain>(domains), "Bing");
sortedDomains2 = sortDomains2(new ArrayList<Domain>(sortedDomains2), "Hilton");

public class Main 
{
    public static void main(String args[])
    {
        new Main().run();
    }

    private void run()
    {
        List<Domain> domains = getDomains();

        System.out.println("Domains before sorting: " + domains);

        List<Domain> sortedDomains1 = sortDomains1(new ArrayList<Domain>(domains));
        List<Domain> sortedDomains2 = sortDomains2(new ArrayList<Domain>(domains));

        System.out.println("Domains after sorting by method1: " + sortedDomains1);
        System.out.println("Domains after sorting by method2: " + sortedDomains2);

        System.out.println("Original list: " + domains);
    }

    private List<Domain> sortDomains1(final List<Domain> domains)
    {
        List<Domain> tempList = null;
        int i = 0;
        for(final Domain domain : domains) 
        {
            if(domain.getName().equalsIgnoreCase("Hilton")) 
            {
                tempList = domains.subList(i, i+2);
                break;
            }
            i++;
        }

        Domain tempDomain;
        tempDomain = tempList.get(1);
        tempList.set(1, tempList.get(0));
        tempList.set(0, tempDomain);

        return domains;
    }

    private List<Domain> sortDomains2(final List<Domain> domains)
    {
        for(int i = 0; i < domains.size(); i++) 
        {
            if(domains.get(i).getName().equalsIgnoreCase("Hilton")) 
            {
                Domain temp = domains.get(i);
                domains.set(i, domains.get(i+1));
                domains.set(i+1, temp);
                i++;
            }
        }

        return domains;
    }

    private class Domain
    {
        private final String name;

        private Domain(final String name)
        {
            this.name = name;
        }

        private String getName()
        {
            return name;
        }

        @Override
        public String toString()
        {
            return name;
        }
    }

    private List<Domain> getDomains()
    {
        List<Domain> list = new ArrayList<Domain>();
        list.add(new Domain("Apple"));
        list.add(new Domain("Bing"));
        list.add(new Domain("Google"));
        list.add(new Domain("Hilton"));
        list.add(new Domain("Ink"));
        list.add(new Domain("Facebook"));
        return list;
    }
}

Domains before sorting: [Apple, Bing, Google, Hilton, Ink, Facebook]
Domains after sorting by method1: [Apple, Bing, Google, Ink, Hilton, Facebook]
Domains after sorting by method2: [Apple, Bing, Google, Ink, Hilton, Facebook]
Original list: [Apple, Bing, Google, Hilton, Ink, Facebook]