我是靠谱客的博主 聪明白羊,最近开发中收集的这篇文章主要介绍十道String题目String类相关练习,觉得挺不错的,现在分享给大家,希望可以做个参考。

概述

String类相关练习

第一题:

分析以下需求,并用代码实现
键盘录入一个字符串,要求删除该字符串中的所有java字符串(最终的字符串中不能包含java),要求打印删除后的结果以及删除了几个java字符串
比如键盘录入: java woaijava,i like jajavava i enjoy java
程序输出结果:原字符串 woai,i like i enjoy 中总共包含:5 个 java 删除java后的字符串为: woai,i like i enjoy

public class Exercises01 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入需要处理的字符串:");
String str1 = scanner.nextLine();//获取用户输入的字符串
System.out.println("请输入需要删除的字符串:");
String str2 = scanner.nextLine();
int count = 0;//计数器
//判断字符串str1中是否有字符串str2
//循环遍历,确定处理后的str1中没有出现字符串str2
while(str1.contains(str2)){
str1 = str1.replaceFirst(str2,"");
count++;
}
System.out.println("原字符串中总共包含"+count+" 个" + str2 + ", 删除"+str2+"后的字符串为:"+str1);
}
}
/**
* 知识点1
*
* nextLine()方法返回的是Enter键之前的所有字符,它是可以得到带空格的字符串的。
*
* next()会自动消去有效字符前的空格键、Tab键或Enter,只返回输入的字符,不能得到带空格的字符串。输入有效字符之后,
* 将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符,但是这些符号仍然在缓冲区内,如果紧接着使用nextLine(),
* 那么nextLine()自动读取了被next()去掉的Enter作为他的结束符,所以没办法从键盘输入值。
*
* 经过验证,其他的next的方法,如nextDouble() ,nextFloat() ,nextInt() 等与nextLine()连用时都存在这个问题。
*/
/**
* 知识点2
*
* String字符串常量
* String的值是不可变的,这就导致每次对String的操作都会生成新的String对象,这样不仅效率低下,而且大量浪费有限的内存空间。
*
* StringBuffer与StringBuilder是字符串变量
* StringBuffer 和 StringBuilder 类的对象能够被多次的修改,并且不产生新的未使用对象
*
*/

第二题:

创建一个一维数组arr(String类型),里面元素有{“a”,”s”,”d”,”f”,”a”,”a”,”d”,”2”,”3”,”8”},根据里面的元素随机生成一个长度为5的字符串,将该字符串中相同的元素去重然后再反序输出到控制台上


public class Exercises02 {
public static void main(String[] args) {
String[] arr = {"a","s","d","f","a","a","d","2","3","8"};
Random random = new Random();
StringBuilder str = new StringBuilder();
StringBuilder str2 = new StringBuilder();
for (int i=0;i<5;i++){
str.append(arr[random.nextInt(arr.length)]);
}
System.out.println("去重前:" + str.toString());
Map<Character,Object> map = new LinkedHashMap<>();
for (int i = 0; i < str.length(); i++) {
map.put(str.charAt(i),i);//去重
}
System.out.println(map.keySet());//返回数组集合
System.out.println(map.keySet().size());
//获取迭代器
Iterator<Character> iterator = map.keySet().iterator();
while (iterator.hasNext()) {//没有指针下移操作,只是判断是否存在下一个元素
Character string = iterator.next();
//
System.out.println(iterator.next());
str2.append(string);
}
System.out.println("去重反转后:" + str2.reverse().toString());
}
private static void method01() {//方法一
String[] arr = {"a","s","d","f","a","a","d","2","3","8"};
Random random = new Random();
StringBuilder str = new StringBuilder();
StringBuilder str2 = new StringBuilder();
for (int i=0;i<5;i++){
str.append(arr[random.nextInt(arr.length)]);
}
System.out.println("去重前:" + str.toString());
for (int i = 0; i < str.length(); i++) {
if (str.indexOf(String.valueOf(str.charAt(i))) == i) {
str2.append(str.charAt(i));
}
}
System.out.println("去重反转后:" + str2.reverse().toString());
}
}
/**
* 知识点1
*
* HashSet:HashSet中的数据是无序的。
* TreeSet:Treeset中的数据是自动排好序的。
*
* 知识点2
*
* 关于Iterator主要有三个方法:hasNext()、next()、remove()
*
* hasNext:没有指针下移操作,只是判断是否存在下一个元素
*
* next:指针下移,返回该指针所指向的元素
*
* remove:删除当前指针所指向的元素,一般和next方法一起用,这时候的作用就是删除next方法返回的元素
*
*/

第三题:

