JAVA字符串和一些练习

字符串

一.字符串

字符串的特性:

1. 不可变性： 字符串是不可变的，这意味着一旦创建了字符串，它的内容就无法更改。当对字符串执行操作（如连接、截取、替换等）时，实际上是创建了一个新的字符串对象，而原始字符串保持不变。这种特性使得字符串操作更加安全和可预测。

2. 字符串连接： 字符串连接是将多个字符串合并成一个字符串的操作。在Java中，可以使用 + 运算符来连接字符串。然而，当需要在循环中进行大量的字符串连接操作时，最好使用 StringBuilder 或 StringBuffer 类来优化性能，因为它们能够避免频繁创建新的字符串对象。

3. 字符串比较： 字符串可以通过使用 equals 方法来比较内容是否相等。注意，不能使用 == 运算符直接比较字符串，因为它会比较字符串的引用而不是内容。

4. 字符串长度： 可以使用 length 方法来获取字符串的长度，即包含的字符数量。注意，数组索引是从 0 开始的，所以最后一个字符的索引是 length - 1。

5. 空字符串： 空字符串是长度为零的字符串，表示不包含任何字符。可以使用 isEmpty() 方法检查一个字符串是否为空。

6. 转义字符： 字符串中可以包含特殊字符，如换行符 \n、制表符 \t、回车符 \r 等。还可以使用反斜杠 \ 进行字符转义，例如 \" 表示双引号，\\ 表示反斜杠本身。

7. Unicode 支持： 字符串可以包含 Unicode 字符，这使得在字符串中使用各种语言的字符和符号变得容易。

8. 注意空指针： 当操作字符串时，务必注意空指针异常。如果一个字符串为 null，那么尝试在其上执行方法或操作可能会导致空指针异常。

9. 不可变性带来的影响： 字符串的不可变性使得在进行大量字符串拼接、替换等操作时，可能会导致创建大量的临时对象，影响性能。在性能要求较高的场景中，应该考虑使用 StringBuilder 或 StringBuffer。

1.创建字符串的两种方法

//第一种
String str = "Hello, World!";
//第二种
String str1 = new String();  // 创建一个空字符串
String str2 = new String("Hello");  // 使用字符串字面量初始化
char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str3 = new String(charArray);  // 使用字符数组初始化
​

2字符串转为数组的方法

1.toCharArray()

直接在字符串对象上调用。它将字符串转换为一个字符数组，其中字符数组的每个元素对应字符串中的一个字符。这是一个无参数的方法，调用它不需要传递任何参数。

public class Main {
    public static void main(String[] args) {
        String str = "Hello, World!";
        
​
    char[] charArray = str.toCharArray();
    
    for (char c : charArray) {
        System.out.print(c + " ");
    }
}
​
}
​

2.通过遍历存到数组

翻转遍历为例子

// 翻转遍历顺序
 String fir = "";
 for (int i = str.length()-1; i >= 0; i--) {
     char a = str.charAt(i);
     fir= fir+a;
 }
 return fir;
}

二.数组转换字符串

1.通过创建对象有参传递

char[] charArray = {'H', 'e', 'l', 'l', 'o'};
String str3 = new String(charArray);  // 使用字符数组初始化

2.通过拼接

char []arr = str.toCharArray();
 String fir = "";
 for (int i = 0,j=arr.length-1; i<j; i++,j--) {
     char tem = arr[i];
     arr[i] = arr[j];
     arr[j] = tem;
​
 }
 //第二种拼接方法:字符串拼接
 for (int i = 0; i < arr.length; i++) {
     fir+= arr[i];
 }

三.一些字符串的方法

1.charAt()字符串索引

Java 字符串类（String）的一个方法，它用于获取字符串中指定位置的字符

public class Main {
    public static void main(String[] args) {
        String text = "Hello, World!";
        
        char firstChar = text.charAt(0); // 获取第一个字符 'H'
        char fifthChar = text.charAt(4); // 获取第五个字符 'o'
        
        System.out.println("First character: " + firstChar);
        System.out.println("Fifth character: " + fifthChar);
    }
}
​

2.substring字符串截取

方法用于从一个字符串中提取子串

注:因为方法原理是获取一个新字符串,因此需要有变量接收

String substring(int startIndex) // 从 startIndex 开始一直到字符串末尾提取子串。
String substring(int startIndex, int endIndex) //提取子串的起始位置和结束位置。它会提取从 startIndex 到 endIndex - 1

public class Main {
    public static void main(String[] args) {
        String text = "Hello, World!";
        
​
    // 提取从索引 7 开始到末尾的子串
    String sub1 = text.substring(7); 
    System.out.println("Sub1: " + sub1); // 输出：Sub1: World!
    
    // 提取从索引 0 开始到索引 5（不包括）的子串
    String sub2 = text.substring(0, 5);
    System.out.println("Sub2: " + sub2); // 输出：Sub2: Hello
}
​
}

3.replace字符串替换

于在字符串中替换指定的字符序列

String replace(要替换的字符串, 新的字符串)

注:不识别大小写

String str = "你玩的真好,以后TMD,不用玩了tmd真的服了";
    // 定义敏感词库
    String []lab = {"sb","tmd","nmd"};
    //循环遍历数组每一个敏感词进行替换
    for (int i = 0; i < lab.length; i++) {
         str = str.replace(lab[i],"***");
    }
    System.out.println(str);
}

