【蓝桥杯冲刺省一,省一看这些就够了-Java版本】蓝桥杯字符串问题相关模板以及练习题

蓝桥杯历年省赛真题

点击链接免费加入题单

字符串

常见字符串函数与reverse

public class StringExamples {
    public static void main(String[] args) {
        // 示例字符串
        String str = "Hello, World!";

        // 1. length() 方法
        System.out.println("Length of the string: " + str.length());

        // 2. charAt() 方法
        char firstChar = str.charAt(0);
        System.out.println("First character: " + firstChar);

        // 3. substring() 方法
        String subStr1 = str.substring(7); // 从索引 7 开始到末尾
        String subStr2 = str.substring(7, 12); // 从索引 7 开始到 12(不包括)
        System.out.println("Substring 1: " + subStr1);
        System.out.println("Substring 2: " + subStr2);

        // 4. indexOf() 方法
        int index = str.indexOf("World");
        System.out.println("Index of 'World': " + index);

        // 5. lastIndexOf() 方法
        int lastIndex = str.lastIndexOf("l");
        System.out.println("Last index of 'l': " + lastIndex);

        // 6. startsWith() 方法
        boolean startsWith = str.startsWith("Hello");
        System.out.println("Starts with 'Hello': " + startsWith);

        // 7. endsWith() 方法
        boolean endsWith = str.endsWith("!");
        System.out.println("Ends with '!': " + endsWith);

        // 8. isEmpty() 方法
        boolean isEmpty = str.isEmpty();
        System.out.println("Is string empty: " + isEmpty);

        // 9. toUpperCase() 方法
        String upperCaseStr = str.toUpperCase();
        System.out.println("Uppercase string: " + upperCaseStr);

        // 10. toLowerCase() 方法
        String lowerCaseStr = str.toLowerCase();
        System.out.println("Lowercase string: " + lowerCaseStr);

        // 11. trim() 方法
        String strWithSpaces = "  Hello, World!   ";
        String trimmedStr = strWithSpaces.trim();
        System.out.println("Trimmed string: '" + trimmedStr + "'");

        // 12. replace() 方法
        String replacedStr = str.replace("World", "Java");
        System.out.println("Replaced string: " + replacedStr);

        // 13. split() 方法
        String[] splitStr = str.split(", ");
        System.out.println("Split string:");
        for (String part : splitStr) {
            System.out.println(part);
        }

        // 14. join() 方法 (Java 8+)
        String joinedStr = String.join(" - ", "Hello", "Java", "World");
        System.out.println("Joined string: " + joinedStr);

        // 15. compareTo() 方法
        String str1 = "apple";
        String str2 = "banana";
        int compareResult = str1.compareTo(str2);
        System.out.println("Comparison result: " + compareResult);

        // 16. equalsIgnoreCase() 方法
        boolean equalsIgnoreCase = str1.equalsIgnoreCase("ApPlE");
        System.out.println("Equals (ignore case): " + equalsIgnoreCase);

        // 17. contains() 方法
        boolean contains = str.contains("World");
        System.out.println("Contains 'World': " + contains);

        // 18. startsWith() 方法 (带偏移量)
        boolean startsWithOffset = str.startsWith("World", 7);
        System.out.println("Starts with 'World' at index 7: " + startsWithOffset);
    }
}
字符串编号(蓝桥杯Java2020B组省赛第一场)
子串
//可通过80%数据,这题数据比较大超时正常的
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 关闭输入输出同步,提高输入输出效率
        Scanner scanner = new Scanner(System.in);
        String a, b;
        int s = 0, t;

        // 读取输入的字符串 a 和 b
        a = scanner.next();
        b = scanner.next();

        // 寻找 b 在 a 中出现的次数
        t = a.indexOf(b); // 寻找第一次出现的位置
        while (t != -1) { // 如果找到了
            s++; // 计数加一
            t = a.indexOf(b, t + 1); // 继续寻找下一次出现的位置
        }

        // 输出结果
        System.out.println(s);
    }
}

删除字符
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s;
        char c;

        // 读取输入的字符串和字符
        s = scanner.nextLine(); // 读取一行输入
        c = scanner.next().charAt(0); // 读取一个字符

        // 寻找并删除字符串中所有等于给定字符的字符
        int p = s.indexOf(c); // 寻找第一个出现的位置
        while (p != -1) { // 如果找到了
            s = s.substring(0, p) + s.substring(p + 1); // 删除字符
            p = s.indexOf(c); // 继续寻找下一个出现的位置
        }

        // 输出结果
        System.out.println(s);
    }
}

替换单词
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s, w, t;
        int p;

        // 读取输入的字符串
        s = scanner.next();

        // 设置要查找和替换的字符串
        w = "black";
        t = "block";

        // 查找并替换字符串中所有匹配的子字符串
        p = s.indexOf(w); // 寻找第一个匹配的子字符串
        while (p != -1) { // 如果找到了
            s = s.substring(0, p) + t + s.substring(p + w.length()); // 替换子字符串
            p = s.indexOf(w, p + t.length()); // 继续寻找下一个匹配的子字符串
        }

        // 输出结果
        System.out.println(s);
    }
}

ASCII码值、字母大小写转换、’0‘~’9‘

// 数字转字符: 'A'(65)  'a'(97)  '0'(48)
char A = char(65);
char a = char(97);
char c = 'a' + 2;      // 'c' = 'a' + 2
char seven = '0' + 7;  // '7' = '0' + 7

