ArrayList删除和增加元素问题.

Question

要求在每次运行程序是,把List中前两个元素放在最后,代码如下.import java.util.ArrayList;
import java.util.List;
import java.util.Queue;public class BBB { /**
 * @param args
 */
public static void main(String[] args) {
Test2();
} public static void Test2() {
List<Integer> data = new ArrayList<Integer>();
data.add(0);
data.add(1);
data.add(2);
data.add(3);
data.add(4);
data.add(5);
data.add(6); System.out.println(data.toString());

for (int i = 0; i < data.size(); i++) {

data.add(data.get(i));
data.remove(data.get(i));
}
System.out.println(data.toString());
for (int i = 0; i < data.size(); i++) {

data.add(data.get(i));
data.remove(data.get(i));
}
System.out.println(data.toString());
}}输出结果[0, 1, 2, 3, 4, 5, 6]
[1, 3, 5, 0, 4, 2, 6]
[3, 0, 2, 1, 4, 5, 6]
首位的0并没有放在最后 这是为啥,
该如何解决JAVA集合

Answer 1

  data.add(data.get(i));
            System.out.println(data.toString());//这里加一句你就明白了，这是一个队列型的，从后面添加，前面删除了后面的就会自动不上，data[0]不会为空
            data.remove(data.get(i));
             System.out.println(data.toString());//这里加一句你就明白了

Answer 2

for循环里对List的结构进行了改变：data.add(data.get(i));此时data的长度已经变了。
data.remove(data.get(i));顺序再变一次。当第i次get和add的时候，对应位已经不适我们想的那样了。另外，data.get(i)是get(int index) ，是以“数组”下标为准的哦，LZ可以debug跟下看看。

Answer 3

另外，真实项目中，对list循环的时候，做remove和add操作，是大忌。

Answer 4

提问前自己调试的时候加过,,就算是自动补上了,那add方法不是加到最后位置么,怎么还会跑到中间去

Answer 5

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现 

Answer 6

提问前自己调试的时候加过,,就算是自动补上了,那add方法不是加到最后位置么,怎么还会跑到中间去
你把我下面程序跑一遍看看就知道错了。for (int i = 0; i < data.size(); i++) {
            System.out.println("本次删除的数是:"+data.get(i));//注意第二次循环的时候，i=1的时候，这时候list.get(1)的是是2了，因为队列为1234560
            data.add(data.get(i));
            System.out.println(data.toString());
            data.remove(data.get(i));
            
        }
        System.out.println(data.toString());

Answer 7

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

Answer 8

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

每次输出都是一样 

Answer 9

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }
API上说 " 如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。 
" 是不是这个关系 

Answer 10

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

每次输出都是一样 
因为你的需求就是这样的。你想要什么效果呢？

Answer 11

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }
API上说 " 如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。 
" 是不是这个关系 

需求是每次运行程序,把第一个元素放到最后一位,
0 1 2 3 4 5 6 
1 2 3 4 5 6 0这样的 

Answer 12

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

每次输出都是一样 
因为你的需求就是这样的。你想要什么效果呢？是每运行一次  要把前四个元素添加到List的尾部.
0 1 2 3 4 5 6
4 5 6 0 1 2 3
这样的 

Answer 13

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }
API上说 " 如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。 
" 是不是这个关系 

保证list1.addAll(list2);时，不会对list2做并发操作就没关系了。
源码：    public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
        int numNew = a.length;
ensureCapacity(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
return numNew != 0;
    }
第一步转换为a数组之后，如果有对c有并发操作，此时a数组不会受影响，这时的addAll看起来就“不准”了(表面上看起来，list1.addAll(list2)结果不一定了)。

Answer 14

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

每次输出都是一样 
因为你的需求就是这样的。你想要什么效果呢？是每运行一次  要把前四个元素添加到List的尾部.
0 1 2 3 4 5 6
4 5 6 0 1 2 3
这样的 
    public static void test2()
    {
        /*
         * 是每运行一次  要把前四个元素添加到List的尾部.
        0 1 2 3 4 5 6
        4 5 6 0 1 2 3
        这样的  
         */
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());        //循环到4即可
        for (int i = 0; i < 4 && i < data.size(); i++)
        {            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < 4 && i < data.size(); i++)
        {            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

Answer 15

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }

每次输出都是一样 
因为你的需求就是这样的。你想要什么效果呢？是每运行一次  要把前四个元素添加到List的尾部.
0 1 2 3 4 5 6
4 5 6 0 1 2 3
这样的 
    public static void test2()
    {
        /*
         * 是每运行一次  要把前四个元素添加到List的尾部.
        0 1 2 3 4 5 6
        4 5 6 0 1 2 3
        这样的  
         */
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());        //循环到4即可
        for (int i = 0; i < 4 && i < data.size(); i++)
        {            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < 4 && i < data.size(); i++)
        {            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }好简洁...我的方法是在循环里面加了个判断....  

Answer 16

