?

程序32 左移右移

題目：取一個整數(shù)a從右端開始的4～7位。
分析：比如取123456789從右端開始的4～7位即：3456

?

 1 package test50;
 2 /*
 3  * 題目：取一個整數(shù)a從右端開始的4～7位。
 4  * 分析：比如取123456789從右端開始的4～7位即：6543
 5  */
 6 public class test32 {
 7 
 8     public static void main(String[] args) {
 9         long num=123456789;
10         quzhi(num);
11     }
12     
13     public static void quzhi(long number){
14         String s =Long.toString(number);//將Long型轉(zhuǎn)化成字符串
15         char[] arr=s.toCharArray();//將字符串轉(zhuǎn)化成數(shù)組
16         if(arr.length<7){
17             System.out.print("輸入整數(shù)不滿足條件");
18         }
19         for(int i=arr.length-4;i>=arr.length-7;i--){
20             System.out.print(arr[i] " ");
21         }
22     }
23 }

?

程序33 楊輝三角

題目：打印出楊輝三角形（要求打印出10行如下圖）

 1 package test50;
 2 /*
 3  * ％4d代表在4個空格內(nèi)打印數(shù)字。我們選擇4，因?yàn)槲覀冎?0行楊輝三角形的最大數(shù)字的最大位數(shù)是3位數(shù)。
 4  * System.out.format("$s: %s%n", "fefe","fwefrr");
 5    "$s: %s%n"的解釋：
 6    $s:表示輸出24個空格，s為替換的字符串
 7    %s：表示字符串，即替換的內(nèi)容
 8    %n：表示換行
 9  */
10 public class test33 {
11 
12     public static void main(String[] args) {
13         int rows = 10;
14         for(int i =0;i<rows;i  ) {
15             int number = 1;
16             //打印空格字符串
17             System.out.format("%" (rows-i)*2 "s","");
18             for(int j=0;j<=i;j  ) {//打印每一行得數(shù)字
19                 System.out.format("M",number);//打印當(dāng)前數(shù)字
20                 number = number * (i - j) / (j   1);//計(jì)算下一位數(shù)字
21                 }
22             System.out.println();//換行
23             }
24         }
25     }

?

?

程序34 三個數(shù)排序

略

程序35 最大最小交換

題目：輸入數(shù)組，最大的與第一個元素交換，最小的與最后一個元素交換，輸出數(shù)組。
分析: 例如輸入6 4 8 3 9 7
交換后輸出9 4 8 7 6 3

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 題目：輸入數(shù)組，最大的與第一個元素交換，最小的與最后一個元素交換，輸出數(shù)組。
 7  * 分析: 例如輸入6 4 8 3 9 7
 8  * 交換后輸出9 4 8 7 6 3
 9  */
10 public class test35 {
11     public static void main(String[] args) {
12         // TODO Auto-generated method stub
13         Scanner input=new Scanner(System.in);
14         System.out.println("請輸入數(shù)組元素個數(shù)：");
15         int num=input.nextInt();
16         System.out.print("請輸入數(shù)組：");
17         int[] arr=new int[num];
18         for(int i =0;i<num;i  ) {
19              arr[i]=input.nextInt();
20         }
21         input.close();
22         arrchange(arr);
23     }
24     
25     public static void arrchange(int[] arr){
26         int temp=0;
27         int max=arr[0]; int min=arr[0];
28         int maxIndex=0; int minIndex=0;
29         //找出原數(shù)組arr的最大值、最小值位置
30         for(int i =0;i<arr.length;i  ){
31             if(max<arr[i]){//找到數(shù)組的最大值索引
32                 max=arr[i];
33                 maxIndex=i;
34             }
35             if(min>arr[i]){//找到數(shù)組的最小值索引
36                 min=arr[i];
37                 minIndex=i;
38             }
39         }
40         if(arr[0]!=max){//如果最大值不是第一個
41             arr[maxIndex]=arr[0];
42             arr[0]=max;
43         }
44         if(arr[arr.length-1]!=min){//如果最小值不是最后一個
45             arr[minIndex]=arr[arr.length-1];
46             arr[arr.length-1]=min;
47         }
48         for(int k=0;k<arr.length;k  ){
49             System.out.print(arr[k] " ");
50         }
51     }
52     
53 }

?

程序36 移動位置

