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;
}
}
}
乘法和除法还没有来得及实现。这里的继承写的比较烂,所以在整数和自然数中有一些重复的代码。