java整数类和自然数类的简单实现

java整数类和自然数类的简单实现

只是简单实现了构造方法、加法减法、输出和比较的方法。
代码有很多地方重复，比较乱，初学者水平。
为了实现多位计算，对数字是用数组列表记录每一位。

private int length;			//记录数字的长度
private ArrayList<Integer> numbers;		//记录数字的每一位

import java.util.ArrayList;

public class MyNumber {
    public static void main(String[] args) {
        //成员方法的测试
        MyNaturalNumbers naturalNumber1 = new MyNaturalNumbers("1000000000000000000000");
        System.out.print("自然数1长度:" + naturalNumber1.getLength() + " " + "自然数1:");
        naturalNumber1.outputNumber();

        MyNaturalNumbers naturalNumber2 = new MyNaturalNumbers("2222222222222222222222");
        System.out.print("自然数2长度:" + naturalNumber2.getLength() + " " + "自然数2:");
        naturalNumber2.outputNumber();

        MyNaturalNumbers naturalNumber3 = new MyNaturalNumbers("1111111111111111111199");
        System.out.print("自然数3数字长度:" + naturalNumber3.getLength() + " " + "自然数3:");
        naturalNumber3.outputNumber();

        System.out.println("判断自然数1和2的大小(1前者大，0相等，-1后者大):" + naturalNumber1.equals(naturalNumber2));

        System.out.print("自然数1加上自然数2后的结果:");
        naturalNumber1.add(naturalNumber2);
        naturalNumber1.outputNumber();

        System.out.print("自然数2减去自然数3后的结果:");
        naturalNumber2.reduce(naturalNumber3);
        naturalNumber2.outputNumber();

        MyInteger myInteger1 = new MyInteger("10000000000123456789");
        System.out.print("整数1长度:" + myInteger1.getLength() + " " + "整数1:");
        myInteger1.outputNumber();

        MyInteger myInteger2 = new MyInteger("-22223333444455556666");
        System.out.print("整数2长度:" + myInteger2.getLength() + " " + "整数2:");
        myInteger2.outputNumber();

        MyInteger myInteger3 = new MyInteger("-66666666666666666666");
        System.out.print("整数3长度:" + myInteger3.getLength() + " " + "整数3:");
        myInteger3.outputNumber();

        System.out.print("整数1减去整数2后的结果:");
        myInteger1.reduce(myInteger2);
        myInteger1.outputNumber();


        System.out.println("判断自然数1和整数1的大小(1前者大，0相等，-1后者大):" + naturalNumber1.equals(myInteger1));
        System.out.println("判断整数1和整数2大小(1前者大，0相等，-1后者大):" + myInteger1.equals(myInteger2));
        System.out.println("判断整数1和自然数1大小(1前者大，0相等，-1后者大):" + myInteger1.equals(naturalNumber1));

        System.out.println("把整数3转化会字符串格式化："+myInteger3.toString());
    }
}

class Number {
    private int length;//数字的长度
    private ArrayList<Integer> numbers;//记录数字的每一位

    public int getLength() {
        return this.length;
    }

    public ArrayList<Integer> getNumbers() {
        return numbers;
    }
}

class MyInteger extends Number {

    private int length;//数字的长度
    private ArrayList<Integer> numbers;//记录数字的每一位

    public void setLength(int length) {
        this.length = length;
    }

    public void setNumbers(ArrayList<Integer> numbers) {
        this.numbers = numbers;
    }

    public int getLength() {
        return this.length;
    }

    public ArrayList<Integer> getNumbers() {
        return numbers;
    }

    //构造方法
    public MyInteger() {
        this.length = 0;
        this.numbers = new ArrayList<>();
    }

    public MyInteger(String number) {
        numbers = new ArrayList<>();
        if (number.length() == 1 && number.equals(0)) {
            this.length = 0;
            this.numbers.add(0);
        } else {
            int i = 0;
            for (int j = number.length() - 1; j >= 0; j--) {
                if (number.charAt(j) == '-') {
                    this.numbers.add(Integer.valueOf(number.charAt(0)));
                    i++;
                } else if (number.charAt(j) != ',')
                    this.numbers.add(Integer.valueOf(number.charAt(j)) - 48);
                else
                    i++;
            }
            this.length = number.length() - i;
        }
    }

    public MyInteger(MyNaturalNumbers myNaturalNumbers) {
        this.length = myNaturalNumbers.getLength();
        this.numbers = myNaturalNumbers.getNumbers();
    }

    //输出数字
    public void outputNumber() {
        for (int i = numbers.size() - 1; i >= 0; i--) {
            if (numbers.get(i) == 45)
                System.out.print('-');
            else
                System.out.print(numbers.get(i));
        }
        System.out.println();
    }

