Java实验（二）

版权声明：本文为Trinity原创文章，未经Trinity允许不得转载 https://blog.csdn.net/Caoyang_He/article/details/83450830

(1)创建一个类(DoubleConverter)，该类的作用是将一个字符串的值转换成浮点型(double)数值。
要求：设计一个测试类来测试DoubleConverter。当测试类开始运行时，要求用户从键盘输入一个字符串，然后调用DoubleConverter的方法将字符串转换成为一个浮点型的数值。当用户输入的字符串不是浮点数时，该方法应该提示错误，并退出程序；否则返回该数值。
提示：把这两个类放在包内。不能使用Java内置的Integer类和Scanner类，而必须使用String类的charAt等方法提取每一个数字。

DoubleConverterd.java

package test2;

import java.util.*;

//public class DoubleConverterd {
//	public void DoubleConverterd(String snumber)
//	{
//		double number = 0.0;
//		double temp = 0.0 ;
//		int j = 0;
//		boolean flag= true ;
//		for(int i = 0;i < snumber.length();i++)
//		{
//			if('0' <= snumber.charAt(i) && snumber.charAt(i) <= '9')
//			{
//				temp = snumber.charAt(i) - '0' ;
//				number = number * 10.0;
//				number = number + temp;
//			}else if(snumber.charAt(i) ==  '.' && flag)
//			{
//				j=i;
//				flag=false;
//			}
//			else 
//			{
//				System.out.println("Eorror");
//				System.exit(0);
//			}
//		}
//		for(int i = 1; i < snumber.length()-j;i++ )
//		{
//			number = number / 10 ;
//		}
//		System.out.println(number);
//	}
//}
//上面的结果精确度不够

import java.math.*;
public class DoubleConverterd {
	public void DoubleConverterd(String snumber)
	{
		double number = 0.0;
		double temp = 0.0 ;
		int j = 0;
		boolean flag= true ;
		for(int i = 0;i < snumber.length();i++)
		{
			if('0' <= snumber.charAt(i) && snumber.charAt(i) <= '9')
			{
				temp = snumber.charAt(i) - '0' ;
				number = ArithUtil.mul(number, 10);
				number = ArithUtil.add(number, temp);
			}else if(snumber.charAt(i) ==  '.' && flag)
			{
				j=i;
				flag=false;
			}
			else 
			{
				System.out.println("Eorror");
				System.exit(0);
			}
		}
		for(int i = 1; i < snumber.length()-j;i++ )
		{
			number = ArithUtil.div(number, 10);
		}
		System.out.println(number);
	}
}


class ArithUtil{
	private static final int DEF_DIV_SCALE=10;
	
	private ArithUtil(){}
	
	public static double add(double d1,double d2){
		BigDecimal b1=new BigDecimal(Double.toString(d1));
		BigDecimal b2=new BigDecimal(Double.toString(d2));
		return b1.add(b2).doubleValue();
		
	}
	
	public static double sub(double d1,double d2){
		BigDecimal b1=new BigDecimal(Double.toString(d1));
		BigDecimal b2=new BigDecimal(Double.toString(d2));
		return b1.subtract(b2).doubleValue();
		
	}
	
	public static double mul(double d1,double d2){
		BigDecimal b1=new BigDecimal(Double.toString(d1));
		BigDecimal b2=new BigDecimal(Double.toString(d2));
		return b1.multiply(b2).doubleValue();
		
	}
	
	public static double div(double d1,double d2){
 
		return div(d1,d2,DEF_DIV_SCALE);
		
	}
	
	public static double div(double d1,double d2,int scale){
		if(scale<0){
			throw new IllegalArgumentException("The scale must be a positive integer or zero");
		}
		BigDecimal b1=new BigDecimal(Double.toString(d1));
		BigDecimal b2=new BigDecimal(Double.toString(d2));
		return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
		
	}
	
}

testDoubleConverterd.java

package test2;

import java.util.*;

public class testDoubleConverterd {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println("please input your double");
		Scanner input = new Scanner(System.in);
		String number = input.nextLine(); 
		new DoubleConverterd().DoubleConverterd(number);
	}

}

(2)编写一个Java程序，将用户输入的句子当中每一个单词的第一个字母大写，而单词中的其余字母小写。
要求：程序运行后要求用户输入一个句子。然后提取每一个单词，并将单词的首字母转换成大写，其余字符小写。使用StringBuffer类来创建替换过大小写的新字符串。最后输出新字符串。
提示：需要使用Scanner的nextLine()方法来获取一个句子。注意：单词的分割符除了空格之外，还可能有Tab或者（,;.等标点符号）。注意判断首字符是不是字母。单词中的其他字母可能为大写。
例如：当用户输入”This is a samPLe sentencE to demostrATE the TasK 2.”
程序应该输出：This Is A Sample Sentence To Demonstrate The Task 2.
CaseConverter.java

package test2;

public class CaseConverter {
	
