自己实现Arraylsit,实现其常用的几种增、删、该、查的方法

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

/**
 * 自己实现arraylist
 * 添加 add(E e) add(int index,E e)
 * 获取 get(int index)
 * 删除 remove(int index)  remove(object o)
 * 替换 set(int index)
 * 长度 getSize()
 * @author cuiyc
 * @version 1.0
 * @date 2021/6/5 09:15
 */
public class ArrayListDemo2<E> {
    /**
     * list的长度
     */
    private int size;
 
    private Object[] elemendData;
    /**
     * list的默认的长度为10
     */
    private static final int DEFAULT_CAPACITY=10;
 
    /**
     * 默认容量的object类型的数组
     */
    private static final Object[] DEFAULT_CAPACITY_ELEMENTDATA={};
 
    /**
     * 空参构造函数
     */
    public ArrayListDemo2(){
        this.elemendData=DEFAULT_CAPACITY_ELEMENTDATA;
    }
 
    /**
     * 带初始长度的构造函数
     * @param capacity
     */
    public ArrayListDemo2(int capacity){
        this.elemendData=new Object[capacity];
    }
 
    /**
     * 添加元素
     * @param e 要添加的元素
     * @return 处理结果
     */
    public Boolean add(E e){
        //1 需要确保数组的容量
        ensureListCapacity(size+1);
        //2 添加元素到list中
        elemendData[size++]=e;
        return true;
    }
 
    /**
     * 在list的某个位置上添加元素
     * @param index list的数组的位置
     * @param e 要添加的元素
     */
    public void add(int index,E e){
        //1 确保数组的容量
        ensureListCapacity(size+1);
        //2 数据的拷贝
        System.arraycopy(elemendData,index,elemendData,index+1,size-index);
        //3 数组元素的添加
        elemendData[index]=e;
        //4 数组size的+1
        size++;
    }
 
    /**
     * 获取某个位置上的元素
     * @param index list上的数组的位置
     * @return 获取到的元素
     */
    private E getValue(int index){
        return (E) elemendData[index];
    }
 
    /**
     * 移除list中某个位置的元素
     * @param index list的某个位置
     */
    private E remove(int index){
         List<String> list=new ArrayList<>();
        E oldValue= getValue(index);
        int numMoved=size-index-1;
        if(numMoved>0){
            System.arraycopy(elemendData,index+1,elemendData,index,numMoved);
        }
        elemendData[--size]=null;
        return oldValue;
    }
 
    /**
     * 移除list中的某个元素，传入的参数是object，数组中存的值
     * @param o
     */
    private Boolean remove(Object o){
        if(o==null){
            //如果o是空，怎么处理
            for (int i = 0; i < size; i++) {
                if(getValue(i)==null){
                    fastRemove(i);
                    return true;
                }
            }
        }else {
            //如果o不是空，怎么处理
            for (int i = 0; i < size; i++) {
                if(o.equals(getValue(i))){
                    fastRemove(i);
                    return true;
                }
            }
        }
        return false;
    }
 
    /**
     * 在某个位置赋值新的值
     * @param index list的数组的位置
     * @param e 新的值
     */
    public void setNewValue(int index,E e){
        elemendData[index]=e;
    }
 
    private int getSize(){
        return elemendData.length;
    }
 
    /**
     * 快速删除元素
     * @param index
     */
    public void fastRemove(int index){
        int numMoved=size-index-1;
        if(numMoved>0){
            System.arraycopy(elemendData,index+1,elemendData,index,numMoved);
        }
        elemendData[--size]=null;
    }
 
 
    /**
     * 确保list的数组的容量可以容纳新增的元素
     * @param miniCapacity 添加新的元素后，list的数组的长度
     */
    public void ensureListCapacity(int miniCapacity){
        //1 先对数组的长度进行逻辑上的一些判断 得到目前需要定义的一个list数组的长度
        int nowCapacity=caculateCapacity(elemendData,miniCapacity);
        //2 如果新添加元素后，数组的长度大于目前数组定义的一个长度，则需要扩容
        if(nowCapacity-elemendData.length>0){
            grow(nowCapacity);
        }
    }
 
    /**
     * 计算目前的list的数组的定义的长度。1 如果是第一次初始化list，则有可能是默认的10，也有可能是初始化的时候有定义数组长度。
     *                              2 如果不是第一次初始化list，则直接返回的是目前数组的实际长度+1的值。
     * @param elemendData
     * @param miniCapacity
     * @return
     */
    public int caculateCapacity(Object[] elemendData,int miniCapacity){
        if(elemendData==DEFAULT_CAPACITY_ELEMENTDATA){
            return Math.max(DEFAULT_CAPACITY,miniCapacity);
        }
        return miniCapacity;
    }
 
    /**
     * 扩容的机制
     * @param nowCapacity 目前数组的实际的最大的长度
     */
    public void grow(int nowCapacity){
        //目前list的数组的定义的一个容量大小
        int oldGuiDing_Capacity=elemendData.length;
        //扩容为1.5倍后的容量大小
        int newGuiDing_Capacity=oldGuiDing_Capacity+(oldGuiDing_Capacity>>1);
 
        //比较，扩容后的容量大小是否是比实际数组的最大长度还小，如果还小，则将实际的数组的最大长度赋值给需要扩容的容量
        if(newGuiDing_Capacity-nowCapacity<0){
            newGuiDing_Capacity=nowCapacity;
        }
 
        //数据拷贝，产生一个新的数组，将旧的数组的数据拷贝到新的数组中去
        Arrays.copyOf(elemendData,newGuiDing_Capacity);
    }
}