黑马程序员技术交流社区

标题: 关于集合的引用是什么？ [打印本页]
作者: 李玉江    时间: 2013-6-1 17:34
标题: 关于集合的引用是什么？
class  Demo
{
        public static void main(String[] args)
        {
                ArrayList al=new ArrayList();
                al.add("java01");
                al.add("java02");
                al.add("java03");
                sop(al);
                Iterator it =al.iterator();
                while (it.hasNext())
                {
                        Object obj=it.next();
                        if (obj.equals("java02"))
                        {
                                it.remove();
                        }
                        sop("obj="+obj);
                }
                sop(al);
                //老师说将java02的引用从集合中删除了 。这个引用是角标吗？
                //删除后那在打印集合的时候像数组一样没有al[1]了吗？
                //应该不是吧也就是集合是怎么调用它的元素的？

        }
}//在并发异常中如要用listIterator操作删除集合的元素，集合进行访问的时候不也会出错吗？
作者: First    时间: 2013-6-3 19:07
首先要理解的是ArrayList 是动态的数组，
这样增加元素是会增加数组的长度，减少元素是会缩短数组的长度。
要实现这样的效果就要new 出新数组。
换句话说把原来那个数组里的元素遍历后重新放到一个新的数组中，这样是否可以理解？

贴个动态数组的例子，希望楼主能够理解我的观点：
  1. /*
  2. 现在要求定义一个数组(Array)，里面定义了一个整型数组，但是此整型数组属于动态分配大小，
  3. 即：所以大小由程序指定，并在此基础上实现以下的两个子类。
  4.         *反转类：可以将数组的内容反转排列
  5.         *排序类：可以对数组进行排序的操作
  6. */

  8. import java.util.ArrayList;
  9. import java.util.Arrays;
  10. import java.util.Collections;
  11. import java.util.Comparator;
  12. import java.util.List;

  14. public class MyDynamicArray {

  16.         public static void main(String []args){
  17.        
  18.                 ReverseArray al = new ReverseArray();
  19.                 SortArray sa = new SortArray();

  21.                 al.add(1);
  22.                 al.add(15);
  23.                 al.add(7);
  24.                 al.add(19);
  25.                 al.add(5);
  26.                 al.add(29);
  27.                 al.add(9);
  28. /*
  29.                                 al.add(7);
  30.                 al.add(19);
  31.                 al.add(5);
  32.                 al.add(29);
  33.                 al.add(9);
  34.                 sa.add(7);
  35.                 sa.add(19);
  36.                 sa.add(5);
  37.                 sa.add(29);
  38.                 sa.add(9);   */
  39.                
  40.                 sa.add(1);
  41.                 sa.add(15);
  42.                 sa.add(7);
  43.                 sa.add(19);
  44.                 sa.add(5);
  45.                 sa.add(29);
  46.                 sa.add(9);


  49.                 System.out.println(al.toString());
  50.                 //System.out.println(al);
  51.                 al.reverse();
  52.                 System.out.println(al.toString());
  53.                
  54.                 System.out.println(sa.toString());
  55.                 sa.sort();
  56.                 System.out.println(sa.toString());

  58.         }
  59. }


  62. class Array {
  63.         private int [] array = new int[10];
  64.         private int size =0;
  65.        
  66.         public int getSize() {
  67.                 return size;
  68.         }
  69.         public void setSize(int size) {
  70.                 this.size = size;
  71.         }
  72.          
  73.         public int get(int index){
  74.                 return array[index];
  75.         }
  76.        
  77.         public int set(int index, int element){
  78.                 array[index] = element;
  79.                 return get(index);
  80.         }
  81.        
  82.         public boolean add(int i){
  83.                 size++;
  84.                 System.out.println(size);
  85.                 if(size>10)
  86.                         array = copyArray(array);

  88.                 array[size-1] = i;
  89.                 return true;
  90.         }
  91.        
  92.         private int[] copyArray(int[] array){
  93.                        
  94.                 int []array1 = new int[array.length+1];
  95.                
  96.                 for(int i = 0; i<array.length;i++){
  97.                         array1[i] = array[i];
  98.                 }
  99.                 return array1;
  100.         }
  101.        
  102.         public boolean remove(int index){
  103.                 if(index>=size)
  104.                         return false;
  105.                 else{
  106.                         int[] array1 = new int[size - 1];
  107.                         for(int i = 0, count = 0; i<size;i++){
  108.                                 if(i == index)
  109.                                         continue;
  110.                                 array1[count++] = array[i];                               
  111.                         }
  112.                         array = array1;
  113.                         size--;
  114.                         return true;
  115.                 }
  116.         }
  117.        
  118.         @Override
  119.         public String toString() {
  120.                 // TODO Auto-generated method stub
  121.                 Integer [] intList = new Integer[size];
  122.                
  123.                 for(int i = 0;i<size;i++){//注意角标越界。
  124.                         intList[i] = get(i);
  125.                 }
  126.                 List list = Arrays.asList(intList);
  127.                 return list.toString();
  128.         }       
  129. }

  131. class ReverseArray extends Array{
  132.        
  133.         public void reverse(){
  134.                 int size = getSize();
  135.                 int half = size>>1;
  136.                
  137.                 for(int i =0,x=0; i< half;i++){
  138.                         x = get(i);
  139.                         set(i, get(size-1-i));
  140.                         set(size-1-i,x);
  141.                 }
  142.         }

  144.        
  145.         public void sort(){
  146.                 int size = getSize();

  148.                 for(int z=0,x=0;z<size-1;z++){
  149.                         for(int y=z+1; y<size;y++){//y=z+1; 而不是1；
  150.                                 if(get(z)>get(y)){
  151.                                         x = get(z);
  152.                                         set(z, get(y));
  153.                                         set(y,x);
  154.                                 }
  155.                         }
  156.                 }
  157.         }
  158.        
  159. }

  161. class SortArray extends Array{
  162.         public void sort(){
  163.                 int size = getSize();

  165.                 for(int z=0,x=0;z<size-1;z++){
  166.                         for(int y=z+1; y<size;y++){
  167.                                 if(get(z)>get(y)){
  168.                                         x = get(z);
  169.                                         set(z, get(y));
  170.                                         set(y,x);
  171.                                 }
  172.                         }
  173.                 }
  174.         }
  175. }
复制代码
作者: 王瀛    时间: 2013-6-4 00:06
我是这样理解的，在ArrayList集合中，"java02"这个对象有一个集合中的名字(索引、角标)，当使用Iterator迭代器进行hasNext判断后，迭代器将这个集合中的名字告诉了外界，obj这时找到了对应的集合中元素。

在使用remove进行判断移除时，迭代器仅仅是将这个对象元素在集合中移除了，但是这个对象还是在的，他被obj指向，所以while循环内打印出来的相当于是集合中原来所有元素的遍历结果。

出循环后，打印的al就是迭代器进行了一轮操作后的集合元素
作者: 殇_心。    时间: 2013-6-4 16:16
如果问题已解决，请及时修改分类，否则继续提问，谢谢合作！



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2