	public static String[] words = new String[20];
	public static String convert(String value) {
		StringBuffer upAfter = new StringBuffer(value.length());
		char aCharacter;
		//将tab , ; .等标点符号替换成空格
		value = value.replaceAll("[\\pP‘’“”]", " ");
		words = value.split(" ");
		for (int i = 0;i < words.length; i++)
		{
			for(int j = 0;j < words[i].length(); j++) {
				aCharacter = words[i].charAt(j);
				if (j==0) {
					//判断是不是字母
					if(Character.isLetter(aCharacter)) {
						upAfter.append(Character.toUpperCase(aCharacter));
					}
					else {
						upAfter.append(words[i].charAt(j));
					}
				}
				else {
					//如果该字符是字母切是大写字母，则转小写，否则直接连接
					if(Character.isLetter(aCharacter) && Character.isUpperCase(aCharacter)) { 
			                upAfter.append(Character.toLowerCase(aCharacter)); 
					}
					else {
						upAfter.append(words[i].charAt(j));
					}
				}
			}
			upAfter.append(" ");
		}
		return new String(upAfter);
	}
}

TestStringEditor.java

package test2;

import java.util.Scanner;

public class TestStringEditor {
 
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		Scanner scan = new Scanner(System.in);
		System.out.println("Input your string:");
		String inputString = scan.nextLine();
		scan.close();
		System.out.println("Your string after change:" + CaseConverter.convert(inputString));
		
	}
 
}

(3)编写一个猜成语的小游戏。
要求：使用一个字符串数组来保存10个四字成语，例如：
String [] idioms = {“凉拌黄瓜”, “红烧肘子”, …};
使用一个字符数组来保存20个无关字符，例如：
String [] chars = {‘吃’, ‘喝’, ‘胡’, …};
每次游戏开始时，随机选择一个成语，然后提取其中的4个汉字，再从字符数组中随机选择另外6个汉字，组成一个10个汉字的数组（汉字顺序随机）。注意！如果成语中，有重复的汉字，则只算一个，那么要从字符数组中多选出汉字。然后提示用户成语中包含这10个汉字，让用户猜测成语，用户输入汉字的编号，程序反馈汉字在成语中的位置。用户只有6次猜错机会，当6次机会用完后，游戏结束（猜对不占用次数）。当用户完全猜测出成语后，程序输出用户猜错的次数。
提示：使用java.util.Random类产生随机数。使用方法如下（具体方法请参见Java API文档）：
Random random = new Random(1000); //参数表示随机数种子
int index = random.nextInt(10); //产生[0,10)之间的随机整数
游戏过程如下：
第一次：
四字成语中包含的汉字如下：
1.王; 2.中; 3.力; 4.习; 5.努; 6.可; 7.时; 8.学; 9.我; 10.成;
[○○○○]
剩余猜测次数为6次，请输入你的猜测：1
对不起，“王”字不在成语中，剩余猜测次数为5次，请再次输入你的猜测：2
对不起，“中”字不在成语中，剩余猜测次数为4次，请再次输入你的猜测：8
[○○学○]
恭喜你，“学”字在成语中的位置是：3
剩余猜测次数为4次，请再次输入你的猜测：9
对不起，“我”字不在成语中，剩余猜测次数为3次，请再次输入你的猜测：9
对不起，“我”字你已经猜过了，剩余猜测次数为2次，请再次输入你的猜测：5
[努○学○]
恭喜你，“努”字在成语中的位置是：1
剩余猜测次数为2次，请再次输入你的猜测：6
对不起，“可”字不在成语中，剩余猜测次数为1次，请再次输入你的猜测：10
对不起，“成”字不在成语中，并且你已经Game Over了！

第二次（假设还是同样的成语）：
四字成语中包含的汉字如下：
1.王; 2.中; 3.力; 4.习; 5.努; 6.可; 7.时; 8.学; 9.我; 10.成;
[○○○○]
剩余猜测次数为6次，请输入你的猜测：1
对不起，“王”字不在成语中，剩余猜测次数为5次，请再次输入你的猜测：8
[○○学○]
恭喜你，“学”字在成语中的位置是：3
剩余猜测次数为5次，请再次输入你的猜测：9
对不起，“我”字不在成语中，剩余猜测次数为4次，请再次输入你的猜测：5
[努○学○]
恭喜你，“努”字在成语中的位置是：1
剩余猜测次数为4次，请再次输入你的猜测：3
[努力学○]
恭喜你，“力”字在成语中的位置是：2
剩余猜测次数为4次，请再次输入你的猜测：4
[努力学习]
恭喜你，“习”字在成语中的位置是：4
太棒了！你一共猜错了2次，已经猜出了整个成语！
GuessIdiomGame.java

package test2;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Random;
import java.util.Scanner;

public class GuessIdiomGame {
	
	private static String[] idioms= {"凉拌黄瓜","开开心心","努力学习","未来可期","不由自主","一事无成","百日做梦","先入为主","青山绿水","东山再起"};
	private static String[] chars = {"吃","喝","胡","朱","龙","老","居","宇","化","放"};
	private static String str = "[○○○○]";
	private static Map<Character, Integer> idiomNumsMap = new HashMap<Character,Integer>();//统计成语字符类型个数
	
