字符串基础

字符串

String

概述：

String类在 java.lang 包下,所以使用的时候不需要导包。
String类代表字符串，Java 程序中的所有字符串文字(例如*abc" ) 都被实现为此类的实例也就是说，Java 程序中所有的双引号字符串，都是String类的对象。

字符串的特点

• 字符串不可变，它们的值在创建后不能被更改
• 虽然String的值是不可变的，但是它们可以被共享
• 字符串效果上相当于字符数组( char[)r但是底层原理是字节数组( byte[)（JDK8及以前是字符数组，JDK9及以后是字节数组）

String构造方法

方法名	说明
public String()	创建一个空白字符串对象，不含有任何内容
public String(char[] chs)	根据字符数组的内容，来创建字符串对象
public String(byte[] bys)	根据字节数组的内容，来创建字符串对象
String s=“abc”;	直接赋值的方式创建字符串对象，内容就是abc

String对象的特点

​ 以“ “方式给出的字符串，只要字符序列相同(顺序和大小写,无论在程序代码中出现几次，JVM都只会建立一个String对象，并在字符串池中维护

String s3 = "abc";
String s4 = "abc";

在上面的代码中，针对第一行代码, JVM会建立一个String对象放在字符串池中，并给s3参考;
第二行则让s4直接参考字符串池中的String对象，也就是说它们本质上是同一个对象。

字符串的比较

使用 == 做比较
● 基本类型:比较的是数据值是否相同
● 引用类型: 比较的是地址值是否相同

字符串是对象，它比较内容是否相同，是通过一个方法来实现的，这个方法叫: equals()
●public boolean equals(Object anObject):将此字符串与指定对象进行比较。由于我们比较的是字符串对象，所以参数直接传递一个字符串

public class StringDemo02 {
public static void main(String[] args) {
//构造方法的方式得到对象
char[] chs = {'a', 'b', 'c'};
String s1 = new String(chs);
String s2 = new String(chs);
//直接赋值的方式得到对象
String s3 = "abc";
String s4 = "abc";
//比较字符串对象地址是否相同
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s3 == s4);
System.out.print1n("-------");
//比较字符串内容是否相同
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3)); 
System.out.println(s3.equals(s4));
}
}

false
false
true
-------    
true
true
true
true

遍历字符串

键盘输入字符串，遍历输出输入的字符串

package com.dong.test;
import java.util.Scanner;
public class StringTest02 {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = scanner.nextLine();
        //遍历字符串，首先要能够获取到字符串中的每一个字符
        //charAt(i)获取字符串的第i个字符
        for (int i=0;i<line.length();i++){
            System.out.println(line.charAt(i));
        }
    }
}

统计字符次数

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

思路。
1:键盘录入一个字符串，用Scanner 实现
2:要统计三种类型的字符个数，需定义三个统计变量，初始值都为e
3:遍历字符串，得到每一个字符
4:判断该字符属于哪种类型，然后对应类型的统计变量+1
假如ch是一个字符，我要判断它属于大写字母，小写字母，还是数字，直接判断该字符是否在对应的范围即可
大写字母。ch>='A" 8& ch<=‘Z’
小写字母: ch>='o’8& ch<= ‘z’
数字: ch>=‘e’ 88 ch<=‘9’
5:输出四种类型的字符个数

package com.dong.test;

import java.util.Scanner;

public class StringTest03 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String line = scanner.nextLine();
        //统计三种类型的字符串个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;
        int otherCount=0;
        for (int i = 0; i < line.length(); i++) {
            char ch=line.charAt(i);
            if (ch>='A'&&ch<='Z'){
                bigCount++;
            }else if (ch>='a'&&ch<='z'){
                smallCount++;
            }else if (ch>='0'&&ch<='9'){
                numberCount++;
            }else {
                otherCount++;
            }
        }
        System.out.println("大写字母个数为："+bigCount);
        System.out.println("小写字母个数为："+smallCount);
        System.out.println("数字个数为："+numberCount);
        System.out.println("特殊字符个数为："+otherCount);
    }
}

结果

请输入一个字符串
54dasdHIHhuH8DUW1333**
大写字母个数为：7
小写字母个数为：6
数字个数为：7
特殊字符个数为：2

字符串拼接

需求
定义一个方法。把int数组中的数据按照指定的格式拼接成一个字符串返回，调用该方法，并在控制台输出结果。
例如，数组为int[] arr = {1,2,3}; ，执行方法后的输出结果为: [1, 2, 3]

思路:
1:定义一个int类型的数组，用静态初始化完成数组元素的初始化
2:定义一个方法，用于把int数组中的数据按照指定格式拼接成一个字符串返回 。
返回值类型String. 参数列表int[] arr
3:在方法中遍历数组，按照要求进行拼接
4:调用方法，用一个变量接收结果
5:输出结果

package com.dong.test;
//字符串的拼接
public class StringTest04 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        String a=arrayToString(arr);
        System.out.println(a);
    }
    public static String arrayToString(int[] arr){
        String s="";
        s+="[";
        for (int i = 0; i < arr.length; i++) {
          if (i==arr.length-1){
              s+=arr[i];
          }else {
              s+=arr[i];
              s+=",";
          }
        }
        s+="]";
        return s;
    }

}