題目：有n個整數(shù)，使其前面各數(shù)順序向后移m個位置，最后m個數(shù)變成最前面的m個數(shù)
分析:比如有4個數(shù)n=4;
1 2 3 4
各個數(shù)向后移動2位m=2，變?yōu)?    1 2 3 4
將最后m個數(shù)，即將最后2個數(shù)變成前面的2個數(shù)變?yōu)?3 4 1 2

 1 package test50;
 2 /*
 3  * 題目：有n個整數(shù)，使其前面各數(shù)順序向后移m個位置，最后m個數(shù)變成最前面的m個數(shù)
 4  */
 5 import java.util.Scanner;
 6 public class test36 {
 7     public static void main(String[] args) {
 8         Scanner input = new Scanner(System.in);
 9         System.out.println("請輸入數(shù)組的長度：");//定義數(shù)組長度
10         int num = input.nextInt();
11         int [] arr = new int[num];
12         System.out.println("請輸入數(shù)組元素：");//鍵入數(shù)組元素
13         for (int i = 0; i < num; i  ) {
14             arr[i] = input.nextInt();
15         }
16         System.out.println("您輸入的數(shù)組是：");//打印數(shù)組
17         for (int j = 0; j < arr.length; j  ) {
18             System.out.print(arr[j]   " " );
19         }
20         System.out.println("請輸入移動的位數(shù)：");//獲取移動位數(shù)
21         int m = input.nextInt();
22         int [] arr2 = new int[num]; 
23         for (int k = 0; k < m; k  ) {//把向前移動的轉(zhuǎn)移進(jìn)新數(shù)組
24             arr2[k] = arr[num - m   k];
25         }
26         for (int k2 = 0; k2 < num - m; k2  ) {//把向后移的插入到新數(shù)組
27             arr2[m k2] = arr[k2];
28         }
29         System.out.println("移動后的數(shù)組為：");
30         for (int l = 0; l < arr2.length; l  ) {
31             System.out.println(arr2[l]);
32         }
33     }
34 }

?

?

程序37 報(bào)數(shù)*****

* 題目：有n個人圍成一圈，順序排號。
* 從第一個人開始報(bào)數(shù)（從1到3報(bào)數(shù)），凡報(bào)到3的人退出圈子，問最后留下的是原來第幾號的那位。
* 分析：最后留下的是第n號那位

 1 package test50;
 2 /*
 3  * 題目：有n個人圍成一圈，順序排號。
 4  * 從第一個人開始報(bào)數(shù)（從1到3報(bào)數(shù)），凡報(bào)到3的人退出圈子，問最后留下的是原來第幾號的那位。
 5  * 分析：最后留下的是第n號那位
 6  */
 7 
 8 import java.util.Scanner;
 9 public class test37 {
10     public static void main(String[] args) {
11         Scanner input = new Scanner(System.in);
12         System.out.println("請輸入總?cè)藬?shù)：");//定義數(shù)組長度
13         int num = input.nextInt();
14         //定義數(shù)組，用其中的元素標(biāo)記是否已經(jīng)被淘汰，0表示為被淘汰
15         int [] arr = new int[num];
16         for (int i = 0; i < num; i  ) {//初始化數(shù)組元素都是1
17             arr[i] = 1;
18         }
19         for (int i = 0; i < arr.length; i  ) {
20             System.out.println(arr[i]);
21         }
22         int index = 0;
23         int sum = 0;
24         while(num > 1 )//用來控制剩余的人數(shù)
25         {
26             if (arr[index] == 1) {  //第index位置有人報(bào)數(shù)，如果arr[index]！= 1，表示index位置的人已經(jīng)退出圈子
27                 sum  ;  //有人報(bào)數(shù)，sum就要加1
28                 if (sum == 3) {//如果是3，則重新記，從1開始
29                     sum = 0; 
30                     arr[index] = 0; 
31                     num-- ;//滿足3個，總?cè)藬?shù)就減1
32                 }
33             }
34         index   ;//指向下一個位置
35         if (index == arr.length) {//如果索引是數(shù)組的長度，則從0開始,（實(shí)際上，索引數(shù)最大為arr.length-1）
36             index = 0 ;//實(shí)際上實(shí)現(xiàn)了循環(huán)遍歷。如有人甲乙丙丁戊。當(dāng)index=4時，下一次索引就指向0，讓甲報(bào)數(shù)，而甲可能退出圈子，可能還在
37         }
38         }//while(num > 1 )結(jié)束
39         for (int i = 0; i < arr.length; i  ) {
40             System.out.println(arr[i]);
41         }
42         for (int i = 0; i < arr.length; i  ) {
43             if (arr[i] == 1) {
44                 System.out.println("第" (i 1) "留了下來");
45             }
46         }
47     }
48 }

