Java常用类练习题

青旅半醒 2022-05-14 02:50 103阅读 0赞

1.键盘录入一个字符串，统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)

import java.util.Scanner;
    
    public class Test2 {
    
    	public static void main(String[] args) {
    //		1、键盘录入一个字符串，统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)
    //		String str = "asdBDGSf1243dSB";
    		//1.键盘录入一个字符串，包含大写小写和数字
    		Scanner sc = new Scanner(System.in);
    		System.out.print("录入一个字符串，包含大写小写和数字：");
    		String str = sc.next();
    		sc.close();
    		//2.定义三个统计变量
    		int upperCaseCount = 0;//大写字符的统计变量
    		String upperStr = "";
    		int lowerCaseCount = 0;//小写字符的统计变量
    		String lowerStr = "";
    		int digitCount = 0;//数字字符的统计变量
    		String digitStr = "";
    		//3.遍历字符串，获取每个字符
    		for(int i=0;i<str.length();i++){
    			char charAt = str.charAt(i);
    			//4.判断当前字符是大写，小写还是数字
    			//5.根据判断结果，让对应的统计变量+1
    			if(charAt>='A' && charAt<='Z'){//大写字符
    				upperCaseCount++;
    				upperStr+=charAt;
    			}
    			if(charAt>='a' && charAt<='z'){//小写字符
    				lowerCaseCount++;
    				lowerStr+=charAt;
    			}
    			if(charAt>='0' && charAt<='9'){//数字字符
    				digitCount++;
    				digitStr+=charAt;
    			}
    		}
    		//6.输出统计变量的结果
    		System.out.println(upperStr+"大写字母的个数是："+upperCaseCount);
    		System.out.println(lowerStr+"小写字母的个数是："+lowerCaseCount);
    		System.out.println(digitStr+"数字字符的个数是："+digitCount);
    	}
    }

2.键盘录入一个字符串，要求长度为8，不符合输出错误；符合条件，将字符串中所有大写字符替换成'M'

方式一：不使用正则

import java.util.Scanner;
    
    public class Test2 {
    
    	public static void main(String[] args) {
    //		2、输入字符串，替换所有的大写字母为“M”	
    		//1.键盘录入一个字符串，包含大写字母
    		Scanner sc = new Scanner(System.in);
    		System.out.print("请输入字符串");
    		String next = sc.next();
    		sc.close();
    		//2.定义新的字符串
    		String newStr = "";
    		//3.遍历字符串
    		for (int i = 0; i < next.length(); i++) {
    			//4.获取每个字符
    			char charAt = next.charAt(i);
    			//5.判断当前字符是否为大写
    			//6.如果是大写字母，将大写M拼接到新的字符串中，如果是其他字符，直接拼接到新的字符串中
    			if(charAt>='A' && charAt<='Z'){//大写字符
    				newStr+='M';
    			}else{
    				newStr+=charAt;
    			}
    		}
    		//7.输出新的字符串
    		System.out.println("next:"+next);
    		System.out.println("newStr:"+newStr);
    	}
    }

方式二：使用正则

import java.util.Scanner;
    
    public class Test4 {
    
    	public static void main(String[] args) {
    //		4、输入字符串，替换所有的大写字母为“M”	
    		//1.键盘录入一个字符串，包含大写字母
    		Scanner sc = new Scanner(System.in);
    		System.out.print("请输入字符串");
    		String next = sc.next();//asfgQ4etAER
    		sc.close();
    		//2.使用正则
    		String regex = "[A-Z]";
    		//3.调用字符串中替换的方法
    		String replaceAll = next.replaceAll(regex, "M");
    		//4.输出新的字符串
    		System.out.println("next:"+next);
    		System.out.println("replaceAll:"+replaceAll);
    	}
    }

3.模拟QQ登陆，输入账号与密码，如果账号与密码正确则显示登录成功，  
如果失败则重新登录，并显示登录错误几次，如果登录错误三次则程序结束登录失败。

public class Test3 {
    