按需求完成指定功能,题目如下:
(1)定义数字字符串数组{“010”,“3223”,“666”,“7890987”,“123123”}
(2)判断该数字字符串数组中的数字字符串是否是对称(第一个数字和最后一个数字相等,第二个数字和倒数第二个数字是相等的,依次类推)的,并逐个输出
(3)如:010 是对称的,3223 是对称的,123123 不是对称的

public static void main(String[] args) {
//
String[] arr = {"010","3223","666","7890987","123123"};
String[] arr = {"010","3223","666","7890987"};
StringBuilder stringBuilder;
int status = 0;
for (int i = 0; i < arr.length; i++) {
//
System.out.println(arr[i]+" "+arr[i].getClass());
char[] str = arr[i].toCharArray();
for (int j = 0; j < str.length/2; j++) {
if(str[j] != str[(str.length-1-j)]){
status = 1;
break;
}
}
if (status == 1){
break;
}
}
if(status == 0){
System.out.println("该数字字符串数组中的数字字符串是:对称的");
}else{
System.out.println("该数字字符串数组中的数字字符串是:非对称的");
}
}
private static void mathod01() {
String[] arr = {"010","3223","666","7890987","123123"};
//
String[] arr = {"010","3223","666","7890987"};
StringBuilder str;
int status = 0;
for (String s : arr) {
str = new StringBuilder(s);
//
System.out.println(str.toString()+" "+str.getClass());
if(!s.equals(str.reverse().toString())){
status =1;
break;
}
}
if(status == 0){
System.out.println("该数字字符串数组中的数字字符串是:对称的");
}else{
System.out.println("该数字字符串数组中的数字字符串是:非对称的");
}
}

第四题:

按需求完成指定功能,题目如下:
(1)打印由7,8,9三个数组组成的三位数,要求该三位数中任意两位数字不能相同
(2)打印格式最后的三位数字以空格分隔,如789 798 879 897 978 987