?

?

?

程序38 求字符串長度

題目：寫一個函數(shù)，求一個字符串的長度，在main函數(shù)中輸入字符串，并輸出其長度。

 1 package test50;
 2 /*
 3  * 題目：寫一個函數(shù)，求一個字符串的長度，在main函數(shù)中輸入字符串，并輸出其長度。
 4  */
 5 
 6 import java.util.Scanner;
 7 public class test38 {
 8     public static void main(String[] args) {
 9         Scanner input = new Scanner(System.in);
10         System.out.println("請輸入一個字符串：");
11         String str = input.nextLine();
12         System.out.println("該字符串的長度是：" getArrLength(str));
13     }
14     public static int getArrLength(String str)
15     {
16         char[] charStr = str.toCharArray();
17         return charStr.length;
18     }
19 }

?

程序39 分?jǐn)?shù)累加

題目：編寫一個函數(shù)，輸入n為偶數(shù)時，調(diào)用函數(shù)求1/2 1/4 ... 1/n,當(dāng)輸入n為奇數(shù)時，調(diào)用函數(shù)1/1 1/3 ... 1/n

遞歸如何實(shí)現(xiàn)

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 編寫一個函數(shù)，輸入 n 為偶數(shù)時，調(diào)用函數(shù)求 1/2 1/4 ... 1/n,當(dāng)輸入 n 為奇數(shù)時，調(diào)用函數(shù) 1/1 1/3 ... 1/n
 7  */
 8 public class test39 {
 9 
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12         Scanner input = new Scanner(System.in);
13         System.out.println("請輸入一個數(shù)字：");
14         int num = input.nextInt();
15         double sum=0.0;
16         System.out.println(getsum(num,sum));
17         }
18     
19     public static double getsum(int number,double sum){
20         while(number>0){
21             sum =(double)1/number;
22             number=number-2;
23             getsum(number,sum);
24         }
25         return sum;
26    }
27         
28 
29 }

?

程序40

題目：根據(jù)字符串內(nèi)字符的ASCII碼值對字符串?dāng)?shù)組進(jìn)行排序。

 1 package test50;
 2 /*
 3  * 題目：根據(jù)字符串內(nèi)字符的ASCII碼值對字符串?dāng)?shù)組進(jìn)行排序。
 4 分析：字符串用ASCII碼比較大小，規(guī)則是：
 5 1、比較首字母的ASCII碼大小
 6 2、若是前面的字母相同，則比較之后的字母的ASCII碼值
 7 3、若是一個字符串從首字母開始包含另一個字符串，則認(rèn)為字符串長度較長的大；例 ：ab > a
 8 備注：Java中String類有一個compareTo方法，該方法返回一個int類型的數(shù)據(jù)。
 9 其比較規(guī)則是：拿出字符串的第一個字符與參數(shù)的第一個字符進(jìn)行比較，
10 如果兩者不等，比較結(jié)束，返回兩者的ascii差，即字符串的第一個字符減去參數(shù)的第一個字符的ascii碼值.
11 如果相等，則比較第二個字符，以此類推。比較到最后還是相等的，方法返回值為0。
12 比如下面的代碼：“abc”.compareTo(“cad”)==-2
13 這里有一點(diǎn)需要注意：如果兩個字符串的長度不同，并且一個字符串與另一個字符串的前面N個字符相等，那么這個方法返回返回兩個字符串長度之差。
14 比如下面的代碼：“fa”.compareTo(“f”)==1
15  */
16 
17 public class test40 {
18 
19     public static void main(String[] args) {
20         String[] str = {"abc","cad","m","fa","f"};
21         for(int i=str.length-1;i>=1;i--){
22             for(int j=0;j<=i-1;j  ){
23                 //注意compareTo函數(shù)在這里的作用
24                 if(str[j].compareTo(str[j 1])<0){
25                     String temp = str[j];
26                     str[j] = str[j 1];
27                     str[j 1] = temp;
28                 }
29             }
30         }
31         //此處使用了增強(qiáng)for循環(huán)遍歷數(shù)組元素
32         for(String subStr:str)//定義了一個String類型的變量接收遍歷后的數(shù)組元素
33             System.out.print(subStr " ");//將遍歷后的數(shù)組元素依次輸出
34     }
35 }

