重写list接口

重写list接口

1.接口

package com.toplab.task2.mylist;
public interface MyList {
    /**
     * 获取 list 第 index 个元素
     * @param index 下标
     * @return 第 index 个元素
     */
    Object get(int index);

    /**
     * 设置 list 第 index 个元素为 element
     * @param index 下标
     * @param element 元素
     * @return 第 index 个元素
     */
    Object set(int index, Object element);

    /**
     * 获取 list 中是否包含某个元素o
     * @param o 元素
     * @return 是否包含某个元素o
     */
    boolean contains(Object o);

    /**
     * 获取 list 是否包含数组c的所有元素
     * @param c 数组
     * @return list 是否包含数组c的所有元素
     */
    boolean containsAll(Object[] c);

    /**
     * 获取 list 的元素个数
     * @return list 的元素个数
     */
    int size();

    /**
     * 获取一个元素和 list 一样的数组
     * @return 一个元素和 list 一样的数组
     */
    Object[] toArray();

    /**
     * 获取 list 是否为空(true)
     * @return list 是否为空
     */
    boolean isEmpty();

    /**
     * 向 list 中添加一个元素
     * @param e 元素
     * @return 成功返回 true 思考一下，为什么这里要boolean值？
     */
    boolean add(Object e);

    /**
     * 将 e 中所有元素添加到 list 中
     * @param e 数组
     * @return 成功返回 true
     */
    boolean addAll(Object[] e);

    /**
     * 从 list 中删除第一个和  e 相等的元素
     * @param e 元素    boolean remove(Object e);
     * @return list是否发生改变
     */
    boolean remove(Object e);
    /**
     * 从 list 中删除所有与数组 e 中的元素相同的元素
     * @param e 元素
     * @return list是否发生改变
     */
    boolean removeAll(Object[] e);

    void clear();

    /**
     * 获取 o 在 list 中第一次出现的下标，下标从零开始
     * @param o 元素
     * @return o 在 list 中第一次出现的下标
     */
    int indexOf(Object o);

    /**
     * 获取 o 在 list 中最后一次出现的下标
     * @param o 元素
     * @return o 在 list 中最后一次出现的下标
     */
    int lastIndexOf(Object o);
    /**
     * 返回当前 list 与 o 是否完全相等
     * @param o 元素
     * @return 当前 list 与 o 是否完全相等
     */
    @Override
    boolean equals(Object o);

    /**
     * 返回 list 中每一个元素组成的字符串
     * 如 list 中有3个整数1， 2， 3，那么返回如下
     *  [1, 2, 3]
     * @return list 中每一个元素组成的字符串
     */
    @Override
    String toString();

}

2.实现类

package com.toplab.task2.mylist.impl;

import com.toplab.task2.mylist.MyList;

public class listImpl implements MyList {
    private Object[] elements;
    private int size;
    public listImpl(){
        elements=new Object[1000];
        size=0;
    }
    @Override
    public Object get(int index) {
        return elements[index];//返回当前元素
    }

    @Override
    public Object set(int index, Object element) {
        Object firstElement=elements[index];
        elements[index]=element;//修改当前索引元素
        return firstElement;//返回没设置之前的
    }

    @Override
    public boolean contains(Object o) {
        for(int i=0;i<size;i++){
            if(elements[i].equals(o)){
                return true;//寻找是否包含
            }
        }
        return false;
    }

    @Override
    public boolean containsAll(Object[] c) {
        for(Object o:c){
            //加强for循环来遍历
            if(!contains(o)){
                return false;//调用了前一个方法，只要有一个不包含就false
            }
        }
        return true;
    }

    @Override
    public int size() {
        return size;
    }

    @Override
    public Object[] toArray() {
        Object[] result=new Object[size];
        for(int i=0;i<size;i++){
            result[i]=elements[i];
        }
        //返回一个一样的数组
        return result;
    }

    @Override
    public boolean isEmpty() {
        return size==0;//等于0则为true
    }

    @Override
    public boolean add(Object e) {
        elements[size++]=e;
        return true;
    }
    @Override
    public boolean addAll(Object[] e) {
        int length=e.length;
        System.arraycopy(e,0,elements,size,length);
        size+=length;
        return true;
    }