字符串的反转

需求:定义一个方法，实现字符串反转。键盘录入-个字符串,调用该方法后，在控制台输出结果
例如，键盘录入abc,输出结果cba

思路:
①键盘录入-个字符串，用Scanner实现
②定义一个方法，实现字符串反转。返回值类型String, 参数Strings
③在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成- 个字符串并返回
④调用方法，用一个变量接收结果
⑤输出结果

package com.dong.test;

import java.util.Scanner;

public class StringTest05 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String line = scanner.nextLine();
        System.out.println("反转后的字符串为:"+"\n"+reverse(line));

    }
    //反转字符串方法
    public static String reverse(String s){
        String s1="";
        for (int i =s.length()-1; i >=0; i--) {
            s1+=s.charAt(i);
        }
        return s1;
    }
}

请输入一个字符串:
dtdy
反转后的字符串为:
ydtd

StringBuilder

如果对字符串进行拼接操作，每次拼接,都会构建一个新的String对象， 既耗时，又浪费内存空间，而这种操作还不可避免。那么有没有一种比较好的方式可以解决这个问题呢? 答案是肯定的，我们可以通过Java提供的
StringBuilder类就来解决这个问题。

概述

StringBuilder是一个可变的字符串类， 我们可以把它看成是一个容器
这里的可变指的是StringBuilder对象中的内容是可变的

String和StringBuilder的区别:
● String: 内容是不可变的
● StringBuilder: 内容是可变的

添加和反转方法

package com.dong.test;

/*
    StringBuilder 的添加和反转方法
     public StringBuilder  append(任意类型)：添加数据并返回对象本身
     public StringBuilder   reverse();返回相反的字符序列
 */
public class StringBuilder02 {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
//        sb.append("Hello");
//        sb.append(" ");
//        sb.append("World");
//        sb.append(" ");
//        sb.append("2020");
//        System.out.println(sb);
        //链式编程
        sb.append("Hello").append(" ").append("World").append(" ").append("2020");
        System.out.println(sb);
        //反转字符
        // public StringBuilder   reverse();返回相反的字符序列
        sb.reverse();
        System.out.println(sb);


    }
}

Hello World 2020
0202 dlroW olleH

StringBuilder和String相互转换

1. StringBuilder转换为String
   public String toString( ):通过toString0就可以实现把StringBuilder转换为String

2. String转换为StringBuilder
   public StringBuilder(Strings):通过构造方法就可以实现把String转换为StringBuilder

package com.dong.test;

public class StringBuilder03 {
    public static void main(String[] args) {
        //StringBuilder 转换为String
        StringBuilder sb =new StringBuilder();
        sb.append("hello");
        String s=sb.toString();
        System.out.println(s);
       //String 转换为StringBuilder
        String s1="world";
        StringBuilder sb1 = new StringBuilder(s1);
        System.out.println(sb1);

    }
}

拼接字符串

需求:定义一个方法，把int 数组中的数据按照指定的格式拼接成一个字符串返回， 调用该方法,并在控制台输出结果。例如，数组为int]arr= {1,23};,执行方法后的输出结果为: [1,2, 3]
思路:
①定义一个int类型的数组，用静态初始化完成数组元素的初始化
②定义一个方法，用于把int数组中的数据按照指定格式拼接成- 个字符串返回。返回值类型String, 参数列表int] arr
③在方法中用StringBuilder按照要求进行拼接，并把结果转成String返回
④调用方法，用一个变量接收结果
⑤输出结果

package com.dong.test;

public class StringBuilder04 {
    public static void main(String[] args){
        int[] arr={1,2,3};//定义一个数组
        System.out.println(arrayToString(arr));
    }
    public static String arrayToString(int[] arr){
        StringBuilder sb=new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i==arr.length-1){
                sb.append(arr[i]);
            }else {
                sb.append(arr[i]).append(", ");
            }
        }
        sb.append("]");
        String s=sb.toString();
        return s;
    }

}

[1, 2, 3]

字符串反转

需求:定义一个方法，实现字符串反转。键盘录入-个字符串,调用该方法后，在控制台输出结果 。 例如，键盘录入abc,输出结果cba
思路:
①键盘录入一个字符串，用Scanner实现
②定义一个方法，实现字符串反转。返回值类型String, 参数Strings
③在方法中用StringBuilder实现字 符串的反转，并把结果转成String返回
④调用方法，用一个变量接收结果
⑤输出结果

package com.dong.test;

import java.util.Scanner;

public class StringBuilder05 {
    public static void main(String[] args) {
    //键盘录入字符串
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串：");
        String line = scanner.nextLine();
        String a =reverse(line);
        System.out.println("反转后的字符串为："+a);
    }
    public static String reverse(String s){
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String s1 = sb.toString();
//        return s1;
        //等价代码
       return new StringBuilder(s).reverse().toString();
    }
}

请输入一个字符串：
sdadaF
反转后的字符串为：Fadads