java中顺序表以及栈的泛型类源码(ArrayList,Stack)

顺序表源码

首先这里相对于一下链接的多个一个泛型的用法，所谓泛型就是我的表里面可以放整数，放小数，放字符，放各种类型。如不想用到泛型可以点到主页找到整数顺序表。

下面是加了泛型的代码：

import java.util.Arrays;
public class MyarryList<E> {
    private Object[] arrys;
    private int usesize;
    //构造方法初始化顺序表
    public MyarryList(){
        this.arrys = new Object[10];
        this.usesize = 0;
    }
    //获取顺序表长度
    public int size(){
        return this.usesize;
    }
    //打印顺序表
    public void display(){
        System.out.println("表中有数据"+usesize+"个");
        for (int i = 0; i < this.usesize; i++) {
            System.out.print(arrys[i]+" ");
        }
    }
    //默认在表中尾部增加数据
    public  void add(E data){
        if(isfull()) {
            addcopy();
            arrys[usesize] = data;
            usesize ++;
        } else {
            arrys[usesize] = data;
            usesize ++;
        }

    }
    //在指定下标添加元素
    public void add(E data,int i){
        if(isfull()) {
            addcopy();
            isright(i);
            for (int j = usesize-1; j > 0; j--) {
                arrys[j+1] = arrys[j];
            }
            arrys[i] = data;
            usesize++;
        } else {
            isright(i);
            for (int j = usesize-1; j >= 0; j--) {
                arrys[j+1] = arrys[j];
            }
            arrys[i] = data;
            usesize++;
        }

    }
    //判断表中是否包含某个元素
    public boolean contains(E data){
        for (int i = 0; i < this.usesize; i++) {
            if(arrys[i].equals(data)){
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    public int indexOf(E data) {
        if(contains(data)){
            for (int i = 0; i <this.usesize ; i++) {
                if(arrys[i].equals(data)){
                    return i;
                }
            }
            return -1;
        } else {
            return -1;
        }
    }
    //查找某个下标的元素
    public E get(int i){
        if(isright(i)){
            return (E)arrys[i];
        } else {
            return (E)arrys[-1];
        }
    }
    //删除某个元素
    public void remove(E data){
        int i = indexOf(data);
        for (int j = i; j < usesize-1 ; j++) {
            arrys[j] = arrys[j+1];
        }
        usesize--;
    }
    //设置某个位置的值
    public void set(int i,E data){
        isright(i);
        arrys[i] = data;
    }
    //清空数据表
    public  void claer(){
        usesize = 0;
    }
    //判断表中数据是否装满
    public boolean isfull(){
        if(this.usesize == arrys.length){
            return true;
        } else {
            return false;
        }
    }
    //顺序表中长度不够是需要扩容
    public void addcopy(){
        //扩容长度为原来的两倍，可自己决定
        arrys = Arrays.copyOf(arrys,usesize * 2);
    }
    //检查下标是否合法
    public boolean isright(int i){
        if(i < 0 || i >= this.usesize){
            throw new WrongadressException("你给的下标有问题");
        } else {
            return true;
        }
    }

}

public class WrongadressException extends RuntimeException{
    //两个构造方法，一个无参构造，一个提示错在哪里
    public WrongadressException(){
    }
    public WrongadressException(String wrong){
        super(wrong);
    }
}

栈的源码

相对顺序表的源码，栈的操作要少很多，毕竟只针对栈顶进行读取弹出。

import java.util.Arrays;

public class InnList<E> {
    public int Top;
    Object[] arry;
    public InnList(){
        arry = new Object[10];
        Top = -1;
    }
    //查看当前栈中元素
    public int number(){

        return (Top+1);
    }
    //弹出栈顶元素
    public void pop(){
        if(Top >= 0){
            Top--;
        }else {
            throw new NoeruntimeException("栈中已无元素");
        }
    }
    //清空栈
    public void clear(){
        Top = -1;
    }
    //查看栈顶元素但不删除
    public E peek(){
        if(Top < 0){
            throw new NoeruntimeException("栈中已无元素");
        }
        return (E)arry[Top];
    }
    //添加元素
    public void push(E data){
        //首先检查是否栈满
        if(isfull()){
            //如果栈满则进行扩容
            addfull();
            arry[Top+1] = data;
            Top++;
        }else {
            arry[Top+1] = data;
            Top++;
        }
    }
    //检查是否栈满
    public  boolean isfull(){
        if(Top == arry.length-1){
            return true;
        } else {
            return false;
        }
    }
    //对栈内进行二倍扩容
    public void addfull(){
        arry = Arrays.copyOf(arry,Top*2);
    }
}

public class NoeruntimeException extends RuntimeException{
    public NoeruntimeException(){

    }
    //提示错在哪里
    public NoeruntimeException(String s){
        super(s);
    }
}