复试04-字符串

字符串一般有以下几种操作

1. 遍历
2. 加密
3. 统计
4. 匹配

String的重要：

1. 构造
2. 操作
3. 运算
4. 函数

字符串的常用操作有：
5. 拷贝
6. 截取

public class d1 {
    public static void main(String[] args) {
        String str = new String("ABCdefAghij3");
        System.out.println(str.charAt(1));//位置1的字符是什么
        System.out.println(str.toLowerCase());//转为小写
        System.out.println(str.toUpperCase());//转为大写
        System.out.println(str.concat("123"));//添加字符串123
        System.out.println(str.contains("ABC"));//是否包含字符串ABC
        System.out.println(str.indexOf("hi"));//字符串hi的位A置
        System.out.println(str.endsWith("ij3"));//是否以ij3结尾的
        System.out.println(str.isEmpty());//是否为空
        System.out.println(str.replace("ABC","abc"));//将str中的ABC替换成abc
        System.out.println(str.split("C"));//以C分割字符串
        System.out.println(str.startsWith("ABC"));//是否以ABC开头
        System.out.println(str.substring(3));//子串下标3到结尾
        System.out.println(str.substring(3,5));//子串下标3到5
        System.out.println(str.matches(""));//匹配正则表达式
        System.out.println(str.lastIndexOf("A"));//返回字符串最后一次的索引
        String[] s = {"1","a"};
        System.out.println(String.join(",",s));
    }
}

这里是常用的java的String类的方法,删除就用subString达到类似效果即可。

例题4.1特殊乘法

这里记住int的范围
-2147483648~2147483647
正负20亿多。

这里值得注意的是：题目的描述中采用的是12
*345，样例输入中采用的123*45.是不同的

并且数据分析以下，由于数据要被切割，每个位上的数要被切割。所以说，数据量并没有那么大。

这里我误以为数据量会很大，就采用的BigInteger。

BigInteger这里要注意的是，BigInteger.add(BigInteger bi) 是返回一个新的BigInteger而不是加到原来的数上。用对象来做算术大概都是这样的

import java.math.BigInteger;
import java.util.Scanner;

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

        if (Integer.parseInt(a) > 1000000000 || Integer.parseInt(b) > 1000000000) {
            System.out.println("数字不合适");
            return;
        }
        System.out.println(SpecialMultiplication(a, b));
    }

    static int SpecialMultiplication(String a, String b) {
        BigInteger bigIntegerA = new BigInteger(a);
        BigInteger bigIntegerB = new BigInteger(b);
        BigInteger sum = bigIntegerA.multiply(bigIntegerB);
        BigInteger x = new BigInteger("0");
        BigInteger integer;
        for (int i = 0; i < a.length(); i++) {
            for (int j = 0; j < b.length(); j++) {
                integer = new BigInteger(String.valueOf(b.charAt(j))).multiply(new BigInteger(String.valueOf(a.charAt(i))));
                x=x.add(integer);
            }
        }
        return x.intValue();
    }


}

例题4.3：字符串加密

按照下面的方法就好了

    static String MD(String s){
        char[] array = s.toCharArray();
        for (int i = 0; i < array.length; i++) {
            if('A'<=array[i]&&array[i]<='Z'){
                array[i]= (char) ((array[i]-'A'-5+26)%26+'A');//对s.charAt(i)解密。
            }
        }
        return String.valueOf(array);
    }

这里重点注意的就是

char[] array = s.toCharArray();//将字符串转换为char数组
String.valueOf(array);//将char数组转换位字符串

例题4.4

第一行输入字符，第二行输入字符串，统计字符在字符串中的个数。

import java.util.Scanner;

public class d4 {
    public static void main(String[] args) {
        Scanner scanner  = new Scanner(System.in);
        String s = scanner.next();
        scanner.nextLine();
        String s1 = scanner.nextLine();
        statistics(s.charAt(0),s1);
    }
    static void statistics(char c ,String str){
        int num=0;
        char[] chars = str.toCharArray();
        for (int i = 0; i < chars.length; i++) {
            if(chars[i]==c)num++;
        }
        System.out.println(c+" "+num);
    }
}

同样，这里要注意，scanner.nextLine();前一定要要额外重复一遍，解决上一次的换行符。

例题：字符串匹配问题

字符串匹配有几种问题

1. Detection 是否出现
2. Location 何处出现
3. Count 出现几次
4. Enumeration 每次出现在何处

匹配算法：

1. 蛮力算法
2. KMP算法

蛮力算法大概如上
复杂度O(m*(n-m+1))
由于只能统计一次最开始或者最后的。

String string = new String("123123123");
        System.out.println(string.contains("12"));
        System.out.println(string.indexOf("31"));

所以我们可以巧妙利用其他方法，
将待统计的字符通过Replace函数移除，然后再通过未移除前的字符串长度减去移除后的字符串长度即可算出。

        String string = new String("123123123123123");
        String str = string.replace("31","");
        System.out.println((string.length()-str.length())/"31".length());

优化思想，就是在匹配的时候能否快速往后移。

这里注意的小技巧就是判断一个数组中是否包含了某个数可以用
先转化为list列表。

if(Arrays.asList(prefixes).contains(suffixes[i]))num++;

例题4.6

这个问题对于java来说，emm比较简单。

最复杂的那个kmp算法，可以理解，但是写不出来，看代码也看得我头疼。想稍微偷点懒，反正string类有内置函数能代替。偶也。