?

?

?

?

題目41：海灘上有一堆桃子，五只猴子來分。第一只猴子把這堆桃子憑據(jù)分為五份，多了一個，這只猴子把多的一個扔入海中，拿走了一份。
* 第二只猴子把剩下的桃子又平均分成五份，又多了一個，它同樣把多的一個扔入海中，拿走了一份，
* 第三、第四、第五只猴子都是這樣做的，問海灘上原來最少有多少個桃子？

采用遞歸

 1 public class Prog41 {
 2     public static void main(String[] args) {
 3         //第一只猴子分桃時,調(diào)用函數(shù)fun(1)求得桃數(shù)
 4         System.out.println("最初海灘上共有" fun(1) "個桃子");
 5     }
 6     //遞歸函數(shù)
 7     public static int fun(int i) {
 8         if(i==5) {
 9             return 6;//輪到第五只猴子分桃時，至少得6個桃
10         }else {
11             return fun(i 1)*5 1;
12         }
13     }
14 }
15 /*運(yùn)行結(jié)果
16 最初海灘上共有3906個桃子
17 */

?

冒泡

 1 package test50;
 2 /*
 3  * 題目：海灘上有一堆桃子，五只猴子來分。第一只猴子把這堆桃子憑據(jù)分為五份，多了一個，這只猴子把多的一個扔入海中，拿走了一份。
 4  * 第二只猴子把剩下的桃子又平均分成五份，又多了一個，它同樣把多的一個扔入海中，拿走了一份，
 5  * 第三、第四、第五只猴子都是這樣做的，問海灘上原來最少有多少個桃子？
 6  * 分析：求最少的桃子數(shù)，則第五個猴子分桃時，手上一共有6個桃
 7  * 利用遞歸法可求得最初的桃數(shù)
 8  */
 9 public class test41 {
10 
11     public static void main(String[] args) {
12         // TODO Auto-generated method stub
13         int sum5=6;//求最少的桃子數(shù)，則第五個猴子分桃時，手上一共有6個桃
14         System.out.print("海灘上原來最少有多少個桃子:" getsum(sum5));
15 
16     }
17     public static int getsum(int sum){
18         for(int i=4;i>=1;i--){
19             sum=sum*5 1;
20         }
21         return sum;
22     }
23 
24 }

?

題目42：809*??=800*?? 9*?? 1其中??代表兩位數(shù)，若有這樣得數(shù)，求??代表的兩位數(shù)

 1 package test50;
 2 /*
 3  * 809*??=800*?? 9*?? 1其中??代表兩位數(shù)，若有這樣得數(shù)，求??代表的兩位數(shù)
 4  */
 5 public class test42 {
 6 
 7     public static void main(String[] args) {
 8         // TODO Auto-generated method stub
 9         boolean  flag=false;
10         int n=0;
11         for(int i=10;i<=99;i  ){
12             if(809*i==800*i 9*i 1){
13                 flag=true;
14                 n=i;
15                 break;
16                 }
17             }
18         if(flag){
19             System.out.print("有這樣得數(shù):" n);
20         }else 
21             System.out.print("不存在這樣得數(shù)");
22 
23     }
24 
25 }

?