    //数字相加方法
    public void add(MyInteger myInteger) {
        //加的数为0
        if (myInteger.length == 0) {
            return;
        }
        //暂时存放结果
        ArrayList<Integer> resultNumber = new ArrayList<>();

        int longLength = this.length > myInteger.length ? this.length : myInteger.length;
        int shortLength = this.length < myInteger.length ? this.length : myInteger.length;
        int val1;
        int val2;
        int carry = 0;
        int borrowCur = 0;
        int borrowNext;
        int temp1;
        int temp2;


        //减数和被减数的正负符号
        int minuendSign = this.numbers.get(this.numbers.size() - 1) == '-' ? -1 : 1;
        int subtractionSign = myInteger.numbers.get(myInteger.numbers.size() - 1) == '-' ? -1 : 1;
        //异号相加的情况
        //绝对值大小比较
        int compareAbs = this.equalsAbs(myInteger);
        if (minuendSign * subtractionSign < 0) {
            if (compareAbs == 0) {
                resultNumber.add(0);
                this.length = 0;
                this.numbers = resultNumber;
                return;
            }
            for (int i = 0; i < longLength; i++) {
                if (i < shortLength) {
                    val1 = this.numbers.get(i);
                    val2 = myInteger.numbers.get(i);
                } else if (i >= shortLength && i < longLength) {
                    if (compareAbs == 1) {
                        val1 = this.numbers.get(i);
                        val2 = 0;
                    } else {
                        val2 = myInteger.numbers.get(i);
                        val1 = 0;
                    }

                } else {
                    val1 = 0;
                    val2 = 0;
                }

                //前者绝对值大，相减为正数
                if (compareAbs == 1) {
                    borrowNext = val1 - val2 - borrowCur >= 0 ? 0 : 1;
                    temp1 = val1 - borrowCur - val2 + borrowNext * 10;
                    borrowCur = borrowNext;
                    resultNumber.add(temp1);
                }
                //后者绝对值大，相减为负数
                if (compareAbs == -1) {
                    borrowNext = val2 - val1 - borrowCur >= 0 ? 0 : 1;
                    temp1 = val2 - borrowCur - val1 + borrowNext * 10;
                    borrowCur = borrowNext;
                    resultNumber.add(temp1);
                }
            }
            //去除高位0
            int indexZero = resultNumber.size() - 1;
            while (resultNumber.get(indexZero) == 0) {
                resultNumber.remove(resultNumber.size() - 1);
                indexZero--;
            }
            //为负则放入负号,结果赋值
            if ((compareAbs == -1 && minuendSign == 1) || (compareAbs == 1 && minuendSign == -1)) {
                resultNumber.add(45);
                this.length = resultNumber.size() - 1;
            } else {
                this.length = resultNumber.size();
            }
            this.numbers = resultNumber;
        }

        //同号相加的情况
        if (minuendSign * subtractionSign > 0) {
            for (int i = 0; (i < longLength) || carry != 0; i++) {
                if (i < shortLength) {
                    val1 = this.numbers.get(i);
                    val2 = myInteger.numbers.get(i);
                } else if (i >= shortLength && i < longLength) {
                    if (this.length > myInteger.length) {
                        val1 = this.numbers.get(i);
                    } else {
                        val1 = myInteger.numbers.get(i);
                    }
                    val2 = 0;
                } else {
                    val1 = 0;
                    val2 = 0;
                }
                temp2 = val1 + val2 + carry;
                carry = temp2 / 10;
                resultNumber.add(temp2 % 10);
            }

            if (minuendSign == 1)
                this.length = resultNumber.size();
            else {
                resultNumber.add(45);
                this.length = resultNumber.size() - 1;
            }
            this.numbers = resultNumber;
        }
    }


    //数字相减方法
    public void reduce(MyInteger myInteger) {
        MyInteger temp = new MyInteger();
        temp.length = myInteger.length;
        temp.numbers = myInteger.numbers;
        if (myInteger.numbers.get(myInteger.numbers.size() - 1) == '-') {
            temp.numbers.remove(myInteger.numbers.size() - 1);
        } else {
            temp.numbers.add(45);
        }
        this.add(temp);
    }

    //字符串格式化
    public String toString() {
        String number = "";
        for (int i = this.numbers.size() - 1; i >= 0; i--) {
            if (this.numbers.get(i) == 45)
                number = number + '-';
            else
                number = number + this.numbers.get(i);
        }
        return number;
    }