	public static void main(String[] args) {
		
		 int count = 6;           //剩余猜测次数
		 boolean flag = false;
		 int num = 0;
		 int tcount =0 ;     //记录猜对次数
		 int fcount = 0;    //记录猜错次数
		 char[] t= str.toCharArray();
		List<Integer> listNum = new ArrayList<Integer>();
		Map<Character, Integer> cMap = new HashMap<Character,Integer>();//统计猜对词的个数
		
		Random random = new Random();
		int index = random.nextInt(10);  //产生[0,10)之间的随机整数
		String idiom = idioms[index];
    	String s = randomSort(idiom);
    	
    	System.out.println("猜测的成语："+idiom);
		System.out.println("四字成语中包含的汉字如下:");
		for(int i=0;i<s.length();i++) {
			System.out.print(i+1+"."+s.charAt(i)+";");
		}
		System.out.println();
		System.out.println(str);	
	
		Scanner in = new Scanner(System.in);
		System.out.println("剩余猜测次数为"+count+"次,请输入你的猜测:");
		
		while(true) {	
			num= in.nextInt();		
			if(num<1 ||num >10) {
				count--;
				if(count!=0) {
					System.out.println("要求输入数字在1~10,剩余猜测次数为"+count+"次，请再次输入你的猜测");
				}else {
					System.out.println("要求输入数字在1~10,并且你已经Game Over了");
					break;
				}
				continue;
			}
			char ss = s.charAt(num-1);       //选中的字符
			if(idiom.indexOf(ss)!=-1 && (cMap.get(ss)==null ||cMap.get(ss) < idiomNumsMap.get(ss))) {
				//猜中其中一个词
				int index2 = 0;
				if(cMap.get(ss)==null|| cMap.get(ss)>1 ) {
					 index2 = idiom.indexOf(ss);
					t[index2+1]=ss;
				}else {
					index2=idiom.lastIndexOf(ss);
					t[index2+1]=ss;
				}
			
				System.out.println(t);
				System.out.println("恭喜你，"+"“"+ss+"”"+"字在成语中的位置是："+(index2+1));
				tcount++;
				
				if(tcount!=4) {
					System.out.println("剩余猜测次数为"+count+"次,请再次输入你的猜测:");
				}
			
				if(cMap.get(ss)!=null) {//统计猜对词的个数
					cMap.put(ss, cMap.get(ss)+1);
				}else {
					cMap.put(ss, 1);
				}
			}else if(idiom.indexOf(ss) == -1 && !listNum.contains(num)){
				//没有猜中
				count--;
				if(count!=0) {
					System.out.println("对不起，“"+ss+"”字不在成语中，剩余猜测次数为"+count+"次"+",请再次输入你的猜测:");		
				}else {
					System.out.println("对不起，“"+ss+"”字不在成语中，并且你已经Game Over了");
					break;
				}
				
			}else {
				//重复猜测
				count--;
				if(count==0) {
					System.out.println("对不起，“"+ss+"”字你已经猜过了，并且你已经Game Over了");
					break;
				}else {
					System.out.println("对不起，“"+ss+"”字你已经猜过了，剩余猜测次数为"+count+"次"+",请再次输入你的猜测:");
				}
				
			}
			if(tcount==4 && count!=0) {
				System.out.println("太棒了！你一共猜错了"+(6-count)+"次，已经猜出了整个成语！");
				break;
			}
			listNum.add(num);
		}
	}
	
	public static String randomSort(String idiom) {
		List<String> sList = new ArrayList<String >();
		List<String> rList = new ArrayList<String>();
		List<Integer> list = new ArrayList<Integer>();
		List<String> nList = new ArrayList<String>();
		String string ="";
		int num=0;
		int randSeq = -1;
	
		idiomNumsMap = idiomNum(idiom);
		for(String str:chars) {
			sList.add(str);
		}

		for(int i=0;i<10-idiomNumsMap.size();i++) {
			Random random = new Random();
			 randSeq = random.nextInt(sList.size());  //产生[0,10)之间的随机整数
		    rList.add(sList.get(randSeq));
		    sList.remove(randSeq);
		}

		for(Map.Entry entry:idiomNumsMap.entrySet()) {
		       do {
		    	   Random random = new Random();
					 randSeq = random.nextInt(rList.size());  //产生[0,10)之间的随机整数
		       }while(list.contains(randSeq));
		        rList.add(randSeq, entry.getKey()+"");
				num++;
				list.add(randSeq);
		}


		for(int i=0;i<rList.size();i++) {
			string +=rList.get(i);
		}
		return string;
	}
	
/**
 * 统计字符串中字符类型的个数
 * @param str
 * @return
 */
 public static Map<Character, Integer> idiomNum(String str){
	  Map<Character, Integer> result = new HashMap<Character,Integer>();
	  for(int i=0;i<str.length();i++) {
		  char ch = str.charAt(i);
		  if(result.get(ch)!=null) {
			  result.put(ch, result.get(ch)+1);
		  }else {
			  result.put(ch, 1);
		  }
	  }
	  
	  return result; 
 }

}