題目43：求0—7所能組成的奇數(shù)個數(shù),奇數(shù)中不包含重復(fù)數(shù)字。

 1 package test50;
 2 /*
 3  * 題目：求0—7所能組成的奇數(shù)個數(shù),奇數(shù)中不包含重復(fù)數(shù)字。
 4  */
 5 public class test43 {
 6     public static void main(String[] args) {
 7         //0-7能組成的所有不重復(fù)的數(shù)的最大值是76543210
 8         //0-76543210中所有的奇數(shù)個數(shù)為76543210/2
 9         String[] s=new String[76543210/2];//定義一個字符串?dāng)?shù)組存儲0-7能組成的所有奇數(shù)
10         int n=0;//定義一個變量為滿足條件的奇數(shù)計(jì)數(shù)
11         int count=0;
12         //將所有奇數(shù)轉(zhuǎn)換成字符串存入字符串?dāng)?shù)組s中
13         for(int i=1;i<=76543210;i  ) {
14             if((i 1)%2==0) {
15                 s[n]=String.valueOf(i);
16                 n  ;
17             }
18         }
19         //將所有的字符串?dāng)?shù)組中的元素取出分別存入一個字符數(shù)組c中
20         for(int j=0;j<n;j  ) {
21             char[] c= s[j].toCharArray();
22             outer:for(int k=0;k<c.length;k  ) {
23                 for(int m=1;m<c.length;m  ) {
24                     if(c[k]==c[m]) {//將字符數(shù)組中的每個元素取出，一旦發(fā)現(xiàn)重復(fù)值退出循環(huán)
25                         break outer;//一個break語句只能跳出一個for循環(huán),因此這里使用 break outer,跳到28行
26                     }
27                 }
28                 count  ;//若該字符數(shù)組中不存在重復(fù)的元素，則該奇數(shù)為滿足條件的奇數(shù)
29             }
30         }
31         System.out.println("0-7所能組成的不包含重復(fù)數(shù)字的奇數(shù)個數(shù)共有：" count "個");
32     }
33 }
34 /*運(yùn)行結(jié)果
35 0-7所能組成的不包含重復(fù)數(shù)字的奇數(shù)個數(shù)共有：18567220個
36 */

?

題目44：一個偶數(shù)總能表示為兩個素?cái)?shù)之和。

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 題目：一個偶數(shù)總能表示為兩個素?cái)?shù)之和。
 7  * 分析：一個偶數(shù)可能會有不止一對兩個素?cái)?shù)之和的情況
 8  * 例如：20=3 17 20=7 13
 9 
10  */
11 public class test44 {
12 
13     public static void main(String[] args) {
14         // TODO Auto-generated method stub
15         Scanner input=new Scanner(System.in);
16         System.out.print("請輸入一個偶數(shù)num：");
17         int num=input.nextInt();
18         if(num%2!=0){
19             System.out.print("輸入的數(shù)不是偶數(shù)");
20             return;
21         }
22         for(int i=2;i<num;i  ){
23             if(isPrimeNumber(i) && isPrimeNumber(num-i)){
24                 System.out.println(num "=" i " " (num-i));
25             }
26         }
27 
28     }
29     
30     public static boolean isPrimeNumber(int n){
31         if(n < 2) return false;; 
32         for(int i=2;i<=n/2;i  ){
33             if(n%i==0){
34                 return false;//不是素?cái)?shù)
35             }
36         }
37         return true;
38     }
39 
40 }

?

?

題目45：判斷一個素?cái)?shù)能被幾個9整除
分析：素?cái)?shù)只能被1和其本身整除，不能被9整除，所以返回false

 1 import java.util.Scanner;
 2 public class Prog45{
 3     public static void main(String[] args){
 4         System.out.print("請輸入一個素?cái)?shù)：");
 5         Scanner scan = new Scanner(System.in);
 6         int n=scan.nextInt();
 7         if(!isPrime(n)) {
 8             System.out.println("你輸入的不是素?cái)?shù)，請重新輸入");
 9             n=scan.nextInt();
10         }
11         scan.close();
12         System.out.println("素?cái)?shù)" n "能被9整除嗎？" zhengchu(n));
13     }
14     //判斷素?cái)?shù)是否能被9整除
15     private static boolean zhengchu(int n) {
16         return n%9==0;
17     }
18     //判斷輸入的數(shù)是否是素?cái)?shù)
19     private static boolean isPrime(int n){
20         boolean flag = true;
21         for(int i=2;i<Math.sqrt(n) 1;i  ){
22             if(n%i==0){
23                 flag = false;
24                 break;
25             }
26         }
27         return flag;
28     }
29 }
30 /*運(yùn)行結(jié)果
31 請輸入一個素?cái)?shù)：11
32 素?cái)?shù)11能被9整除嗎？false
33 */

?

程序46 字符串連接*