// 字符转数字
int a = 'a';    // a: 97
int A = 'A';    // A:65
int t = 't' - 'a';     // 计算字母间差值
int seven = '7' - '0';

字符串流

Scanner 类提供了一种简单的方式来扫描和解析基本数据类型和字符串。

现在让我提供一个简单的示例,说明如何使用 Scanner 对象从字符串中读取数据:

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 定义一个字符串
        String s = "Hello 123 World 456";

        // 创建一个 Scanner 对象,从字符串 s 中读取数据
        Scanner ss = new Scanner(s);

        // 使用 Scanner 对象逐个读取整数和字符串
        while (ss.hasNext()) {
            if (ss.hasNextInt()) { // 如果下一个是整数
                int num = ss.nextInt(); // 读取整数
                System.out.println("Integer: " + num);
            } else { // 否则,读取字符串
                String str = ss.next(); // 读取字符串
                System.out.println("String: " + str);
            }
        }

        // 关闭 Scanner 对象
        ss.close();
    }
}

在这个示例中,我们首先定义了一个字符串 s,然后创建了一个 Scanner 对象 ss,并使用它从字符串中逐个读取数据。通过使用 hasNext() 方法,我们可以检查是否还有下一个元素可供读取。在循环中,我们使用 hasNextInt() 方法来判断下一个元素是整数还是字符串,然后分别使用 nextInt()next() 方法来读取整数和字符串。

stringstream练习
  • 代码
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String s;
        int n, i, sum, a;
        
        // 读取输入的整数 n
        n = scanner.nextInt();
        scanner.nextLine(); // 读取换行符

        for (i = 1; i <= n; i++) {
            // 读取一行输入
            s = scanner.nextLine();

            // 创建字符串流对象
            Scanner ss = new Scanner(s);

            sum = 0;
            // 从字符串流中读取整数并累加
            while (ss.hasNextInt()) {
                a = ss.nextInt();
                sum += a;
            }

            // 输出结果
            System.out.println(sum);
        }
    }
}

[顺子日期(蓝桥杯C/C++2022年B组省赛)](题目详情 - 顺子日期(结果填空) - DashOJ)
public class Main {
    public static void main(String[] args) {
        // 声明并初始化变量
        char[] str = new char[15]; // 存储日期字符串的字符数组
        int cnt = 0, flag = 0, ans = 0; // 计数器和标志变量

        // 遍历年份
        for (int year = 2022; year <= 2022; year++) {
            // 遍历月份
            for (int month = 1; month <= 12; month++) {
                // 遍历天数
                for (int day = 1; day <= 31; day++) {
                    // 判断月份对应的天数
                    if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) ;
                    else if (month == 2) {
                        // 判断闰年和非闰年的2月份天数
                        if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) {
                            if (day > 29) break; // 闰年2月份最多29天
                        } else {
                            if (day > 28) break; // 非闰年2月份最多28天
                        }
                    } else {
                        if (day > 30) break; // 其他月份最多30天
                    }

                    // 转换日期格式为字符串
                    String date = String.format("%04d%02d%02d", year, month, day);
                    str = date.toCharArray(); // 将字符串转换为字符数组

                    // 判断是否存在顺子
                    for (int k = 4; k <= str.length - 3; k++) { // 修正数组越界问题
                        if (str[k + 2] - str[k + 1] == 1 && str[k + 1] - str[k] == 1) {
                            // 如果存在顺子,则输出日期字符串
                            System.out.println(date);
                            ans++; // 顺子计数器加一
                            break;
                        }
                    }
                }
            }
        }

        // 输出顺子个数
        System.out.println(ans);
    }
}

练习题

[日期统计(蓝桥杯C/C++2023年B组省赛)](题目详情 - 日期统计(结果填空) - DashOJ)

字典序

什么是字典序:所谓字典序就是以ASCII码排序。

(1)比如两个字符串 abcdabdd 比较大小。 从第一个字符开始逐位比较,第一个字符不相等,谁的ASCII码值小谁的字典序就小。若第一个相等,继续逐位比较后续字符。比较到字母c < 字母d,所以第一个字符串 abcd 字典序较小。

(2)再比如 histhistory 比较大小。若逐位比较都相等,但其中一个没有后续的字符了,则较短的串 hist 字典序较小。

(3)使用 sort() 可以对字符串进行字典序排序,字符按ASCII码值由小到大排列

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 创建字符串数组
        String[] words = {"banana", "apple", "orange", "grape", "cherry"};

        // 对字符串数组进行字典序排序
        Arrays.sort(words);

        // 输出排序后的字符串数组
        System.out.println("Sorted words:");
        for (String word : words) {
            System.out.println(word);
        }
    }
}
拓拓拼字符
import java.util.Arrays;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 读取输入的 n 和 l
        int n = scanner.nextInt();
        int l = scanner.nextInt();

        // 创建字符串数组并读取输入
        String[] s = new String[n];
        for (int i = 0; i < n; i++) {
            s[i] = scanner.next();
        }

        // 对字符串数组进行排序
        Arrays.sort(s);

        // 输出排序后的字符串数组
        for (int i = 0; i < n; i++) {
            System.out.print(s[i]);
        }
        System.out.println();
    }
}

练习题
排列字母(蓝桥杯Python2022B组省赛)

你可能感兴趣的:(蓝桥杯,java,职场和发展,字符串,算法,数据结构,蓝桥杯省一)