debug看过了..是我理解错了...那我现在这个需求该如何改变才能实现     public static void test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        //用来存放不要的数据
        List<Integer> delData = new ArrayList<Integer>();
        //用来存放要增加的数据
        List<Integer> addData = new ArrayList<Integer>();
        System.out.println(data.toString());
         
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
 
        //复用
        delData.clear();
        addData.clear();
        for (int i = 0; i < data.size(); i++) {
             
            addData.add(data.get(i));//data.add(data.get(i));
            delData.add(data.get(i));//data.remove(data.get(i));
        }
        //统一删、增
        data.removeAll(delData);
        data.addAll(addData);
        System.out.println(data.toString());
    }
API上说 " 如果正在进行此操作时修改指定的 collection ，那么此操作的行为是不确定的。（这意味着如果指定的 collection 是此列表且此列表是非空的，那么此调用的行为是不确定的）。 
" 是不是这个关系 

需求是每次运行程序,把第一个元素放到最后一位,
0 1 2 3 4 5 6 
1 2 3 4 5 6 0这样的 

让我想起了循环队列

Answer 17

你的本意其实你自己都理解错了，
干嘛还一个for循环

Answer 18

回楼主：真心不推荐arraylist，记得学习时候说的查询arraylist,排序likedlist我写的，如下：
package com.nyohh.test1;import java.util.LinkedList;
import java.util.List;public class SortFirstToEnd
{
public static void main(String[] args)
{
List<Integer> data = null;
if (null == data)
{
data = new LinkedList<Integer>();
data.add(0);
data.add(1);
data.add(2);
data.add(3);
data.add(4);
data.add(5);
data.add(6);
System.out.println("初始序列:"+data);
}
System.out.println(sortList(data));
System.out.println(sortList(data));
System.out.println(sortList(data));
System.out.println(sortList(data));
} private static List<Integer> sortList(List<Integer> data)
{
int num = 2;// 这个num表示要把前面几个放到最后去 for (int i = 0; i < num; i++)
{
data.add(data.remove(0));
} return data;
}
}

Answer 19

回楼主：真心不推荐arraylist，记得学习时候说的查询arraylist,排序likedlist我写的，如下：
package com.nyohh.test1;import java.util.LinkedList;
import java.util.List;public class SortFirstToEnd
{
public static void main(String[] args)
{
List<Integer> data = null;
if (null == data)
{
data = new LinkedList<Integer>();
data.add(0);
data.add(1);
data.add(2);
data.add(3);
data.add(4);
data.add(5);
data.add(6);
System.out.println("初始序列:"+data);
}
System.out.println(sortList(data));
System.out.println(sortList(data));
System.out.println(sortList(data));
System.out.println(sortList(data));
} private static List<Integer> sortList(List<Integer> data)
{
int num = 2;// 这个num表示要把前面几个放到最后去 for (int i = 0; i < num; i++)
{
data.add(data.remove(0));
} return data;
}
}业务场景是jsp一个封装过的方法 只能返回List.....每次登陆该页面展示的东西不一样...于是就想把每一次看过的往后移动

Answer 20

import java.util.ArrayList;
import java.util.List;
import java.util.Queue;
 
public class BBB {
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        Test2();
    }
 
    public static void Test2() {
        List<Integer> data = new ArrayList<Integer>();
        data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
 
        System.out.println(data.toString());
        data.add(data.get(0));//无需for循环，第一个数到最后
        data.remove(data.get(0));
        System.out.println(data.toString());
        data.add(data.get(0));//无需for循环，第一个数（一开始数组中的第二个）到最后
        data.remove(data.get(0));
        System.out.println(data.toString());
    }
 
}楼主把自己的for循环跑一遍就知道了，还有可以像楼上的那样把练个元素一起增加删除，在for循环里加一个i<2就可以了，那样复用性更高！

Answer 21

需求是在jsp中读取数据库中的数据的., 不循环只能写死了

Answer 22

这个就不要使用ArrayList的，最好使用LinkedList来实现，可参考如下代码：
List<Integer> data = new LinkedList<Integer>();
data.add(0);
        data.add(1);
        data.add(2);
        data.add(3);
        data.add(4);
        data.add(5);
        data.add(6);
        System.out.println("List修改之前："+data.toString());
        int d1 = data.remove(0);
        data.add(data.size(), d1);//将原第一个值添加至末尾
        System.out.println("List修改之后："+data.toString());

Answer 23

import java.util.LinkedList;public class Test {
public static void main(String[] args) {
toDemo();
}
public static void toDemo(){
LinkedList<Integer> data=new LinkedList<Integer>();
data.add(0);
data.add(1);
data.add(2);
data.add(3);
data.add(4);
data.add(5);
data.add(6);
System.out.println(data.toString());
data.add(data.removeFirst());
System.out.println(data.toString());
data.add(data.removeFirst());
System.out.println(data.toString());

}
}
//代码简单明了，无需index，请指教