題目：編寫一個兩個字符串連接的程序

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 題目：編寫一個兩個字符串連接的程序
 7  */
 8 public class test46 {
 9      public static void main(String[] args){
10          Scanner input=new Scanner(System.in);
11          System.out.print("輸入2個字符串：");
12          String s1=input.nextLine();
13          String s2=input.nextLine();
14          input.close();
15          String s3=s1 s2;
16          System.out.print("連接后的字符串：" s3);
17         
18      }

?

程序47 輸入數(shù)字打印星號

題目：讀取7個數(shù)（1—50）的整數(shù)值，每讀取一個值，程序打印出該值個數(shù)的＊。

?

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 題目：讀取7個數(shù)（1—50）的整數(shù)值，每讀取一個值，程序打印出該值個數(shù)的＊。
 7  */
 8 public class test47 {
 9     public static void main(String[] args){
10          System.out.print("請輸入7個整數(shù)(1-50)：");
11          Scanner scan = new Scanner(System.in);
12          int n1 = scan.nextInt();
13          int n2 = scan.nextInt();
14          int n3 = scan.nextInt();
15          int n4 = scan.nextInt();
16          int n5 = scan.nextInt();
17          int n6 = scan.nextInt();
18          int n7 = scan.nextInt();
19          scan.close();
20          printStar(n1);
21          printStar(n2);
22          printStar(n3);
23          printStar(n4);
24          printStar(n5);
25          printStar(n6);
26          printStar(n7);
27     }
28     static void printStar(int m){
29         System.out.println(m);
30         for(int i=0;i<m;i  )
31             System.out.print("*");
32         System.out.println();
33     }
34 
35 
36 }

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /**
 6  * @author VellBibi
 7  *【程序47】 TestPrint.java
 8  *題目：讀取7個數(shù)（1—50）的整數(shù)值，每讀取一個值，程序打印出該值個數(shù)的＊。
 9  */
10 public class TestPrint {
11 
12     public static void main(String[] args) {
13         Scanner s = new Scanner(System.in);
14         int[] a = new int[7];
15         for(int i=0; i<7; i  ){
16             System.out.print("輸入第" (i 1) "個整數(shù)：");
17             a[i] = s.nextInt();
18         }
19         
20         for(int i=0; i<7; i  ){
21             for(int j=0; j<a[i]; j  ){
22                 System.out.print("*");
23             }
24             System.out.println();
25         }
26     }
27 
28 }

?

程序48 數(shù)字加密

題目：某個公司采用公用電話傳遞數(shù)據(jù)，數(shù)據(jù)是四位的整數(shù)，在傳遞過程中是加密的，
加密規(guī)則如下：每位數(shù)字都加上5,然后用和除以10的余數(shù)代替該數(shù)字，再將第一位和第四位交換，第二位和第三位交換。
分析：例如原始數(shù)據(jù)是： 6 7 8 9（原始數(shù)據(jù)）
每個數(shù)加上5后為：11 12 13 14
除以10后為： 1 2 3 4
交換位置之后 4 3 2 1（加密后的數(shù)據(jù)）

 1 package test50;
 2 
 3 import java.util.Scanner;
 4 
 5 /*
 6  * 題目：某個公司采用公用電話傳遞數(shù)據(jù)，數(shù)據(jù)是四位的整數(shù)，在傳遞過程中是加密的，
 7  * 加密規(guī)則如下：每位數(shù)字都加上5,然后用和除以10的余數(shù)代替該數(shù)字，再將第一位和第四位交換，第二位和第三位交換。
 8  * 分析：例如原始數(shù)據(jù)是： 6 7 8 9（原始數(shù)據(jù)）
 9  * 每個數(shù)加上5后為：11 12 13 14
10  * 除以10后為： 1 2 3 4
11  * 交換位置之后 4 3 2 1（加密后的數(shù)據(jù)）
12  */
13 public class test48 {
14 
15     public static void main(String[] args) {
16         // TODO Auto-generated method stub
17         int temp=0;
18          System.out.println("請輸入0到9間的4個整數(shù):");
19          Scanner scan = new Scanner(System.in);
20          int[] arr=new int[4];
21          for(int i=0;i<=3;i  ){
22              arr[i]=scan.nextInt();
23          }
24          scan.close();
25          for(int i=0;i<=3;i  ){
26              arr[i]=(arr[i] 5);
27          }
28          //將第一位和第四位交換
29          temp=arr[0];
30          arr[0]=arr[3];
31          arr[3]=temp;
32          //第二位和第三位交換
33          temp=arr[2];
34          arr[2]=arr[1];
35          arr[1]=temp;
36          
37          for(int i=0;i<=3;i  ){
38              System.out.print(arr[i] " ");
39          }
40     }
41 
42 }

?

?

?

程序49 子串出現(xiàn)的個數(shù)

題目：計(jì)算首末不含空格各個子串之間只含一個空格的字符串中子串出現(xiàn)的次數(shù)
分析：例如輸入的字符串為"I come from County DingYuan Province AnHui."
空格隔斷的即為字符子串，所以上述字符串的子串個數(shù)有7個

?

 1 package test50;
 2 /*
 3  * 題目：計(jì)算首末不含空格各個子串之間只含一個空格的字符串中子串出現(xiàn)的次數(shù)
 4  * 分析：例如輸入的字符串為"I come from County DingYuan Province AnHui."
 5  * 空格隔斷的即為字符子串，所以上述字符串的子串個數(shù)有7個
 6  */
 7 public class test49{
 8     public static void main(String[] args){
 9         String str="I come from County DingYuan Province AnHui.";
10         int count=0;
11         char[] ch=str.toCharArray();//將字符串轉(zhuǎn)換成字符數(shù)組
12         for(int i=0;i<ch.length;i  ) {
13             if(ch[i]==' ')//計(jì)算字符串中的空格個數(shù)
14                 count  ;
15         }
16         count  ;//字符串中子串的個數(shù)=空格數(shù) 1
17         System.out.println("共有" count "個字符子串");
18     }
19 }
20 /*運(yùn)行結(jié)果
21 共有7個字符子串
22 */

思路：轉(zhuǎn)換成數(shù)組，利用

?if(ch[i]==' ')

計(jì)算空格數(shù)

?

程序50 文件IO

題目：有五個學(xué)生，每個學(xué)生有3門課的成績，從鍵盤輸入以上數(shù)據(jù)（包括學(xué)生號，姓名，三門課成績），計(jì)算出平均成績，將原有的數(shù)據(jù)和計(jì)算出的平均分?jǐn)?shù)存放在磁盤文件"stud"中。

 1 package test50;
 2 
 3 import java.io.*;
 4 public class test50{
 5     //定義學(xué)生模型
 6     String[] number = new String[5];
 7     String[] name = new String[5];
 8     float[][] grade = new float[5][3];
 9     float[] sum = new float[5];
10     public static void main(String[] args) throws Exception{
11         test50 stud = new test50();
12         stud.input();
13         stud.output();
14     }
15     //輸入學(xué)號、姓名、成績
16     void input() throws IOException{
17         BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
18         //錄入狀態(tài)標(biāo)識
19         boolean isRecord = true;
20         while(isRecord){
21             try{
22                 for(int i=0;i<5;i  ){
23                     System.out.print("請輸入學(xué)號：");
24                     number[i] = br.readLine();
25                     System.out.print("請輸入姓名：");
26                     name[i] = br.readLine();
27                     for(int j=0;j<3;j  ){
28                         System.out.print("請輸入第" (j 1) "門課成績：");
29                         grade[i][j] = Integer.parseInt(br.readLine());
30                     }
31                     System.out.println();
32                     sum[i] = grade[i][0] grade[i][1] grade[i][2];
33                 }
34                 isRecord = false;
35             }catch(NumberFormatException e){
36                 System.out.println("請輸入一個數(shù)字！");
37             }
38         }
39     }
40     //輸出文件
41     void output() throws IOException{
42         FileWriter fw = new FileWriter("D:\\JavaEE\\Code\\Java基礎(chǔ)50道經(jīng)典練習(xí)題\\src//stud.txt");
43         BufferedWriter bw = new BufferedWriter(fw);
44         bw.write("No.  " "Name  " "grade1  " "grade2  " "grade3  " "average");
45         bw.newLine();
46         for(int i=0;i<5;i  ){
47             bw.write(number[i]);
48             bw.write("  " name[i]);
49             for(int j=0;j<3;j  )
50                 bw.write("  " grade[i][j]);
51             bw.write("  " (sum[i]/5));
52             bw.newLine();
53         }
54         bw.close();
55     }
56 }

?