    @Override
    public boolean remove(Object e) {
        for(int i=0;i<size;i++){
            if(elements[i].equals(e)){
                System.arraycopy(elements,i+1,elements,i,size-i-1);
                //数据数组+起始索引+目的数组+起始索引+拷贝长度
                size--;
                return true;
            }
        }
        return false;
    }
   
    @Override
    public boolean removeAll(Object[] e) {
        boolean flag=false;
        for(Object o:e){
            if(remove(o)){
                //调用上一个方法
                flag=true;
            }
        }
        return flag;
    }

    @Override
    public void clear() {
        elements=new Object[1000];
        size=0;
    }

    @Override
    public int indexOf(Object o) {
        //返回下标
        for(int i=0;i<size;i++){
            if(elements[i].equals(o)){
                return i;
            }
        }
        return -1;
    }

    @Override
    public int lastIndexOf(Object o) {
        for(int i=size-1;i>=0;i--){
            if(elements[i].equals(o)){
                return i;
            }
        }
        return -1;
    }
    //equals函数不是很清楚
    public boolean equals(Object o){
        if(this==o) return true;
        //两个对象的运行时类不相等
        if(o==null||getClass()!=o.getClass()) return false;
        listImpl myList=(listImpl) o;
        for(int i=0;i<size;i++){
            if(!elements[i].equals(myList.elements[i])) return false;
        }
        return true;
    }
    public String toString(){
        //按照要求写toString
        StringBuilder str=new StringBuilder("[");
        for(int i=0;i<size;i++){
            str.append(elements[i]);
            if(i<size-1) str.append(",");
        }
        str.append("]");
        return str.toString();
    }
}

3.测试类

package com.toplab.task2;

import com.toplab.task2.mylist.MyList;
import com.toplab.task2.mylist.impl.listImpl;

import java.util.Collection;
import java.util.List;

/**
 * @Author: Medivh
 * @Date: 2023/11/11 18:01
 * @Description:
 */
public class TestList {
    public static void main(String[] args) {
        //先创建一个list
        MyList list = new listImpl();
    //测试类开始调用MyList的实现类的重写的所有方法
    //add方法
        list.add("屠算法");
        list.add("斩软开");
        list.add("多沉淀");
        list.add("少抱怨");
        System.out.println(list.add("成大佬"));
    //get方法
        System.out.println("Get index 4: " + list.get(4));
    //set方法
        System.out.println("Set index 4: " + list.set(4, "进大厂"));
        System.out.println("Get index 4: " + list.get(4));
    //contains方法
        System.out.println("Contains All-killed " + list.contains("All-killed"));
    //containsAll方法
        String[] test = new String[]{"梦入江南烟水路", "寻尽江南", "不与离人遇"};
        System.out.println("ContainsAll: " + list.containsAll(test));
    //size方法
        System.out.println("Size: " + list.size());
    //toArray方法
        Object[] tempArray = list.toArray();
        System.out.println("After to array");
    //使用加强for循环
        for (Object go : tempArray) {
            System.out.println(go);
        }
    //isEmpty方法
        System.out.println("isEmpty: "+list.isEmpty());
    //addAll方法
        System.out.println("After addAll");
        list.addAll(test);
        for(int i=0;i< list.size();i++){
            System.out.println(list.get(i));
        }
    //remove方法
        list.remove("不与离人遇");
        System.out.println("After remove: ");
        for(int i=0;i< list.size();i++){
            System.out.println(list.get(i));
        }
        //removeAll方法
        list.removeAll(test);
        System.out.println("After removeAll: ");
        for(int i=0;i< list.size();i++){
            System.out.println(list.get(i));
        }
    //indexOf方法和lastIndexOf方法
        list.add("多沉淀");
        System.out.println("After indexOf and last IndexOf");
        System.out.println(list.indexOf("多沉淀")+" "+list.lastIndexOf("多沉淀"));
    //equals方法
        System.out.println(list.get(2).equals(list.get(5)));
    //toString方法
        System.out.println(list.toString());
    //clear方法
        list.clear();
        System.out.println("After clear: "+list.size());
    }
}

欢迎批评指正！