-------、java培訓、期待與您交流！ ----------

黑馬程式設計師訓練營基礎測試題及個人程式碼（包含思路、步驟和基本註釋）

1、 編寫程式計算1²+2²+3²+....+100²的和.

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);//輸出
		}	
	}
}