黑马程序员_基础测试

-------android培训、java培训、期待与您交流！
----------

黑马程序员训练营基础测试题及个人代码（包含思路、步骤和基本注释）

1、 编写程序计算12+22+32+....+1002的和.

package com.itheima;

/*
* 第一题：编写程序计算1到100的平方和。
*
* 		思路：
* 			①计算方法，可以采用两数相乘再进行累加，也可以采用自带的Math函数处理后进行累加，还可以利用数学公式计算。
* 			②实现方法：可以使用for循环方法、do while循环方法、while循环方法、递归方法和公式直接定义方法。
* 		步骤：
* 			①定义实现不同方法的静态函数，主函数可以调用。
* 			②在函数中实现计算方法。
*/
public class Test1 {
//-------------------------------------------------------------------------------------
//主函数用来调用不同方法的函数。
public static void main(String[] args) {
int sum1=formethod(1,100);
int sum2=dowhilemethod(1, 100);
int sum3=whilemethod(1, 100);
int sum4=recursivemethod(1, 100);
int sum5=formulamethod(1, 100);
//调用5个具有不同方法的函数，将结果存入对应的5个变量中
System.out.println("for循环方法的计算结果是："+sum1+"\ndowhile循环方法的计算结果是："+sum2+"\nwhile循环方法的计算结果是："+sum3+"\n递归循环方法的计算结果是："+sum4+"\n公式直接定义方法的计算结果是："+sum5);
//输出结果
}
//-------------------------------------------------------------------------------------
//利用for循环来实现数a到数b的平方和。
public static int formethod(int a,int b){
int sum=0;//定义一个存放结果的sum变量
for(int c=a;c<=b; c++){
sum=sum+c*c;//将存在sum中的值和数c的平方相加得到新值，存入sum中。
}//for语句中定义变量c=a完成变量的初始化，c<=b规定平方和计算的循环条件，c++用来运行一遍循环后修改控制循环的变量值。
return sum;//返回sum的值。
}
//-------------------------------------------------------------------------------------
//利用do while循环来实现数a到数b的平方和。
public static int dowhilemethod(int a,int b){
int sum=0;//定义一个存放结果的sum变量
do{
sum=sum+a*a;
a++;
}//将存在sum中的值和数c的平方相加得到新值，存入sum中,a++用来运行一遍循环后修改控制循环的变量值。
while(a<=b);//当while语句中的“a<=b”条件不被满足时，自动停止循环
return sum;//返回sum的值。
}
//-------------------------------------------------------------------------------------
//利用while循环来实现数a到数b的平方和。
public static int whilemethod(int a,int b){
int sum=0;//定义一个存放结果的sum变量
while(a<=b){
sum=sum+a*a;
a++;
}//将存在sum中的值和数c的平方相加得到新值，存入sum中,a++用来运行一遍循环后修改控制循环的变量值。当while语句中的“a<=b”条件不被满足时，自动停止循环
return sum;//返回sum的值。
}
//-------------------------------------------------------------------------------------
//利用递归方法来实现数a到数b的平方和。
public static int recursivemethod(int a,int b){
if(a==b){
return (int)Math.pow(a, 2);//如果第一个值与最后一个值相同，利用math类中的幂计算函数计算后直接返回此值的平方。
}
return b*b+recursivemethod(a, b-1);//利用递归方法，调用自身计算出结果。
}
//-------------------------------------------------------------------------------------
//直接定义公式来实现数a到数b的平方和。
public static int formulamethod(int a,int b){
int sum=0;//定义一个存放结果的sum变量
int c=a-1;//若a不等于1，计算a与1的差
sum=b*(b+1)*(2*b+1)/6-c*(c+1)*(2*c+1)/6;//定义平方和公式
return sum;//返回sum的值。
}
//-------------------------------------------------------------------------------------

}

2、 定义一个二维int数组，编写代码获取最小元素。

package com.itheima;

/*
* 第二题：定义一个二维int数组，编写代码获取最小元素。
*
* 		思路：
* 			要求获取二维数组中的最小元素，可以定义一个二维数组运用for循环进行比较，直到找到最小的元素，即求得。
* 		步骤：
* 			①定义一个二维数组并赋值进行初始化，定义一个最小元素变量并初始化
* 			②运用嵌套循环控制二维数组的行和列的值，在循环中将数组元素值和min进行比较，
* 				如果数组元素值比min更小，则将数组元素值赋给min，不断循环这个过程，循环完毕后，min值则为二维数组中最小的元素
*
*/
public class Test2 {

public static void main(String[] args) {

int arr[][]={{9,8,5,3},{6,2,7,1},{4,5,8,6}};//定义了一个二维int数组，赋初值进行初始化
int min=arr[0][0];//定义一个代表最小元素的变量并初始化
for(int i=0; i<arr.length; i++){
for(int j=0; j<arr[i].length; j++){
if(arr[i][j]<min){
min=arr[i][j];
}//将数组元素值和min进行比较，如果数组元素值比min小，则将数组元素值赋给min
}//此for循环用来控制二维数组中的列值
}//此for循环用来控制二维数组中的行值
System.out.println("二维int数组中的最小元素为"+min);//最终得到二维数组中最小的元素并输出。
}
}

