import java.util.ArrayList;
public class Test_14_2 {
public static void main(String args[]) {
  ArrayList<Integer> arrayList_1 = new ArrayList<Integer>();
  ArrayList<Integer> arrayList_2 = new ArrayList<Integer>();
  ArrayList<Integer> arrayList_3 = new ArrayList<Integer>();
  ArrayList<Integer> arrayList_4 = new ArrayList<Integer>();
  arrayList_1.add(0);
  arrayList_1.add(1);
  arrayList_1.add(2);
  arrayList_1.add(3);
  arrayList_1.add(4);
  arrayList_1.add(5);
  arrayList_1.add(6);
  arrayList_1.add(7);
  arrayList_1.add(8);
  arrayList_1.add(9);
  arrayList_2 = arrayList_1;
  arrayList_3 = arrayList_1;
  arrayList_4 = arrayList_1;
  for (int a = 0; a < arrayList_1.size(); a++) {
   int i = arrayList_1.get(a);
   arrayList_2.remove(i);
   arrayList_3.remove(i);
   arrayList_4.remove(i);
   for (int b = 0; b < arrayList_2.size(); b++) {
    int j = arrayList_2.get(b);
    arrayList_3.remove(j);
    arrayList_4.remove(j);
    for (int c = 0; c < arrayList_3.size(); c++) {
     int m = arrayList_3.get(c);
     arrayList_4.remove(m);
     for (int d = 0; d < arrayList_4.size(); d++) {
      int n = arrayList_4.get(d);
      System.out.println(i * 1000 + j * 100 + m * 10 + n);
     }
    }
   }
  }
}
}


运行出错：先打印了几个数字，然后提示Exception in thread "main"
java.lang.IndexOutOfBoundsException: Index: 4, Size: 4
at java.util.ArrayList.RangeCheck(ArrayList.java:547)
at java.util.ArrayList.remove(ArrayList.java:387)
at Test.Test_14_2.main(Test_14_2.java:36)
。我发现在移除的时候实际是移除了arrayList_1中元素，的为什么会这样？

对集合进行增删改查最好不要用ArrayListl他是线性表，用链式表会好些

你首先建立了arrayList_1,并添加了元素，
然后建立arrayList_2,arrayList_3,arrayList_4,但是并不是对他们自己引用的ArrayList进行操作  而是将arrayList_1的引用赋给 arrayList_2,arrayList_3,arrayList_4,
这就让 arrayList_2,arrayList_3,arrayList_4,引用arrayList_1的引用（如下面的图）
而这个异常是IndexOutOfBoundsException数组越界异常   你在不断的remove（）但是操作的是同一个引用，只要移除十次 那个集合就空  但是程序还在对集合进行操作。
所以就会报告异常

1. import java.util.ArrayList;
   
2. 
   
3. public class Test_14_2
   
4. {
   
5.          public static void main(String args[])
   
6.         {
   
7.            ArrayList<Integer> arrayList_1 = new ArrayList<Integer>();
   
8.            ArrayList<Integer> arrayList_2 = new ArrayList<Integer>();
   
9.            ArrayList<Integer> arrayList_3 = new ArrayList<Integer>();
   
10.            ArrayList<Integer> arrayList_4 = new ArrayList<Integer>();
    
11.            
    
12.            arrayList_1.add(0);
    
13.            arrayList_1.add(1);
    
14.            arrayList_1.add(2);
    
15.            arrayList_1.add(3);
    
16.            arrayList_1.add(4);
    
17.            arrayList_1.add(5);
    
18.            arrayList_1.add(6);
    
19.            arrayList_1.add(7);
    
20.            arrayList_1.add(8);
    
21.            arrayList_1.add(9);
    
22.            
    
23.            arrayList_2 = arrayList_1;
    
24.            arrayList_3 = arrayList_1;
    
25.            arrayList_4 = arrayList_1;
    
26.            
    
27.                 for (int a = 0; a < arrayList_1.size(); a++)
    
28.                 {
    
29.                         int i = arrayList_1.get(a);
    
30.                         arrayList_2.remove(i);
    
31.                         arrayList_3.remove(i);
    
32.                         arrayList_4.remove(i);
    
33.                         for (int b = 0; b < arrayList_2.size(); b++)
    
34.                         {
    
35.                                 int j = arrayList_2.get(b);
    
36.                                 arrayList_3.remove(j);
    
37.                                 arrayList_4.remove(j);
    
38.                                 for (int c = 0; c < arrayList_3.size(); c++)
    
39.                                 {
    
40.                                         int m = arrayList_3.get(c);
    
41.                                         arrayList_4.remove(m);
    
42.                                         for (int d = 0; d < arrayList_4.size(); d++)
    
43.                                         {
    
44.                                                 int n = arrayList_4.get(d);
    
45.                                                 System.out.println(i * 1000 + j * 100 + m * 10 + n);
    
46.                                         }
    
47.                                 }
    
48.                         }
    
49.                 }
    
50.         }
    
51. }
    

复制代码

那是不是我想让每一个集合都有一个自己的内存空间的话，就得为每一个ArrayList添加元素

这就相当于C++里的指针一样，他指向一个内存单元，arrayList_2 = arrayList_1;

24.           arrayList_3 = arrayList_1;

25.           arrayList_4 = arrayList_1;
只是把 arrayList_1的首地址赋给了三个对象引用，使其指向同一内存空间，那么每个对象的操作都是对同一数据的操作，所以会出现以下运行结果：
333
334
335
339
Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 4, Size: 4
        at java.util.ArrayList.RangeCheck(Unknown Source)
        at java.util.ArrayList.remove(Unknown Source)
        at liu.test.eclipse.Test_14_2.main(Test_14_2.java:34)
每个集合没有值时，他的大小就是零，就没有空间大小，自然就没有内存空间，一旦你add数据，就会
创建存数据的空间

嗯。这个我懂