public class Exercises04 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
String str = "789";
for (char c : str.toCharArray()) {
String s = str;
s.replace(String.valueOf(c),"");
list.add(String.valueOf(c)+str.charAt(0)+str.charAt(1));
list.add(String.valueOf(c)+str.charAt(1)+str.charAt(0));
}
for (int i = 0; i < list.size(); i++) {
if(i != list.size()-1){
System.out.print(list.get(i)+" ");
}else{
System.out.print(list.get(i));
}
}
}
}
//方法二
public class Exercises04_2 {
ArrayList<String> res = new ArrayList<>();
public static void main(String[] args) {
ArrayList<String> res = new Exercises04_2().getPermutation("6789");
System.out.println(res);
}
public ArrayList<String> getPermutation(String A) {
char[] arr = A.toCharArray();//将字符串转化为char数组
getPermutationCore(arr, 0);
return res;
}
public void getPermutationCore(char[] arr, int k) {
if (k == arr.length) {
res.add(new String(arr));
System.out.println("y");
}else{
System.out.println("x");
}
for (int i = k; i < arr.length; i++) {
if (isSame(arr, k, i)) {//如果arr[k]到arr[i]之间没有相同的元素
swap(arr, k, i);//替换数组arr[k]和arr[i]的值
System.out.println("替换:"+"i="+i+"
k="+k+","+Arrays.toString(arr));
getPermutationCore(arr, k + 1);
swap(arr, k, i); // 回溯
System.out.println("回溯:"+"i="+i+"
k="+k+","+Arrays.toString(arr));
}else{
System.out.println("issame"+Arrays.toString(arr));
}
}
}
//判断是否有重复的元素
public boolean isSame(char[] arr, int first, int end) {
for (int i = first; i < end; i++) {
if (arr[i] == arr[end]) {
return false;
}
}
return true;
}
public void swap(char[] arr, int k, int i) {
char tem = arr[k];
arr[k] = arr[i];
arr[i] = tem;
}
}
//方法三
public class Exercises04_3 {
ArrayList<String> list = new ArrayList<>();
public ArrayList<String> parmute(String str){
char[] chars = str.toCharArray();
if(chars.length == 0) return list;
StringBuilder path =new StringBuilder();
boolean[] used = new boolean[chars.length];
dfs(chars,path,used);
return list;
}
private void dfs(char[] chars, StringBuilder path, boolean[] used) {
if(path.length() == chars.length){
list.add(new String(path));
return ;
}
for (int i = 0; i < chars.length; i++) {
if(used[i] == true)
continue;
used[i] = true;
path.append(chars[i]);
dfs(chars,path,used);
path.deleteCharAt(path.length() - 1);//回溯
used[i] = false;
}
}
public static void main(String[] args) {
ArrayList<String> list1 = new Exercises04_3().parmute("6789");
System.out.println(list1);
}
}

第五题:

按需求完成指定功能,题目如下:
(1)键盘录入一个包含多个java子字符串的字符串
例如:“javajava I love java l like jajavava I enjoy javajavajava”
(2)删除该字符串中的“java”,打印删除“java”后的字符串,以及删除的“java”的数量
(3)删除java后的输出结果为:
删除java后的字符串为:
I love
l like
I enjoy ,删除的java的数量是: 8

第六题:

获取随机的字符串,要求如下:
定义String getStr(char[] chs)静态方法,方法内要求:获取长度为5的随机字符串,字符串由随机的4个大写英文字母和1个0-9之间(包含0和9)的整数组成
定义main方法,方法内完成:
1.定义长度为26,元素值为26个大写英文字母的数组chs
2.传递数组chs调用getStr(char[] chs)方法,获取返回值,并在控制台打印返回值

public class Exercises05 {
public static String getStr(char[] chs){
String str = "";
Random random = new Random();
for (int i = 0; i < 4; i++) {
str =str + chs[random.nextInt(chs.length)];
}
str += random.nextInt(10);
return str;
}
public static void main(String[] args) {
char[] chs = new char[26];
int index = 0;
for (int i = 'A'; i <= 'Z'; i++) {
chs[index++] = (char)i;
}
int y = 0;
while (y<5){
String str = getStr(chs);
System.out.println(str);
y++;
}
}
private static void Letter26Out() {
List<Character> list = new ArrayList<>();
for (int i = 'A'; i <= 'Z'; i++) {
list.add((char)i);
}
System.out.println(list.toString());
}
}
//方法二
public class Exercises05_2 {
public static String getStr(char[] ch) {
int count1 = 0;//用来记录数组中存储数字的次数
int count2 = 0;//用来记录数组中存储字母的次数
Random r = new Random();
for (int i = 0; i < ch.length; i++) {
//生成一个48-90的随机数
int num = r.nextInt(43) + 48;
//判断生成的随机数是否在'0'-'9'范围内,如果在此范围之内将次数存入字符数组中
//如果数组中存入了一个数,count1自增后,将不会进入此if语句
if (num >= 48 && num <= 57 && count1 == 0) {
ch[i] = (char) num;
count1++;
} else if (num >= 65 && num <= 90 && count2 < 4) {//判断生成的随机数是否在'A'-'Z'范围内,如果在此范围之内将次数存入字符数组中
ch[i] = (char) num;//如果数组中存入了四个字母,count2自增4次后,将不会进入此if语句
count2++;
} else {//如果生成的随机数不在'A'-'Z'和'0'-'9',重新生成此索引位置的随机值
i--;
}
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < ch.length; i++) {
//
sb.append(ch[i]).append(" ");
sb.append(ch[i]);
}
String s = sb.toString();
return s;
}
public static void main(String[] args) {
//动态定义一个长度为5的字符数组
int len = 5;
char[] ch = new char[len];
for (int i = 0; i < 5; i++) {
String s = getStr(ch);
System.out.println(s);
}
}
}

第七题:

按需求完成指定功能,题目如下:
定义一个MyStringUtil工具类,该类中定义三个方法,要求如下:
(1) public static char[] toCharArray(String str) : 将给定的参数字符串转成对应的字符数组
(不能直接调用jdk中的工具类及String类中的tocharArray方法)
(2) public static String getSingleString(String str) : 去除给定的参数字符串中的重符字符
(重复字符只保留一个),将新的字符串返回
(3)public static boolean isBalancedString(String str): 如果左右两边字符相同则返回true
否则返回false,例如:abccba是对称字符
例如:abcdecba不是对称字符

第八题:

编写一个校验用户名的程序,检测键盘录入的用户名是否合法
要求:用户名必须是6-10位之间的字母并且不能以数字开头
public class Exercises06 {
public static void main(String[] args) {
ArrayList<String> strings = new ArrayList<>();
strings.add("kfjhsuisefikfj");
strings.add("9lkjfdk");
strings.add("hfsdjfh");
for (String string : strings) {
JudgeLegal(string);
}
}
private static void JudgeLegal(String str) {
if ( str.charAt(0) > '9' && str.length()>=6 && str.length()<=10){
System.out.println("用户名合法");
}else{
System.out.println("用户名不合法");
}
}
private static void JudgeIsFigure(String string) {
String str ="9dshfkjas";
System.out.println(Character.isDigit(str.charAt(0)) );
System.out.println(str.charAt(0)>='0' && str.charAt(0) <= '9' );
}
}

第九题:

将"goOd gooD stUdy dAy dAy up"每个单词的首字母转换成大写其余还是小写字母(不许直接输出good good study day day up 要用代码实现)

第十题:

模拟验证手机号的过程,按照以下要求实现相关代码(友情提示:不一定要用正则)
a.	提示用户在控制台输入手机号,用一个字符串对其进行保存
b.	判断该手机号位数是否是11位
c.	判断该手机号,是否都是数字
public class Exercises07 {
public static void main(String[] args) {
String str1 = "fiDkdfnIkD";
String str2 = "abccba";
String str3 = "abcdecba";
System.out.println(Arrays.toString(MyStringUtil.toCharArray(str1)));
System.out.println(MyStringUtil.getSingleString(str1));
System.out.println(MyStringUtil.isBalancedString(str2));
System.out.println(MyStringUtil.isBalancedString(str3));
}
}

工具类:

package com.student.java.exercises.String.uitl;
import java.util.ArrayList;
import java.util.Arrays;
public class MyStringUtil {
ArrayList<String> list = new ArrayList<>();
//将给定的参数字符串转成对应的字符数组
public static char[] toCharArray(String str){
char[] chars = new char[str.length()];
for (int i = 0; i < str.length(); i++) {
chars[i] = str.charAt(i);
}
return chars;
}
//去除给定的参数字符串中的重符字符
public static String getSingleString(String str){
StringBuffer str2 = new StringBuffer();
for (int i = 0; i < str.length(); i++) {
if (str.indexOf(str.charAt(i)) == i){
str2.append(str.charAt(i));
}
}
return new String(str2);
}
//左右两边字符相同则返回true,否则返回false
public static boolean isBalancedString(String str){
StringBuilder str1 = new StringBuilder(str);
return str1.reverse().toString().equals(str);
}
//将字符数组中的所有大写字母变成小写字母(不能使用 toLowerCase()方法)
public static char[] toLowerCase(char[] chars){
for (int i = 0; i < chars.length; i++) {
if (chars[i] >= 'A' && chars[i] <= 'Z'){
chars[i] += 32;
}
}
return chars;
}
//全排序,将一个String类型数据排列生成没有任何两个相同元素的字符串(每个字符串长度和输入的字符串长度相同/每个元素都要使用到)
//算法思路是二叉树(减枝)
public ArrayList<String> parmute(String str){
char[] chars = str.toCharArray();
if(chars.length == 0) return list;
StringBuilder path =new StringBuilder();//在单线程中,StringBuilder类运算速度更快
boolean[] used = new boolean[chars.length];//定义字符串元素的使用情况
dfs(chars,path,used);
return list;
}
//迭代
private void dfs(char[] chars, StringBuilder path, boolean[] used) {
if(path.length() == chars.length){//判断是否到达二叉树最底层
list.add(new String(path));
return ;
}
for (int i = 0; i < chars.length; i++) {
if(used[i] == true)//判断该元素是否使用过
continue;
used[i] = true;//将该元素标记为使用
path.append(chars[i]);//进入到下一级(添加一个元素)
dfs(chars,path,used);//递归
path.deleteCharAt(path.length() - 1);//回溯
used[i] = false;//释放该元素,让其在其他分枝可以被使用
}
}
//输入一串字符串,将每个单词的首字母转换成大写其余还是小写字母
//方法一:
public static String tialetterturn(String str){
String[] str1 = str.split(" ");
System.out.println(Arrays.toString(str1));
StringBuilder str3 = new StringBuilder();
for (String s : str1) {
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
if (i ==0 && chars[0] >= 'a' && chars[0] <= 'z'){
chars[0] -= 32;
}
if (i>= 1 && chars[i] >= 'A' && chars[i] <= 'Z'){
chars[i] += 32;
}
}
String str2 = ArrayTurnString(chars);
str3.append(str2);
str3.append(" ");
}
return new String(str3);
}
private static String ArrayTurnString(char[] arr) {
String temp = Arrays.toString(arr);
String str02 = temp.substring(1,temp.length()-1);
return str02.replace(", ","");
}
//方法一:
public String tialetterturn2(String str){
String A =str.substring(0,1);
String B=str.substring(1);
//将首字母变成大写
String upperCase=A.toUpperCase();
//其余字母小写
String lowerCase=B.toLowerCase();
//拼接
String pinjie = str.substring(0,1).toUpperCase().concat(str.substring(1).toLowerCase());
return pinjie;
}
public static void main(String[] args) {
String str = "goOd gooD stUdy dAy dAy up";
System.out.println(tialetterturn(str));
}
}

最后

以上就是聪明白羊为你收集整理的十道String题目String类相关练习的全部内容,希望文章能够帮你解决十道String题目String类相关练习所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错,欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供,作为学习参考使用,或来自网络收集整理,版权属于原作者所有。
点赞(46)

评论列表共有 0 条评论

立即
投稿
返回
顶部