    	public static void main(String[] args) {
    		// 3、模拟QQ登陆，输入账号与密码，如果账号是jiyun123，密码是123jiyun则显示登录成功，
    		// 如果不是则重新登录，并显示登录错误几次，如果登录错误三次则程序结束登录失败。
    		Scanner sc = new Scanner(System.in);
    		int count = 0;
    		while (true) {
    			count++;
    			// 1.键盘录入账号
    			System.out.print("请输入QQ账号：");
    			String zhangHao = sc.next();
    			// 2.键盘录入密码
    			System.out.print("请输入QQ密码：");
    			String miMa = sc.next();
    			// 3.判断账号和密码是否正确
    			if("jiyun123".equals(zhangHao) && "123jiyun".equals(miMa)){
    				// 4.如果正确，则登录成功
    				System.out.println("登录成功！");
    				break;
    			}else{
    				// 5.如果不正确，则重新登录，并显示登录错误几次
    				System.out.println("账号和密码不正确，请重新登录，当前登录错误"+count+"次");
    				// 6.如果登录错误三次，就结束程序，并登录失败
    				if(count==3){
    					System.out.println("登录错误三次，账号被锁定，程序结束！");
    					break;
    				}
    				
    			}
    		}
    		sc.close();//如果while循环是死循环，这行会报Unreachable code
    	}
    }

4.利用Scanner输入一个字符串，再利用Scanner输入一个字符，查找该字符在上述字符串中的位置，并输出该位置。

5.String str = "svd9876fsb543fdg210";将字符串中所有偶数转为int\[\] 数组，再对数组冒泡排序，最后使用Arrays输出数组。

public class Test1 {
    
    	public static void main(String[] args) {
    		// 1.String str = "svd9876fsb543fdg210";将字符串中所有偶数转为int[] 数组，
    		// 再对数组冒泡排序，最后使用Arrays输出数组。
    
    		String str = "svd9876fsb543fdg210";
    		StringBuilder sb = new StringBuilder();
    		// 1.遍历字符串，获取每个字符
    		for (int i = 0; i < str.length(); i++) {
    			char charAt = str.charAt(i);
    			// 2.判断当前字符是否为数字，
    			if (Character.isDigit(charAt)) {// 如果是数字
    				// 3.再判断该字符是否为偶数如果是偶数
    				// char--->String--->int
    				int parseInt = Integer.parseInt(String.valueOf(charAt));
    				if (parseInt % 2 == 0) {
    					// 保存起来
    					sb.append(parseInt);
    				}
    			}
    		}
    		System.out.println("sb:" + sb);
    		// 4.根据保存偶数数字的个数来创建int[]
    		int[] arr = new int[sb.length()];
    		for (int i = 0; i < sb.length(); i++) {
    			char charAt = sb.charAt(i);// 获取sb中下表为i的字符
    			// 将该字符转为int类型
    			int parseInt = Integer.parseInt(String.valueOf(charAt));
    			// 5.将存储的数字赋值给int[]
    			// 将该int类型的值赋值给数组下表为i的元素
    			arr[i] = parseInt;
    		}
    		System.out.println(Arrays.toString(arr));
    		// 6.冒泡
    		maoPao(arr);
    		// 7.输出
    		System.out.println(Arrays.toString(arr));
    
    	}
    
    	/**
    	 * 对数组冒泡排序
    	 * 
    	 * @param arr
    	 *            被排序的数组
    	 */
    	public static void maoPao(int[] arr) {
    		for (int i = 0; i < arr.length - 1; i++) {
    			for (int j = 0; j < arr.length - 1 - i; j++) {
    				if (arr[j] > arr[j + 1]) {
    					int temp = arr[j];
    					arr[j] = arr[j + 1];
    					arr[j + 1] = temp;
    				}
    			}
    		}
    	}
    }

6.利用Math类获取5个随整数范围在(15,30)，不能重复，放在数组中，冒泡排序后遍历输出。

