jakyforever

  博客园 :: 首页 :: 博问 :: 闪存 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
package com.jaky.Collection;

import java.util.Arrays;
import java.util.Iterator;

/**
 * 使用数组实现ArrayList 存放 String
 * 1、构造器 
 * 2、新增方法 1)容器最后一个 add(元素) 2)插入,指定位置存放
 * 3、获取指定索引的元素 get 
 * 4、修改 : 
 * 5、删除 1)、根据索引删除 2)、根据元素删除 一次 3)、根据元素删除所有
 * 
 * 6、迭代器 7、foreach 必须实现 java.lang.Iterable +iterator
 * 
 * @author Administrator
 * 
 */
public class MyArrayList {
    // 字符串数组
    private String[] elementData;
    // 实际元素大小
    private int size;

    // 1、构造器

    public MyArrayList() {
        this(5);
    }

    // 指定数组容量
    public MyArrayList(int len) {
        if (len <= 0 || len > 100) {
            System.out.println("长度不合法||");
            return;
        }
        elementData = new String[len];
    }

    /**
     * 扩容 :每次扩容5个 
     * 1、检查容量是否足够 
     * 2、不够扩容 Arrays.copyOf(数组,长度)
     */
    public void larger() {
        int len = elementData.length;

        if (size < len) {
            return;
        }
        // 不够扩容 Arrays.copyOf(数组,长度)
        elementData = Arrays.copyOf(elementData, len + 5);
    }

    /**
     * 获取实际大小方法
     */

    public int size() {
        return this.size;
    }

    /**
     * 判断容器是否为空
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * 获取指定索引的元素 
     * 1、检查索引是否有效 (index 在 0- size-1内) 
     * 2、有效,从数组中获取元素
     * 
     */
    public String get(int index) {
        if (index > size - 1 || index < 0 || size == 0) {
            throw new ArrayIndexOutOfBoundsException("索引无效,不在范围内");
        }
        return this.elementData[index];
    }

    /**
     * 新增元素 添加到最后一个 
     * 1、检查容量是否足够 +扩容 
     * 2、存放到最后一个数组的有效(实际大小)位置 
     * 3、实际大小 size+1
     * 
     * @param elem
     *            待存放元素
     */

    public boolean add(String element) {
        larger();
        elementData[size++] = element;
        return true;
    }

    /**
     * 指定位置存放元素 (插入元素) 
     * 1、索引是否有效 
     * 2、扩容 
     * 3、插入元素 1 x a b c d 
     * a b b c d 
     * a x b c d
     * 4、size +1
     * 
     * @param index
     *            指定位置
     * @param elem
     *            待存放元素
     */

    public void add(int index, String element) {

        // 1、索引是否有效
        // 可以等于size 相当于添加到最后一个位置
        if (index < 0 || index > size) {
            // return null;
            throw new ArrayIndexOutOfBoundsException("索引无效,不在范围内");
        }

        // 2、扩容
        larger();
        // 3、插入元素
        System.arraycopy(this.elementData, index, this.elementData, index + 1,
                this.size - index);
        // 覆盖元素
        this.elementData[index] = element;
        // 4、size +1
        this.size++;
    }

    /**
     * 删除元素 根据索引删除指定位置的元素
     *  1、索引是否有效
     *   2、删除即可:指定位置拷贝数组,丢弃最后一个 
     *   3、this.size -1
     */
    public void remove(int index) {
        get(index);// 原来的值 ,存在即有效
        // 2、删除即可:指定位置拷贝数组,丢弃最后一个
        System.arraycopy(this.elementData, index + 1, this.elementData, index,
                this.size - (index + 1));
        /**
         * 丢弃最后一个 this.elementData[this.size-1] =null; 3、缩小实际大小 this.size--;
         */

        elementData[--size] = null;
    }

    /**
     * 删除元素:根据元素本身删除 涉及对象的比较,删除一次即可 
     * 1、根据 删除对象 找到索引 
     * 2、根据索引删除即可
     */
    public void remove(String elem) {
        int idx = -1;
        if (null == elem) { // 删除null
            for (int i = 0; i < size; i++) {
                if (elem == this.elementData[i]) {
                    idx = i; // 找到删除
                    break;
                }
            }
        } else { // 根据内容删除
            for (int i = 0; i < size; i++) {
                if (elem.equals(this.elementData[i])) {
                    idx = i; // 找到删除
                    break;
                }
            }
        }

        if (idx >= 0) { // 找到删除
            this.remove(idx);
        }

    }

    /**
     * 删除元素:根据元素本身删除 涉及对象的比较,删除所有
     */
    public void removeAll(String element) {
        if (null == element) {
            for (int i = 0; i < size; i++) {
                if (element == this.elementData[i]) {
                    remove(i); // 找到删除
                    i--;
                }
            }
        } else {
            for (int i = 0; i < size; i++) {
                if (element.equals(this.elementData[i])) {
                    remove(i); // 找到删除
                    i--;
                }
            }
        }
    }

    // 匿名内部类
    public Iterator iterator() {
        
        return new Iterator() {

            private int coursor = -1;

            // 加入自己迭代器 判断 指针 是否 在size内
            // 只是判断,不会移动

            public boolean hasNext() {
                return coursor < size - 1;
            }

            // 移动指针 +获取值
            public String next() {
                if (!hasNext()) {
                    throw new ArrayIndexOutOfBoundsException("索引无效,不在范围内");
                }
                coursor++; // 移动指针
                return elementData[coursor];
            }

            @Override
            public void remove() {
                if (!hasNext()) {
                    throw new ArrayIndexOutOfBoundsException("索引无效,不在范围内");
                }
                coursor++; // 移动指针
                MyArrayList.this.remove(coursor);
                coursor--;

            }

        };
    }

    
    /*    
    private int coursor =-1;
    
    // 加入自己迭代器 判断 指针 是否 在size内
     // 只是判断,不会移动
     
     public boolean hasNext(){         
         return coursor<this.size-1;
     }
       //移动指针 +获取值
     public String next(){
         if(!hasNext()){
             throw new ArrayIndexOutOfBoundsException("索引无效,不在范围内");
         }
         coursor++; //移动指针
         return this.elementData[coursor];
     }
    */
    /*
    //封装成内部类
    public class MyIter{
        private int coursor =-1;
        
        // 加入自己迭代器 判断 指针 是否 在size内
         // 只是判断,不会移动
         
         public boolean hasNext(){         
             return coursor<size-1;
         }
           //移动指针 +获取值
         public String next(){
             if(!hasNext()){
                 throw new ArrayIndexOutOfBoundsException("索引无效,不在范围内");
             }
             coursor++; //移动指针
             return elementData[coursor];
         }
    }
    
    public MyIter iterator(){
        return new MyIter();
    }
    
    */    
    
}

 

 测试程序如下:

package com.jaky.Collection;

import java.util.Iterator;

public class ArrayListApp {
    public static void main(String[] args) {
        MyArrayList list = new MyArrayList();
        list.add(null);
        list.add("c");
        list.add("c");
        list.add("null");//存放自己为null占位
list.add(
"a"); // 遍历: 第一种 for +get System.out.println("===第一种 for +get======="); // 查看所有的元素 for (int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } // 第二种迭代器 System.out.println("===第二种迭代器======="); // MyArrayList.MyIter it =list.new MyIter(); Iterator it = list.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }

 

posted on 2013-09-05 12:28  jakyforever  阅读(323)  评论(0编辑  收藏  举报