    //比较两个整数的大小
    public int equals(MyInteger myInteger) {
        int myInteger2Size = myInteger.getNumbers().size();
        int myInteger1Size = this.numbers.size();
        if (myInteger.getNumbers().get(myInteger2Size - 1) == '-' && this.numbers.get(myInteger1Size - 1) != '-')
            return 1;
        else if (myInteger.getNumbers().get(myInteger2Size - 1) == '-' && this.numbers.get(myInteger1Size - 1) != '-')
            return -1;
        else if (myInteger.getNumbers().get(myInteger2Size - 1) != '-' && this.numbers.get(myInteger1Size - 1) != '-') {
            if (this.length > myInteger.getLength())
                return 1;
            else if (this.length < myInteger.getLength())
                return -1;
            else {
                for (int i = this.length - 1; i >= 0; i--) {
                    if (this.numbers.get(i) > myInteger.getNumbers().get(i))
                        return 1;
                    else if (this.numbers.get(i) < myInteger.getNumbers().get(i))
                        return -1;
                    else
                        continue;
                }
            }
            return 0;
        } else {
            if (this.length > myInteger.getLength())
                return -1;
            else if (this.length < myInteger.getLength())
                return 1;
            else {
                for (int i = this.length - 1; i >= 0; i--) {
                    if (this.numbers.get(i) > myInteger.getNumbers().get(i))
                        return -1;
                    else if (this.numbers.get(i) < myInteger.getNumbers().get(i))
                        return 1;
                    else
                        continue;
                }
            }
            return 0;
        }
    }

    //比较两个整数绝对值的大小
    public int equalsAbs(MyInteger myInteger) {
        if (this.length > myInteger.length)
            return 1;
        else if (this.length < myInteger.length)
            return -1;
        else {
            for (int i = this.length - 1; i >= 0; i--) {
                if (this.numbers.get(i) > myInteger.numbers.get(i))
                    return 1;
                else if (this.numbers.get(i) < myInteger.numbers.get(i))
                    return -1;
                else
                    continue;
            }
        }
        return 0;
    }

    //比较一个整数和一个自然数的大小
    public int equals(MyNaturalNumbers myNaturalNumbers) {
        int myIntegerSize = this.numbers.size();
        if (this.numbers.get(myIntegerSize - 1) == '-')
            return -1;
        else if (this.length > myNaturalNumbers.getLength())
            return 1;
        else if (this.length < myNaturalNumbers.getLength())
            return -1;
        else {
            for (int i = this.length - 1; i >= 0; i--) {
                if (this.numbers.get(i) > myNaturalNumbers.getNumbers().get(i))
                    return 1;
                else if (this.numbers.get(i) < myNaturalNumbers.getNumbers().get(i))
                    return -1;
                else
                    continue;
            }
        }
        return 0;
    }
}

class MyNaturalNumbers extends Number {
    public void setLength(int length) {
        this.length = length;
    }

    public int getLength() {
        return this.length;
    }

    public ArrayList<Integer> getNumbers() {
        return numbers;
    }

    public void setNumbers(ArrayList<Integer> numbers) {
        this.numbers = numbers;
    }

    private int length;//数字的长度
    private ArrayList<Integer> numbers;//记录数字的每一位

    //构造方法
    public MyNaturalNumbers() {
        this.length = 0;
        this.numbers = new ArrayList<>();
    }

    public MyNaturalNumbers(String number) {
        numbers = new ArrayList<>();

        //为负数提示错误
        if (number.charAt(0) == '-') {
            System.out.println("自然数不能为负");
            this.length = -1;
        }
        //为0
        else if (number.length() == 1 && number.equals(0)) {
            this.length = 0;
            this.numbers.add(0);
        } else {
            //为正整数
            int i = 0;
            for (int j = number.length() - 1; j >= 0; j--) {
                if (number.charAt(j) != ',')
                    this.numbers.add(Integer.valueOf(number.charAt(j)) - 48);
                else
                    i++;
            }
            this.length = number.length() - i;
        }
    }

    //输出数字
    public void outputNumber() {
        for (int i = numbers.size() - 1; i >= 0; i--) {
            System.out.print(numbers.get(i));
        }
        System.out.println();
    }

    //数字相加方法
    public void add(MyNaturalNumbers myNaturalNumbers) {
        MyNaturalNumbers res = new MyNaturalNumbers();
        int val1;
        int val2;
        int temp;
        int carry = 0;
        int maxLength = this.length > myNaturalNumbers.length ? this.length : myNaturalNumbers.length;
        int minLength = this.length < myNaturalNumbers.length ? this.length : myNaturalNumbers.length;
        for (int i = 0; (i < maxLength) || carry != 0; i++) {
            if (i < minLength) {
                val1 = this.numbers.get(i);
                val2 = myNaturalNumbers.numbers.get(i);
            } else if (i >= minLength && i < maxLength) {
                if (this.length > myNaturalNumbers.length) {
                    val1 = this.numbers.get(i);
                } else {
                    val1 = myNaturalNumbers.numbers.get(i);
                }
                val2 = 0;
            } else {
                val1 = 0;
                val2 = 0;
            }
            temp = val1 + val2 + carry;
            carry = temp / 10;
            res.numbers.add(temp % 10);
        }
        res.length = res.numbers.size();
        this.numbers = res.numbers;
        this.length = res.length;
    }