import java.util.Arrays;
    
    public class Test7 {
    
    	public static void main(String[] args) {
    		// 7. 利用Math类获取5个随整数范围在(15,30)，不能重复，放在数组中，冒泡排序后遍历输出。
    
    		// 1.定义数组长度为5
    		int[] arr = new int[5];
    		// 2.循环产生随机数，并为数组赋值，赋值前先判断数组中是否包含此元素
    		for (int i = 0; i < arr.length; i++) {
    			// 循环产生随机数范围在(15,30)
    			int num = (int) (Math.random() * (30 - 15) + 15);
    			System.out.println(num);
    			// 赋值前先判断数组中是否包含此元素
    			if (contains(arr, num)) {
    				i--;// 包含的时候，需要从当前i再产生一个随机数,所以需要i--和循环控制语句中的i++中和
    			} else {
    				arr[i] = num;// 将元素赋值给数组
    			}
    		}
    		// 3.对数组冒泡排序
    		// Arrays.sort(arr);
    		maoPao(arr);// 调用冒泡方法对数组排序
    		// 4.输出数组
    		System.out.println(Arrays.toString(arr));
    	}
    
    	/**
    	 * 对数组进行冒泡
    	 * 
    	 * @param arr
    	 *            被冒泡的数组
    	 */
    	public static void maoPao(int[] arr) {
    		for (int i = 0; i < arr.length - 1; i++) {
    			for (int j = 0; j < arr.length - 1 - i; j++) {
    				if (arr[j] > arr[j + 1]) {
    					int temp = arr[j];
    					arr[j] = arr[j + 1];
    					arr[j + 1] = temp;
    				}
    			}
    		}
    	}
    
    	/**
    	 * 判断数组中是否包含有某个元素 思路：将该元素和数组中的每个元素比较， 如果有相等的，返回true，否则，最后返回false
    	 * 
    	 * @param arr
    	 *            数组
    	 * @param num
    	 *            元素
    	 */
    	public static boolean contains(int[] arr, int num) {
    		for (int i = 0; i < arr.length; i++) {
    			if (arr[i] == num) {// 如果有元素和num相等，返回true，代表数组中包含此num值
    				return true;
    			}
    		}
    		// for循环结束后，没有返回true，说明数组中没有此num值，那么就返回false，代表数组中没有此num
    		return false;
    	}
    }

7.键盘录入一个字符串，利用正则表达式判断是否是一个qq邮箱。  
8.将以下字符串按逗号分割，将得到的字符串数组转化为int数组，排序，遍历输出。  
字符串如下："120,11,32,135,234,91,18"

9.将由三个字符组成的单词输出，并统计个数： String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";

import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class PatternDemo {
    
    	public static void main(String[] args) {
    		//将由三个字符组成的单词输出,并统计个数
    		String s = "da jia ting wo shuo,jin tian yao xia yu,bu shang wan zi xi,gao xing bu?";
    		
    		//1.定义正则规则
    		String regex = "\\b\\w{3}\\b";
    		//2.将规则加入模式器
    		Pattern pattern = Pattern.compile(regex);
    		//3.通过模式器获取匹配器对象
    		Matcher matcher = pattern.matcher(s);
    		//4.通过匹配其对象的find()方法查找符合规则的内容
    		int count = 0;//统计变量
    		while(matcher.find()){
    			count++;
    			//5.通过匹配其对象的group()方法获取通过find()方法查找到的内容
    			System.out.println(matcher.group());
    		}
    		System.out.println("count:"+count);
    	}
    }

10.产生一个长度为15位的随机字符串：大写小写和数字，最后输出该随机字符串。

public class Test10 {
    
    	public static void main(String[] args) {
    		// 产生一个长度为15位的随机字符串：大写小写和数字，最后输出该随机字符串
    
    		// 1.定义StringBuiler，用于存储产生的随机字符
    		StringBuilder sb = new StringBuilder();
    		// 2.循环产生随机字符
    		for (int i = 0; i < 15; i++) {
    			//需要解决当前产生的字符应该是数字大写字母还是小写字母
    			int num = (int) (Math.random()*10000);
    			int result = num%3;//0 or 1 or 2
    			int chInt;
    			char ch;
    			switch (result) {
    			case 0://产生一个大写字符
    				chInt = (int) (Math.random()*(91-65)+65);
    				ch = (char) chInt;
    				// 6.将产生的字符添加到StringBuiler中
    				sb.append(ch);
    				break;
    			case 1://产生一个数字
    				// 4.中间5个字符,随机对应的数字[0,10)
    				chInt = (int) (Math.random()*10);
    				// 6.将产生的数字添加到StringBuiler中
    				sb.append(chInt);
    				break;
    			case 2://产生一个小写字符
    				// 5.后面5个字符随机产生小写字符,小写字母对应的数字[97,123)
    				chInt = (int) (Math.random()*(123-97)+97);
    				ch = (char) chInt;
    				// 6.将产生的字符添加到StringBuiler中
    				sb.append(ch);
    				break;
    			default:
    				break;
    			}
    		}
    		// 7.输出随机产生的字符串
    		System.out.println("sb:"+sb);
    	}
    }