- 浏览: 282643 次
- 性别:
- 来自: 北京
文章分类
最新评论
-
marshan:
服务器可以异步执行
HTML5中的服务器‘推送’技术 -Server-Sent Events -
flex_莫冲:
marshan 写道这个间隔可以由服务器端完成 无伤大雅服务器 ...
HTML5中的服务器‘推送’技术 -Server-Sent Events -
marshan:
这个间隔可以由服务器端完成 无伤大雅
HTML5中的服务器‘推送’技术 -Server-Sent Events -
flex_莫冲:
SSE就是循环执行ajax。SSE还不能自定义循环时间间隔。
HTML5中的服务器‘推送’技术 -Server-Sent Events -
iMaplezhou:
"然后用这个非抽象类的实例来调用方法"。怎 ...
Java抽象类和抽象方法
期中考试题2:BigInteger的部分实现
Java中long类型可以表示 -9,223,372,036,854,775,808(即-2^64)到9,223,372,036,854,775,807(即2^64-1)范围内的整数。有的时候我们希望能够处理在此范围之外的整数。
为此,我们设计了一个BigInteger类。它可以支持大整数的加、减、乘操作。请根据提供的代码框架,完成整个程序。
> 注:
> 1) 请仔细阅读代码中的注释,并在标有// YOU FILL THIS IN 的位置添加你的代码。你可以添加自己的方法、变量,但是请不要修改已有的代码。
> 2) 程序中的main函数只是一个示例测试。在批改作业时,我们会用更多的用例来测试你的程序。所以请保证你的程序的正确性。
> 3) 我们在测试你的程序时,将使用合法的输入值,因此你无需考虑输入不合法的情况。输入值可能有两种形式:"343839939" 或者
"-394939399390343",输入的数字位数不固定,但一定是合法的整数。
> 4) 不允许使用java.math包。
> 5) 请将你的项目打包成rar或者zip格式提交。请注意提交的格式:打开你的压缩包,应该可以看到BigInteger文件夹,这个文件夹里面包含了src和bin两个文件夹。
如果提交作业格式错误,将不能通过测试,没有得分。
给出的代码是这样子的:
其实,大家不要被这个看似很难的题目吓到,想想小学时我们刚开始学加法和乘法的时候,老师都教我们怎么算?竖式运算,对!由于BigInteger把每一位数都存在数组中,也为竖式运算提供了方便。
我们需要写的方法是:
public BigInteger(String numberStr);
public BigInteger add(BigInteger another);
public BigInteger add(int num);
public BigInteger subtract(BigInteger another);
public BigInteger subtract(int num);
public BigInteger multiply(BigInteger another);
public BigInteger multiply(int num);
3个小时,如果真的每个方法都写的话,估计很难做完。化归思想大家都学过,我们来运用一下:
这里的negate方法是新加的,就是返回一个相反数。减法就是加上一个数的相反数,对吧?(注意,为了防止可能的副作用,这里使用了deep copy)
于是,我们需要写的方法减少到了3个:
public BigInteger(String numberStr);
public BigInteger add(BigInteger another);
public BigInteger multiply(BigInteger another);
第一个方法不难,只要先判断第一个字符是不是'-',然后再把不是负号的部分加到digits数组中就行。(由于明确了输入格式肯定是正确的,这里不考虑输入格式的问题):
然后来看public BigInteger add(BigInteger another)方法,我们要考虑什么?首先是符号,如果两数同号,那好办,和肯定是和两数符号相同的;若异号,那么我们就要看两数绝对值的大小了,和与绝对值大的数同号。
怎样判断绝对值呢?首先看位数,位数大的绝对值肯定大。位数相同,则从首位开始比较,只要有一位不同,不同位置的数字大的大;如果每一位都相同,那么我们得到的就是0,省事很多。
然后我们考虑具体的加减,同号相加(其实是绝对值相加),要考虑进位问题,而产生的和的位数最多比绝对值大的数多一位;异号相加,其实是绝对值相减,要考虑借位问题,而得到的差位数不大于绝对值大的数。
这里要特别注意的是,竖式计算的是从最末尾开始的,而我们的数组首位存储的是最高位,第二位是第二高位,一次类推;故我们这里用的循环大多同平日写的循环有些不同:for(int i = 1;i <= digits.length;i++)。
梳理好以上思路,add方法写法如下:
最后就是乘法了,其实还是竖式计算,就是稍微麻烦了一点(暂时还没找到更好的解法,3个小时,咱就不考虑什么算法优化了)。第一还是先考虑符号,这个比加法简单,要是同号,商为正,要是异号,那么商为负。
第二是具体的竖式计算怎么做,先看一个例子:
规律是什么?1. 大数在上,小数在下; 2. 大数乘以小数的每一位,分别得到商; 3.最后把各个商按位相加。 听上去挺简单,不是吗?实现1,和加法里面的循环类似,从低位开始相乘,还要考虑进位。2中的商我们可以保存在一个二维数组中,数组第一维的大小是较小数的位数,第二维是较大数的位数+1,为什么有个+1?看看上面的第三个商,最多有可能比大数多一位。 而3呢?位数的便宜似乎比较难实现,但是想想我们上次做过的WordPuzzle,如果是个矩阵呢?其实上面的几个商,按照矩阵排列就是:
对应的加法是沿着主对角线方向的!有点感觉了是吧,而这个矩阵就是我们刚刚做的那个二维数组!
乘法实现如下:
以上几个方法中的zeroCount和接下来跟着的循环是用来去掉数组前几位不必要的0而设计的。
用java.math包内自带的BigInteger测试了几个相同的实例:
得到的结果:(没两行上面的是java.math包内的BigInteger的结果,下面是我写的BigInteger的结果)
Java中long类型可以表示 -9,223,372,036,854,775,808(即-2^64)到9,223,372,036,854,775,807(即2^64-1)范围内的整数。有的时候我们希望能够处理在此范围之外的整数。
为此,我们设计了一个BigInteger类。它可以支持大整数的加、减、乘操作。请根据提供的代码框架,完成整个程序。
> 注:
> 1) 请仔细阅读代码中的注释,并在标有// YOU FILL THIS IN 的位置添加你的代码。你可以添加自己的方法、变量,但是请不要修改已有的代码。
> 2) 程序中的main函数只是一个示例测试。在批改作业时,我们会用更多的用例来测试你的程序。所以请保证你的程序的正确性。
> 3) 我们在测试你的程序时,将使用合法的输入值,因此你无需考虑输入不合法的情况。输入值可能有两种形式:"343839939" 或者
"-394939399390343",输入的数字位数不固定,但一定是合法的整数。
> 4) 不允许使用java.math包。
> 5) 请将你的项目打包成rar或者zip格式提交。请注意提交的格式:打开你的压缩包,应该可以看到BigInteger文件夹,这个文件夹里面包含了src和bin两个文件夹。
如果提交作业格式错误,将不能通过测试,没有得分。
给出的代码是这样子的:
public class BigInteger { // The sign of this integer - true for a positive number, and false // otherwise private boolean sign = true; // digits[0] is the most significant digit of the integer, and // the last element of this array is the least significant digit. // For example, if we have a BigInteger of value 34, then // digits[0] = 3 and digits[1] = 4. private byte[] digits; public BigInteger() { this.digits = new byte[1]; this.digits[0] = 0; } public BigInteger(byte[] digits) { this.digits = digits; } /** * Initializes a <code>BigInteger</code> according to a string. The form of * <code>numberStr</code> is a string consisting of all digits ranging from * 0 to 9, following an OPTIONAL minus symbol (i.e., "-"). For example, * "1234567891234567" and "-17788399934334388347734" are both valid. * * @param numberStr * a number expressed as a string */ public BigInteger(String numberStr) { // YOU FILL THIS IN // Note: You should parse the string and initialize the "digits" array // properly. // You may also need to set the "sign" variable to a correct value. } /** * Performs addition. * * @param another * another <code>BigInteger</code> object * @return this+another */ public BigInteger add(BigInteger another) { // YOU FILL THIS IN } /** * Performs addition. * * @param num * an integer * @return this+num */ public BigInteger add(int num) { // YOU FILL THIS IN } /** * Performs subtraction. * * @param another * another <code>BigInteger</code> object * @return this-another */ public BigInteger subtract(BigInteger another) { // YOU FILL THIS IN } /** * Performs subtraction. * * @param num * an integer * @return this-num */ public BigInteger subtract(int num) { // YOU FILL THIS IN } /** * Performs multiplication. * * @param another * another <code>BigInteger</code> object * @return this*another */ public BigInteger multiply(BigInteger another) { // YOU FILL THIS IN } /** * Performs multiplication. * * @param num * an integer * @return this*num */ public BigInteger multiply(int num) { // YOU FILL THIS IN } public String toString() { StringBuffer buf = new StringBuffer(); if (!sign) { buf.append("-"); } for (byte d : digits) { buf.append(d); } return buf.toString(); } public static void main(String[] args) { BigInteger i1 = new BigInteger("999999999999999999"); BigInteger i2 = i1.add(1); System.out.println(i2); // the output should be 1000000000000000000 BigInteger i3 = i2.multiply(i1); System.out.println(i3); // expected: 999999999999999999000000000000000000 System.out.println(i3.subtract(-3)); // expected: 999999999999999999000000000000000003 } }
其实,大家不要被这个看似很难的题目吓到,想想小学时我们刚开始学加法和乘法的时候,老师都教我们怎么算?竖式运算,对!由于BigInteger把每一位数都存在数组中,也为竖式运算提供了方便。
我们需要写的方法是:
public BigInteger(String numberStr);
public BigInteger add(BigInteger another);
public BigInteger add(int num);
public BigInteger subtract(BigInteger another);
public BigInteger subtract(int num);
public BigInteger multiply(BigInteger another);
public BigInteger multiply(int num);
3个小时,如果真的每个方法都写的话,估计很难做完。化归思想大家都学过,我们来运用一下:
public BigInteger(int integer){ this(String.valueOf(integer)); } public BigInteger add(int num) { return this.add(new BigInteger(num)); } public BigInteger subtract(BigInteger another) { return this.add(another.negate()); } public BigInteger subtract(int num) { return this.subtract(new BigInteger(num)); } public BigInteger multiply(int num) { return this.multiply(new BigInteger(num)); }
这里的negate方法是新加的,就是返回一个相反数。减法就是加上一个数的相反数,对吧?(注意,为了防止可能的副作用,这里使用了deep copy)
public BigInteger negate(){ BigInteger bi = new BigInteger(); byte[] digitsCopy = new byte[this.digits.length]; for(int i = 0;i < this.digits.length;i++){ digitsCopy[i] = this.digits[i]; } bi.sign = !this.sign; bi.digits = digitsCopy; return bi; }
于是,我们需要写的方法减少到了3个:
public BigInteger(String numberStr);
public BigInteger add(BigInteger another);
public BigInteger multiply(BigInteger another);
第一个方法不难,只要先判断第一个字符是不是'-',然后再把不是负号的部分加到digits数组中就行。(由于明确了输入格式肯定是正确的,这里不考虑输入格式的问题):
public BigInteger(String numberStr) { // YOU FILL THIS IN // Note: You should parse the string and initialize the "digits" array // properly. // You may also need to set the "sign" variable to a correct value. if(numberStr.charAt(0) == '-'){ sign = false; StringBuilder sb = new StringBuilder(numberStr); sb.deleteCharAt(0); numberStr = new String(sb); }else{ sign = true; } digits = new byte[numberStr.length()]; for(int i = 0;i < numberStr.length();i++){ switch(numberStr.charAt(i)){ case '0': digits[i] = 0;break; case '1': digits[i] = 1;break; case '2': digits[i] = 2;break; case '3': digits[i] = 3;break; case '4': digits[i] = 4;break; case '5': digits[i] = 5;break; case '6': digits[i] = 6;break; case '7': digits[i] = 7;break; case '8': digits[i] = 8;break; case '9': digits[i] = 9;break; } } }
然后来看public BigInteger add(BigInteger another)方法,我们要考虑什么?首先是符号,如果两数同号,那好办,和肯定是和两数符号相同的;若异号,那么我们就要看两数绝对值的大小了,和与绝对值大的数同号。
怎样判断绝对值呢?首先看位数,位数大的绝对值肯定大。位数相同,则从首位开始比较,只要有一位不同,不同位置的数字大的大;如果每一位都相同,那么我们得到的就是0,省事很多。
然后我们考虑具体的加减,同号相加(其实是绝对值相加),要考虑进位问题,而产生的和的位数最多比绝对值大的数多一位;异号相加,其实是绝对值相减,要考虑借位问题,而得到的差位数不大于绝对值大的数。
这里要特别注意的是,竖式计算的是从最末尾开始的,而我们的数组首位存储的是最高位,第二位是第二高位,一次类推;故我们这里用的循环大多同平日写的循环有些不同:for(int i = 1;i <= digits.length;i++)。
梳理好以上思路,add方法写法如下:
public BigInteger add(BigInteger another) { // YOU FILL THIS IN BigInteger sum = new BigInteger(); if(this.sign == another.sign){ //the signs of both are equal int length1 = this.digits.length; int length2 = another.digits.length; int biggerLength = Math.max(length1, length2); byte[] temp = new byte[biggerLength]; byte carry = 0; for(int i = 1;i <= biggerLength;i++){ byte i1 = (length1 - i < 0)?0:this.digits[length1 - i]; byte i2 = (length2 - i < 0)?0:another.digits[length2 -i]; int s = i1 + i2 + carry; if(s < 10){ temp[biggerLength - i] = (byte)s; carry = 0; }else{ temp[biggerLength - i] = (byte)(s - 10); carry = 1; } } if(carry == 0){ sum.digits = temp; }else{ sum.digits = new byte[biggerLength + 1]; sum.digits[0] = carry; for(int i = 0;i < biggerLength;i++){ sum.digits[i + 1] = temp[i]; } } sum.sign = this.sign; }else{ //the signs differ boolean isAbsoluteEqual = false;//the default value is false boolean isThisAbsoluteBigger = false;// the default value is false if(this.digits.length > another.digits.length){ isThisAbsoluteBigger = true; }else if(this.digits.length == another.digits.length){ isAbsoluteEqual = true; for(int i = 0;i < this.digits.length;i++){ if(this.digits[i] != another.digits[i]){ if(this.digits[i] > another.digits[i]){ isThisAbsoluteBigger = true; } isAbsoluteEqual = false; break; } } } //if isAbsoluteEqual is true, the sum should be 0, which is just the default value if(!isAbsoluteEqual){ byte[] temp; byte[] bigger; byte[] smaller; if(isThisAbsoluteBigger){ sum.sign = this.sign; temp = new byte[this.digits.length]; bigger = this.digits; smaller = another.digits; }else{ sum.sign = another.sign; temp = new byte[another.digits.length]; bigger = another.digits; smaller = this.digits; } boolean borrow = false; for(int index = 1;index <= bigger.length;index++){ byte biggerDigit = bigger[bigger.length - index]; biggerDigit = (byte) ((borrow)?(biggerDigit - 1):biggerDigit); byte smallerDigit = (smaller.length - index < 0)?0:smaller[smaller.length - index]; int s = biggerDigit - smallerDigit; if(s < 0){ borrow = true; s += 10; }else{ borrow = false; } temp[temp.length - index] = (byte)s; } int zeroCount = 0; for(int i = 0;i < temp.length;i++){ if(temp[i] == 0){ zeroCount++; }else{ break; } } sum.digits = new byte[temp.length - zeroCount]; for(int i = 0;i < sum.digits.length;i++){ sum.digits[i] = temp[zeroCount + i]; } } } return sum; }
最后就是乘法了,其实还是竖式计算,就是稍微麻烦了一点(暂时还没找到更好的解法,3个小时,咱就不考虑什么算法优化了)。第一还是先考虑符号,这个比加法简单,要是同号,商为正,要是异号,那么商为负。
第二是具体的竖式计算怎么做,先看一个例子:
1 2 3 4 x 9 3 4 ---------------- 4 9 3 6 3 7 0 2 + 1 1 1 0 6 ---------------- 1 1 5 2 5 5 6
规律是什么?1. 大数在上,小数在下; 2. 大数乘以小数的每一位,分别得到商; 3.最后把各个商按位相加。 听上去挺简单,不是吗?实现1,和加法里面的循环类似,从低位开始相乘,还要考虑进位。2中的商我们可以保存在一个二维数组中,数组第一维的大小是较小数的位数,第二维是较大数的位数+1,为什么有个+1?看看上面的第三个商,最多有可能比大数多一位。 而3呢?位数的便宜似乎比较难实现,但是想想我们上次做过的WordPuzzle,如果是个矩阵呢?其实上面的几个商,按照矩阵排列就是:
0 4 9 3 6 0 3 7 0 2 1 1 1 0 6
对应的加法是沿着主对角线方向的!有点感觉了是吧,而这个矩阵就是我们刚刚做的那个二维数组!
乘法实现如下:
public BigInteger multiply(BigInteger another) { // YOU FILL THIS IN BigInteger product = new BigInteger(); if(this.sign == another.sign){ product.sign = true; }else{ product.sign = false; } int biggerLength; int smallerLength; byte[] bigger; byte[] smaller; byte[][] tempProducts; if(this.digits.length >= another.digits.length){ biggerLength = this.digits.length; smallerLength = another.digits.length; bigger = this.digits; smaller = another.digits; }else{ biggerLength = another.digits.length; smallerLength = this.digits.length; bigger = another.digits; smaller = this.digits; } tempProducts = new byte[smallerLength][]; for(int i = 1;i <= smallerLength;i++){ byte[] temp = new byte[biggerLength + 1];//make plenty of space to avoid overflow byte carry = 0; byte m1 = smaller[smallerLength - i]; for(int j = 1;j <= biggerLength;j++){ byte m2 = bigger[biggerLength - j]; int tempProduct = m1 * m2 + carry; temp[biggerLength + 1 - j] = (byte)(tempProduct % 10); carry = (byte)(tempProduct / 10); } temp[0] = carry; tempProducts[i - 1] = temp; } byte[] sum = new byte[smallerLength + biggerLength]; byte carry = 0; int count = 1; int row = 0; int column = biggerLength; while(count <= sum.length){ int startR = row; int startC = column; int currentSum = 0; while((startR < smallerLength) && (startC < biggerLength + 1)){ currentSum += tempProducts[startR][startC]; startR++; startC++; } currentSum += carry; if(currentSum < 10){ sum[sum.length - count] = (byte)(currentSum); carry = 0; }else{ sum[sum.length - count] = (byte)(currentSum % 10); carry = (byte)(currentSum / 10); } //System.out.println("processing digit: " + (sum.length - count) + " current digit: " + sum[sum.length - count] + " current carry: " + carry); if(column == 0){ row++; }else{ column--; } count++; } int zeroCount = 0; for(int i = 0;i < sum.length;i++){ if(sum[i] == 0){ zeroCount++; }else{ break; } } product.digits = new byte[sum.length - zeroCount]; for(int i = 0;i < product.digits.length;i++){ product.digits[i] = sum[zeroCount + i]; } return product; }
以上几个方法中的zeroCount和接下来跟着的循环是用来去掉数组前几位不必要的0而设计的。
用java.math包内自带的BigInteger测试了几个相同的实例:
public static void main(String[] args) { BigInteger bi = new BigInteger("-123456789").multiply(new BigInteger("1111111111")).multiply(new BigInteger("-222222222")).multiply(new BigInteger("333333333")).multiply(new BigInteger("-444444444")).multiply(new BigInteger("555555555")).multiply(new BigInteger("678987654")); System.out.println(bi); BigInteger bi2 = new BigInteger("123456789").multiply(new BigInteger("-999999999").multiply(new BigInteger("2387423749237"))); System.out.println(bi2); System.out.println(bi.subtract(bi2)); System.out.println(bi.add(bi2)); }
得到的结果:(没两行上面的是java.math包内的BigInteger的结果,下面是我写的BigInteger的结果)
-1703513391044005504226057865745939441413078537590685258276720 -1703513391044005504226057865745939441413078537590685258276720 -294743669768397549929858780007 -294743669768397549929858780007 -1703513391044005504226057865745644697743310140040755399496713 -1703513391044005504226057865745644697743310140040755399496713 -1703513391044005504226057865746234185082846935140615117056727 -1703513391044005504226057865746234185082846935140615117056727
发表评论
-
【转】java 命令行引用jar包的方法 的整理
2011-09-22 22:20 7412http://hi.baidu.com/jlike/ ... -
【笔试】两个大数相乘
2011-09-16 14:09 2175package com.baidu.ecom; ... -
【面试】当一个线程进入一个对象的一个synchronized方法后,其它线程是否可进入此对象的其它方法?
2011-09-15 11:18 4279问题:当一个线程进入一个对象的一个synchronized方法 ... -
System.err与System.out的区别【zhuan】
2011-08-17 15:38 2033System.err与System.out的区别 今天 ... -
Thinking in java 的附录E——关于java垃圾回收
2011-08-17 14:54 1501附录E 关于垃圾收集的 ... -
java foreach语法
2011-08-17 11:45 1706java的foreach可以遍历数组和所有的Collecti ... -
java 嵌套接口
2011-08-11 20:20 1478接口可以嵌套在类 或者 其他接口中。 当实现某 ... -
什么是HotSpot【转自网易博客】
2011-08-10 14:47 1272什么是HotSpot 链接:h ... -
HotSpot虚拟机对象探秘[转自infoQ]
2011-08-10 14:37 1274HotSpot虚拟机对象探秘 ... -
java操作符重载?
2011-08-06 18:04 1367+ 和+= 被重载来处理String对象 -
java静态导入--导入你需要的静态成员
2011-08-03 23:14 1180java静态导入--导入你需要的静态成员 在Java ... -
Java内存模型中的三个代简介
2011-07-28 21:20 2008Java内 ... -
【面试】Map放进去重复key-value对
2011-07-20 21:54 3699import java.util.ArrayList; ... -
javap查看class文件
2011-06-09 22:26 3028javap JDK自带的反汇编器,可以查看java编译器为我 ... -
Java序列化之高级认识
2011-06-09 21:32 1337Java序列化之高级认识 将 Java 对象序列化为二进制文 ... -
Java的BitSet类(JDK1.1)
2011-05-30 17:29 3022BitSet实际是由“二进制位”构成的一个Vector。如果希 ... -
JAVA字符编码系列二:Unicode,ISO-8859,GBK,UTF-8编码及相互转换
2011-05-09 11:25 1566JAVA字符编码系列二:Unicode,ISO-8859,GB ...
相关推荐
- 设计一个能处理一百亿级别的计算器,需要考虑大整数运算,可以使用`BigInteger`类来实现。 2. **变量与数据类型** - `final`关键字修饰变量时,如果是对象引用,意味着引用不能改变,但引用的对象内容可以改变...
《Java笔试题面试宝典》是一本针对初级Java...以上是部分Java笔试题和面试中常见的知识点,深入理解这些概念对于Java开发者来说至关重要。在实际面试中,应试者不仅要熟记这些知识点,还要能够灵活应用和解决实际问题。
首先,Java基础部分包括: - 基本语法:包括数据类型、运算符、流程控制、方法定义等。 - 类相关的语法:包括类的定义、构造函数、实例化、对象引用等。 - 内部类语法:包括局部内部类、匿名内部类、静态内部类的...
9. **设计大整数计算器**:实现一个能处理百亿级别的计算器,需要考虑使用`BigInteger`类,它可以处理任意大小的整数,并提供了所有必要的数学运算方法。 10. **final关键字**:`final`修饰的变量,如果是基本类型...
9. 设计一个一百亿的计算器涉及大数运算,可以通过使用Java的BigInteger类来实现。 10. 使用final关键字修饰变量时,该变量的引用地址不能变,但是引用的对象本身可以改变(如果对象是可变的)。 11. "=="用于比较...
该文件为Java程序员面试宝典的一部分,主要内容包括Java基础知识点的面试问题及其答案,非常适合准备参加Java程序员面试的求职者。以下是详细的知识点: 1. Java源文件中可以包括多个类,但只能有一个公共类...
这只是Java面试宝典中一小部分问题的解析,实际的面试可能会涉及更多概念和技术细节,如多线程、集合框架、异常处理、IO流、设计模式、JVM内存模型等。熟悉并理解这些知识点对于提升Java程序员的技能和面试成功率至...
以上仅是《Java面试宝典(2012.6)》中部分精选知识点的深度解析,每一项都是Java面试中常见的考察点。深入理解并掌握这些知识,不仅能提升个人的编程能力,更能在面试中脱颖而出,展现出扎实的理论基础与实践能力。
1. Java基础部分: - .java文件中可以包括多个类,但只有一个类可以被声明为public类,且这个类的名称需要与文件名相匹配。 - Java中没有goto语句。 - &是位运算符,而&&是逻辑运算符,后者在逻辑与操作中具有...
7. `char`型变量可以存储单个Unicode字符,包括中文汉字,因为每个`char`占据16位,足以表示大部分常用字符。 8. 计算2乘以8最有效率的方式是直接使用 `2 ,这利用了位移运算的效率。 9. 设计一个一百亿的计算器,...
以上问题只是Java面试中的一部分,实际面试中还会涉及更多关于多线程、异常处理、IO流、集合框架、设计模式、JVM内存管理等方面的问题。全面理解和熟练应用这些知识点是成为合格Java开发者的必备条件。
19. 构造器不能被override:构造器不是继承的一部分,不能像普通方法那样被重写,但可以在子类中声明同名构造器实现重载。 20. 接口与抽象类:接口可以继承接口;抽象类可以实现接口;抽象类不能继承具体类,但可以...
Java 基础部分 1. **JAVA 的基本数据类型有哪些 ? String 是不是基本数据类型 ?** Java 的基本数据类型包括:整型(byte, short, int, long)、浮点型(float, double)、字符型(char)和布尔型(boolean)。...
- **抽象类**可以包含抽象方法和非抽象方法,可以有状态(即成员变量),可以提供部分实现。 - **接口**只能包含抽象方法(Java 8后可以有默认方法和静态方法),没有状态,只能定义常量。 3. **Strings=new ...
《Java工程师面试宝典》是一份详尽的指南,旨在帮助Java开发者准备面试,涵盖了从基础知识到高级概念的广泛主题。以下是对标题和描述中提到的知识点的深入解析: ### Java基础部分 #### 1. 多个类在一个源文件中 ...
实现一个能够处理非常大数字的计算器,可以使用`BigInteger`类,该类提供对任意精度整数的支持。 #### 10. `final`关键字的作用 使用`final`关键字修饰一个变量时,实际上是不允许修改变量的引用。对于基本数据...
在计算机科学中,大整数运算通常使用大数库实现,比如Java的BigInteger类或Python的内置支持。这些库提供了加、减、乘、除等操作,可以处理超过普通整型范围的数值。 4. **统计记录频度并输出前5%和后5%**: 这...
- 设计一个能处理百亿级别的计算器要考虑大整数的运算,可以使用BigInteger类来实现。 5. **final关键字** - `final`修饰的变量,其引用一旦初始化后不可更改,对于基本类型,是值不可变;对于对象,是引用的对象...
9. 设计一个能处理一百亿数字的计算器,需要考虑数值溢出问题,可能需要使用大整数类如 `BigInteger`,并实现加减乘除等基本运算。 10. 使用 `final` 关键字修饰变量,意味着该引用不可变,一旦赋值后就不能更改。 ...
- 设计一个能处理一百亿(10^10)级别的计算器,需要考虑高效的大整数运算,可以使用BigInteger类来实现。 5. **final关键字** - 使用`final`修饰变量,意味着变量一旦赋值后就不能再改变,如果是对象引用,引用...