3、 以下代码哪个是正确的？为什么？
a. byte b = 1 + 1;
b. byte b = 1;b = b + 1;
c. byte b = 1;b = b += 1;
d. byte b = 1;b = ++b;

package com.itheima;

public class Test3 {
/*
* 第三题：以下代码哪个是正确的？为什么？
a. byte b = 1 + 1;
b. byte b = 1; b = b + 1;
c. byte b = 1; b = b += 1;
d. byte b = 1; b = ++b;
解答：
a，c，d正确；b错误。

选项a中，语句等价于byte = 2；因为右边是常量，其值固定,操作数在byte型的范围内，编译器会自动完成强制转换，所以正确；
选项c中，+=是一个赋值运算符，加和赋值是一步完成的，含有强制类型转换。等价于b=b=(byte)(b+1)；所以正确；
选项d中，++是自增运算符,自身加1再赋值给自己，加1和赋值也是一步完成的，且不会改变变量的类型（含有强制类型转换）。byte b = 1; b = ++b; ”语句相当于“[byte] b = [byte] b + [byte] 1”语句,所以正确；
选项b中，因为“byte b = 1; b = b + 1; ”语句相当于“[byte] b = [byte] b + [int] 1”语句，b自动转型为int与1做加法，结果是int类型，把int类型赋给byte类型b，类型不符合，所以错误。
*
*/
public static void main(String[] args) {
byte b = 1 + 1;
//byte b = 1; b = b + 1;
//byte b = 1; b = b += 1;
//byte b = 1; b = ++b;
System.out.println(b);

}

}

4、 编写一个函数，函数内输出一个字符串，并在主函数内调用它。

package com.itheima;

public class Test4 {

/*
* 第四题：编写一个函数，函数内输出一个字符串，并在主函数内调用它。
*	思路：定义字符串输出函数供主函数调用
*	步骤：编写一个静态函数，函数中定义一个字符串并输出，在main函数里调用这个函数。
*/
public static void main(String[] args) {
output();//调用函数
}
public static void output(){
String str="I love itheima！";//定义字符串
System.out.println(str);//输出字符串
}
}

5、 写出以下代码执行结果，分析为什么？(没有分析结果不得分)
public class Test {
public static void main(String[] args) {
String s = "abc";
s.substring(1);
s.replace("bc", "xyz");
System.out.println(s);
String value = new String ("abc");
System.out.println(s == value);
}
}

package com.itheima;

public class Test5 {
/*第五题：写出以下代码执行结果，分析为什么？(没有分析结果不得分)

public class Test {
public static void main(String[] args) {
String s = "abc";
s.substring(1);
s.replace("bc", "xyz");
System.out.println(s);
String value = new String ("abc");
System.out.println(s == value);
}
}

解答：执行结果为:   abc
false

分析：定义一个字符串s等于abc，对s进行了substring和replace操作，作用是截取和替换，对s的操作都产生了新的字符串，
但新字符串对字符串s并不产生影响，操作后，字符串s的值还是abc，所以程序输出s结果为abc。

s==value实际上比较的是s和value在内存中的地址是否相同，并返回逻辑值，比较的并不是两者的内容，
在语句中，虽然s和value的内容都是abc，但s和value指向的不是同一个对象，内存地址不相同，
所以程序输出s==value为false。

*
* */
public static void main(String[] args) {
String s = "abc";
s.substring(1);//将s中的第一位a截取掉，生成新字符串bc，s不变
s.replace("bc", "xyz");//将s中的bc替换为xyz生成新字符串xyz，s不变
System.out.println(s);
String value = new String ("abc");
System.out.println(s == value);//s和value指向的不是同一个对象,false
}
}

6、 用控制台程序倒着输出九九乘法表；输出结果按下图所示：
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
……
1*3=3 2*3=6 3*3=9
1*2=2 2*2=4
1*1=1

package com.itheima;