    //数字相减方法
    public MyInteger reduce(MyNaturalNumbers myNaturalNumbers) {
        MyInteger res = new MyInteger();
        int val1;
        int val2;
        int borrowCur = 0;
        int borrowNext;
        int temp;
        int compare = this.equals(myNaturalNumbers);
        ArrayList<Integer> resultNumber = new ArrayList<>();
        int maxLength = this.length > myNaturalNumbers.length ? this.length : myNaturalNumbers.length;
        int minLength = this.length < myNaturalNumbers.length ? this.length : myNaturalNumbers.length;
        //两数相等，相减为0
        if (compare == 0) {
            resultNumber.add(0);
            res.setLength(0);
            res.setNumbers(resultNumber);
            this.length = res.getLength();
            this.numbers = res.getNumbers();
            return res;
        }
        for (int i = 0; i < maxLength; i++) {

            if (i < minLength) {
                val1 = this.numbers.get(i);
                val2 = myNaturalNumbers.numbers.get(i);
            } else if (i >= minLength && i < maxLength) {
                if (compare == 1) {
                    val1 = this.numbers.get(i);
                    val2 = 0;
                } else {
                    val2 = myNaturalNumbers.numbers.get(i);
                    val1 = 0;
                }

            } else {
                val1 = 0;
                val2 = 0;
            }

            //前者大，相减为正数
            if (compare == 1) {
                borrowNext = val1 - val2 - borrowCur >= 0 ? 0 : 1;
                temp = val1 - borrowCur - val2 + borrowNext * 10;
                borrowCur = borrowNext;
                resultNumber.add(temp);
            }
            //后者大，相减为负数
            if (compare == -1) {
                borrowNext = val2 - val1 - borrowCur >= 0 ? 0 : 1;
                temp = val2 - borrowCur - val1 + borrowNext * 10;
                borrowCur = borrowNext;
                resultNumber.add(temp);
            }

        }
        //去除高位0
        int indexZero = resultNumber.size() - 1;
        while (resultNumber.get(indexZero) == 0) {
            resultNumber.remove(resultNumber.size() - 1);
            indexZero--;
        }
        //为负则放入负号
        if (compare == -1) {
            resultNumber.add(45);
        }
        //结果对象赋值
        res.setNumbers(resultNumber);
        if (resultNumber.get(resultNumber.size() - 1) == 45) {
            res.setLength(resultNumber.size() - 1);
            System.out.println("运算结果不为自然数,返回值为负整数");
        } else {
            res.setLength(resultNumber.size());
            this.length = res.getLength();
            this.numbers = res.getNumbers();
        }

        return res;
    }

    //通过自然数创建整数
    public MyInteger toMyInteger() {
        MyInteger myInteger = new MyInteger();
        myInteger.setLength(this.length);
        myInteger.setNumbers(this.numbers);
        return myInteger;
    }

    //字符串格式化
    public String toString() {
        String number = "";
        for (int i = this.numbers.size() - 1; i >= 0; i--) {
            number = number + this.numbers.get(i);
        }
        return number;
    }

    //比较两个自然数大小
    public int equals(MyNaturalNumbers myNaturalNumbers) {
        if (this.length > myNaturalNumbers.length)
            return 1;
        else if (this.length < myNaturalNumbers.length)
            return -1;
        else {
            for (int i = this.length - 1; i >= 0; i--) {
                if (this.numbers.get(i) > myNaturalNumbers.numbers.get(i))
                    return 1;
                else if (this.numbers.get(i) < myNaturalNumbers.numbers.get(i))
                    return -1;
                else
                    continue;
            }
        }
        return 0;
    }

    //比较自然数与整数的大小
    public int equals(MyInteger myInteger) {
        int myIntegerSize = myInteger.getNumbers().size();
        if (myInteger.getNumbers().get(myIntegerSize - 1) == '-')
            return 1;
        else {
            if (this.length > myInteger.getLength())
                return 1;
            else if (this.length < myInteger.getLength())
                return -1;
            else {
                for (int i = this.length - 1; i >= 0; i--) {
                    if (this.numbers.get(i) > myInteger.getNumbers().get(i))
                        return 1;
                    else if (this.numbers.get(i) < myInteger.getNumbers().get(i))
                        return -1;
                    else
                        continue;
                }
            }
            return 0;
        }
    }
}

乘法和除法还没有来得及实现。这里的继承写的比较烂，所以在整数和自然数中有一些重复的代码。