运行结果:你玩的真好,以后TMD,不用玩了***真的服了

4.StringBuilder

常用于

1.翻转字符串

2.拼接字符串

public class StringBuilderExample {
    public static void main(String[] args) {
        // 创建一个StringBuilder实例
        StringBuilder sb = new StringBuilder();

​    // 添加字符串
​    sb.append("Hello, ");
​    sb.append("world!");

​    // 插入字符串
​    sb.insert(7, "beautiful ");

​    // 替换字符串
​    sb.replace(0, 5, "Hi");

​    // 删除字符
​    sb.delete(2, 4);

​    // 反转字符串
​    sb.reverse();

​    // 转换为最终字符串
​    String finalString = sb.toString();

​    System.out.println(finalString); // 输出：!dlrow taeH
}

}

5.StringJoiner

用于将一组字符串连接在一起的实用工具类。它可以方便地处理连接字符串，并且还允许你在每个字符串之间添加分隔符。

import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        // 创建一个StringJoiner，指定分隔符和可选的前缀和后缀
        StringJoiner joiner = new StringJoiner(", ", "[", "]");

        // 添加元素到StringJoiner
        joiner.add("Apple");
        joiner.add("Banana");
        joiner.add("Orange");

        // 将元素连接成一个字符串
        String result = joiner.toString();

        System.out.println(result); // 输出：[Apple, Banana, Orange]
    }
}

链式编程

链式编程（Chaining）是一种编程风格，它允许你通过连续地调用方法，一步步地对对象进行操作，从而提高代码的可读性和简洁性

例如:

import java.util.StringJoiner;

public class ChainingExample {
 public static void main(String[] args) {
     // 使用StringBuilder进行链式编程
     StringBuilder sb = new StringBuilder()
         .append("Hello")
         .append(", ")
         .append("world!")
         .insert(5, " amazing")
         .delete(5, 13)
         .reverse();

     System.out.println("StringBuilder result: " + sb.toString()); // 输出：StringBuilder result: !dlrow

     // 使用StringJoiner进行链式编程
     StringJoiner sj = new StringJoiner(", ", "[", "]")
         .add("Apple")
         .add("Banana")
         .add("Orange")
         .setEmptyValue("No fruits");

     System.out.println("StringJoiner result: " + sj.toString()); // 输出：StringJoiner result: [Apple, Banana, Orange]
 }
}

四:练习以及一些思路

1.写一个程序计算翻转字符的次数(字符翻转)

a是原始字符串,targetstr是目标字符串,

思路有两种

1.通过循环截取字符串(本题)

输入一个字符串,和目标字符串,每次将第一个字母放到最后面,需要几次达成目标;如abc->bca需要1次

2.先转换为字符数组,之后进行操作

public class rotate_str {
    static String targetStr = "dfgas";

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String a = "asdfg";
        int seconds = rotate(a);
        if (boolsame(a)) {
            System.out.println(0);
        } else {
            if (-1 == rotate(a)) {
                System.out.println("不匹配");
            } else {
                System.out.println(seconds);
            }
        }
    }

    public static int rotate(String a) {
        int count = 0;
        while (count < a.length()) {
            // char fir = a.charAt(count++);
            String fir = a.substring(0, ++count);
            String newa = a.substring(count);
            String fin = "" + newa + fir;
            if (boolsame(fin)) {
                return count;
            }
        }
        return -1;
    }

    public static boolean boolsame(String fin) {
        if (fin.equals(targetStr)) {
            return true;
        }
        return false;
    }
}

2.字符的打乱(random)

题目:生成一个5位数验证码,四位是大小写字母,一位是数字,无顺序

 public static void main(String[] args) {
        Random r = new Random();
        char[] uppercaseArray = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J',
                'K', 'L', 'M', 'N', 'O', 'P', 'Q',
                'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
                'g', 'h', 'i', 'j', 'k', 'l',
                'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};

        int num[] = {0,1,2,3,4,5,6,7,8,9};
         String str = "";
        for (int i = 0; i < 4; i++) {
            int  a = r.nextInt(uppercaseArray.length);
            str = str+uppercaseArray[a];
        }
        str = str + num[r.nextInt(num.length)];
        str =randomstr(str);
        System.out.println(str);
    }
    public static String randomstr(String str){
        Random r = new Random(str.length());
        char newstr[] = str.toCharArray();

        for (int i = 0; i < str.length(); i++) {
           int index =  r.nextInt(str.length());
            char tem = newstr[i];
            newstr[i] = newstr[index];
            newstr[index] = tem;
        }


        return new String(newstr);
    }

3.字符串转整数的方法

先转换为字符数组,见上文

方法一:

通过ASCII码以及自动转换转为整数

int num = a-'0'; //a为字符型的数字

原理是比"0"的ASCII码48大多少,最终的差就是所求整数等于a

方法二:

通过查表匹配

建一个整数数组查询相同返回其索引(其中==比较的是ASCII码)

char carr[] = {'0','1','2','3','4','5','6','7','8','9'};
for (int i = 0; i < carr.length ; i++) {
    if(a==carr[i]){
        return i;
    }
}return 0;