public class Test6 {
/*第六题：用控制台程序倒着输出九九乘法表；输出结果按下图所示：

1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81

……

1*3=3   2*3=6   3*3=9

1*2=2   2*2=4

1*1=1
思路：
要求倒着输出九九乘法表，采用嵌套循环控制行和列，进行计算并按格式输出。
步骤:
在for循环控制行数时从9开始，循环条件为行数大于等于1，每循环一次行数减1;
for循环控制列数时从1开始，循环条件为列数小于等于9，每循环一次列数+1;
嵌套循环中定义好计算式，并按照格式输出即可倒着输出九九乘法表。
* */
public static void main(String args[]) {
int i,j,k; //定义三个变量，i，j用来表示行数和列数，k表示运算结果
for(i=9;i>=1;i--) {
for(j=1;j<=i;j++) {
k=i*j; //运算结果
System.out.print(j+"*"+i+"="+k+"\t"); //按格式输出等式
}
System.out.println("\n");  //处理完一行进行换行
}
}
}

7、在打印语句中如何打印这3个x变量？

class A {
int x = 1;

class B {
int x = 2;

void func() {
int x = 3;
System.out.println( ? );
}
}
}

package com.itheima;

/*第七题：在打印语句中如何打印这3个x变量？

class A {
int x = 1;

class B {
int x = 2;

void func() {
int x = 3;
System.out.println( ? );
}
}
}
思路: 外部类中有一个内部类，各个类拥有自己的成员变量，且类中变量是实例变量，要求内部类中的函数输出3个位置不同的x变量
已知内部非静态类中可以随意访问外部类的各个成员或成员函数，直接访问成员变量可以实现打印出这3个x变量。
* */
class A {
int x = 1;
class B {
int x = 2;
void func() {
int x = 3;
System.out.println(A.this.x+ "," + B.this.x + "," + x);
//内部非静态类中可以随意访问外部类的各个成员变量或成员函数。
//如果内部类B为静态，则输出语句应为“System.out.println(new A().x+ "," + new B().x + "," + x);”
// 因为内部类B在静态的情况下，B随着类的加载而加载，B中函数调用A的非静态成员变量必须要建立对象。
}
}//内部类
}//外边类
public class Test7 {
public static void main(String[] args){
A.B ab=new A().new B();//若B类为静态,此处语句应为“A.B ab=new A.B();”
ab.func();
}
}

8、 编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。

package com.itheima;
import java.io.*;

/*第八题：编写程序，从键盘接收一个字符串，对字符串中的字母进行大小写互转（大写字母转成小写，小写字母转成大写）。
* 思路：①从键盘接收一个字符串，需要用到输入流
* 			②接收到字符串后有两种方法可以进行大小字母转换，
* 				第一种利用Character类自带函数逐字符判断字符类型进行转换并输出
* 				第二种利用大小写字母范围逐字符判断字符类型后对字符加或减32转换字符并输出。
* 步骤：①定义两个实现转换功能的函数，分别利用两种不同方法实现。
* 			②在主函数中调用函数实现输入字符串对其中的大小写字母进行互转。
* */
public class Test8 {
//------------------------------------------------------------------------------------------------------------------------
//两种转换方法
public static String convertstr1(String s) throws Exception {
StringBuffer sb=new StringBuffer();//定义字符串变量
if(s.equals("over")){
System.out.println("当前方法已经终止运行！");
Test8.main(null);
}
for(int i=0;i<s.length();i++) {
char c=s.charAt(i);//字符串中取得具体字符
if(Character.isUpperCase(c)) {
sb.append(Character.toLowerCase(c));
}//若用isUpperCase判断字符为大写字母，则利用toLowerCase将其转换为小写字母
else if(Character.isLowerCase(c)) {
sb.append(Character.toUpperCase(c));
}//若用isLowerCase判断字符为小写字母，则利用toUpperCase将其转换为大写字母
else if(Character.isDigit(c)) {
sb.append(c);
}//若用isDigit判断字符为数字，则保持不变
else {
sb.append(c);
}//其他字符保持不变
}
return sb.toString();//返回字符串
}
public static String convertstr2(String s) throws Exception {
StringBuffer sb=new StringBuffer();//定义字符串变量
if(s.equals("over")){
System.out.println("当前方法已经终止运行！");
Test8.main(null);
}
for(int i=0;i<s.length();i++) {
char c=s.charAt(i);//字符串中取得具体字符
if(c>='A'&&c<='Z') {
c+=32;
sb.append(c);
}//若判断字符为大写字母，则将其+32转换为小写字母。ASCII码中，大写字母比小写字母的数值小32
else if(c>='a'&&c<='z') {
c-=32;
sb.append(c);
}//若判断字符为小写字母，则将其-32转换为大写字母。ASCII码中，小写字母比大写字母的数值大32
else {
sb.append(c);
}//其他字符保持不变
}
return sb.toString();//返回字符串
}
//-----------------------------------------------------------------------------------------------------------------------
public static void convert1(){
BufferedReader br=null;
System.out.println("请输入一串字符，输入over可以停止当前方法。");
try {
br=new BufferedReader(new InputStreamReader(System.in));//接受字符串
String s=null;
while((s=br.readLine())!=null){
System.out.println(convertstr1(s));//调用convertstr1函数对字符串进行转换
}
}
catch(Exception e) {
System.out.println(e.getMessage());
}
}
public static void convert2(){
BufferedReader br=null;
System.out.println("请输入一串字符，输入over可以停止当前方法。");
try {
br=new BufferedReader(new InputStreamReader(System.in));//接受字符串
String s=null;
while((s=br.readLine())!=null){
System.out.println(convertstr2(s));//调用convertstr2函数对字符串进行转换
}
}
catch(Exception e) {
System.out.println(e.getMessage());
}
}
public static void main(String[] args) {
System.out.println("请输入编号选择方法：\n1.Character类转换方法\n2.ASCII码转换方法\n");
try {
BufferedReader br1=new BufferedReader(new InputStreamReader(System.in));
String a=br1.readLine();
if(a.equals("1")){
System.out.println("Character类转换方法:");
convert1();
}
if(a.equals("2")){
System.out.println("ASCII码转换方法:");
convert2();
}
if(!a.equals("1")||!a.equals("2")){
System.out.println("编号输入错误！");
Test8.main(null);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}

9、 定义一个静态方法，该方法可以接收一个List<Integer>，方法内对List进行排序

package com.itheima;

import java.util.*;
/*第九题：定义一个静态方法，该方法可以接收一个List<Integer>，方法内对List进行排序
* 思路：定义一个静态方法返回值为list，在方法中定义一个list，再使用Collections类中的sort函数对其排序。
* */
public class Test9 {
public static void main(String[] args){
List<Integer> list = Arrays.asList(4,3,1,9,7,6,2,0,5,8);//建立一个list
getList(list);//将list传给getlist函数进行排序处理
}

public static List<Integer> getList(List<Integer> list){
Collections.sort(list);//使用Collections类中的sort方法对接收的list进行升序排序
for (Integer i:list ){
System.out.print(i+" ");//输出
}
return list;
}
}

10、 编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）
例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是"HM"而不要出现半个中文

package com.itheima;

import java.io.*;

/*第十题：编写函数，从一个字符串中按字节数截取一部分，但不能截取出半个中文（GBK码表）
例如：从“HM程序员”中截取2个字节是“HM”，截取4个则是“HM程”，截取3个字节也要是"HM"而不要出现半个中文

思路：要在字符串中按字符串截取一部分，先要将字符串转为字节形式，根据单汉字的字节为2的特点，
如果截取长度末尾正好在汉字的一个字节上，那么输出时汉字便会不完整，可以在字符串中将不完整汉字的一个字符截取掉，
便不会存在输出中文字符不完整的问题，可以输出完整的字符串
* */
class Test10{
public static void main(String[] args){
substr("HM程序员", 3);
}
public static void substr(String str , int l){//定义截取函数，参数为(字符串,截取字节长度)
String s = null; //定义字符串s初始化为空
if(str == null){
System.out.println("字符串为空");
}
else{
byte[] bt = null; //初始化字节数组bt为空
try {
bt = str.getBytes("GBK"); //将字符串使用GBK编码转化为字节数组
}
catch (UnsupportedEncodingException e){
e.printStackTrace();
}
if(bt.length <= l){
s = str;
}//若字节数组长度小于要求的截取字节长度,则字符串s仍为原字符串str
if(l > 0){
s = new String(bt, 0, l); //根据截取字节长度从字符数组中解码，生成新的字符串s。
int length = s.length(); //得到新字符串s长度
if(str.charAt(length - 1) != s.charAt(length-1)){//如果原字符串str和新字符串s中相应位置上的字符不相等，说明新字符串中相应位置上的字符不完整，将不完整的字符截取掉
if(length < 2){
s = null; //若新字符串长度小于2，且新字符串中末尾的字符不完整，则新字符串为空。
}
else{
s = s.substring(0, length-1); //把s的最后一位不完整的字符截掉，把完整字符串赋给s
}
}
}
System.out.println(s);//输出
}
}
}