【Java】认识String类

1. String类的重要性
2. 常用方法
- 2.1 字符串构造+求字符串长度
- 2.2 String对象的比较
- 2.3 字符串查找
- 2.4 转化
- 2.5 字符串替换
- 2.6 字符串截取
- 2.7 字符串拆分
- 2.8 其他操作方法
- - 2.8.1 String trim()
  - 2.8.2 String toUpperCase()
  - 2.8.3 String.format（）
3. 总结！

1. String类的重要性

在C语言中已经涉及到字符串了，但是在C语言中要表示字符串只能使用字符数组或者字符指针，可以使用标准库提

供的字符串系列函数完成大部分操作，但是这种将数据和操作数据方法分离开的方式不符合面相对象的思想，而字

符串应用又非常广泛，因此Java语言专门提供了String类。

可以使用String直接定义一个变量，这个变量可以直接就是字符串：

2. 常用方法

2.1 字符串构造+求字符串长度

1.直接定义一个字符串。

2.通过new String对象。

3.通过字符串数组进行构造。

public static void main1(String[] args) {
        //1.直接定义一个字符串
        String str="hello";//区别于C语言，Java中的字符串，没有以'\0'结尾
        System.out.println(str);
        System.out.println(str.length());
        System.out.println("hello".length());

        //2.通过new String对象
        String str3=new String("world");
        System.out.println(str3);

        //3.通过字符串数组进行构造
        char[] array={'a','b','c'};
        String str4=new String(array);
        System.out.println(str4);

        int[] array2={1,2,3,4,5};
        System.out.println(array2.length);

    }

2.2 String对象的比较

用于两个字符串比较：
1.==
2.equals
3.compareTo
4.compareToIgnoreCase

public static void main2(String[] args) {
        String str1=new String("abcde");
        String str2=new String("abcde");

        System.out.println(str1==str2);//==：实质是比较字符串的地址,false
        System.out.println(str1.equals(str2));//String类重写了父类Object中equals方法,Object中equals默认按照==比较，                                                                      //String重写equals方法后，就会发生动态绑定true,

        String str3=new String("abcde");
        String str4=new String("abcde");
        System.out.println(str3==str4);//字符串常量池!

    }

字符串常量池：

1.存储双引号“ ”，引起来的字符串，存的是字符串常量值。
2.看常量池是否存在当前字符串。
3.如果没有，则存进去。
4.如果有，则获取这个字符串在常量池中的地址。

public static void main3(String[] args) {
        String str1=new String("abcde");
        String str2=new String("abcdef");
        System.out.println(str1.compareTo(str2));
        
        String s1=new String("Abcde");
        String s2=new String("abcdef");
        System.out.println(s1.compareToIgnoreCase(s2));//忽略大小写比较
    }

2.3 字符串查找

用于字符串查找：

1.char charAt(int index)：返回index位置上字符，如果index为负数或者越界，抛出IndexOutOfBoundsException异常。

2.int indexOf(int ch) ：返回ch第一次出现的位置，没有返回-1。

3.int indexOf(int ch, int fromIndex):从fromIndex位置开始找ch第一次出现的位置，没有返回-1。

4.int indexOf(String str) :返回str第一次出现的位置，没有返回-1。

5.int indexOf(String str, int fromIndex):从fromIndex位置开始找str第一次出现的位置，没有返回-1。

6.int lastIndexOf(int ch) :从后往前找，返回ch第一次出现的位置，没有返回-1。

7.int lastIndexOf(int ch, int fromIndex):从fromIndex位置开始找，从后往前找ch第一次出现的位置，没有返回-1。

8.int lastIndexOf(String str) :从后往前找，返回str第一次出现的位置，没有返回-1。

9.int lastIndexOf(String str, int fromIndex):从fromIndex位置开始找，从后往前找str第一次出现的位置，没有返回-1。

public static void main5(String[] args) {
        String str1="abcdef";
        //获取指定位置的字符
        char ch=str1.charAt(2);
        System.out.println(ch);

        int index=str1.indexOf('c',3);
        System.out.println(index);

        int index2=str1.indexOf('c',5);
        System.out.println(index2);
        
        String s1="abcdaefd";
        int index3=s1.lastIndexOf('a',2);
        System.out.println(index3);   
    }

总结一下：

如果找单个字符，则用charAt方法；
找字符或字符串，则返回所需要的下标；
如果是从前往后找，则用indexOf方法；
如果是从后往后找，则用lastIndexOf方法；

2.4 转化

public static void main6(String[] args) {
        //数字转字符串
        String s1=String.valueOf(12.34);
        System.out.println(s1);

        String s2=String.valueOf(1234);
        System.out.println(s2);

        String s3=String.valueOf(false);
        System.out.println(s3);
        System.out.println("======================");
        
        //字符串转数字
        int data1=Integer.parseInt("1234");//转化成整数
        System.out.println(data1);

        double data2=Double.parseDouble("12.34");//转换成Double类型的小数
        System.out.println(data2);
        
        //也可以定义一个学生类，直接在valueOf里面定义一个new Student类型
        String s4=String.valueOf(new Student(10));
        System.out.println(s3);
    }
    
    //s4：
    class Student{
        private int age;
        public Student(int age){
            this.age=age;
        }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                '}';
    }
}

2.5 字符串替换

字符串替换：

1.String replaceAll(String regex, String replacement) ：替换所有的指定内容。或String replace(String regex,

String replacement)

2.String replaceFirst(String regex, String replacement) ：替换收个内容。

public static void main8(String[] args) {
        String str="abababcedf";
        String ret=str.replace("ab","oo");
        System.out.println("==========================");

        String ret2=str.replaceFirst("a","p");
        System.out.println(ret2);
        System.out.println("===========================");

        String ret3=str.replaceAll("a","p");
        System.out.println(ret2);
    }

2.6 字符串截取

字符串截取：

1.String substring(int beginIndex) ：从指定索引截取到结尾

2.String substring(int beginIndex, int endIndex) ：截取部分内容

 public static void main(String[] args) {
        String s="abcd";
        String ret=s.substring(0);
        System.out.println(ret);
        
        String ret2=s.substring(1,3);//在Java里面，左闭右开：[1,3)
        System.out.println(ret2);
        
        String s2="    abcd  ";
        System.out.println(s2);
        String ret1=s2.trim();
        System.out.println(ret1);
    }

2.7 字符串拆分

字符串拆分：

1.String[] split(String regex) ：将字符串全部拆分。

2.String[] split(String regex, int limit) ：将字符串以指定的格式，拆分为limit组。

public static void main9(String[] args) {
        String str="abc&de&f=10";
        String[] strings=str.split("&");
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        
        //打印：
        String[] strings2=str.split("=");
        for (int i = 0; i < strings2.length; i++) {
            System.out.println(strings2[i]);
        }

        String[] strings3=str.split("&",2);
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        
        //比如，\" . \"点号，如果要识别IP地址中的点号，直接通过split进行拆分是识别不出点号作为分割符的，需要加上转义字符，也就    是  \\\\.
        String str="199.2.34";
        System.out.println(str);
        String[] strings=str.split("\\.");//以//来转换'.'
        for (int i = 0; i < strings.length; i++) {
            System.out.println(strings[i]);
        }
        
        //如果是一个字符串中有多个分隔符，那么用 | 作为连字符
        String str="abc&de&f=10";
         String[] strings2=str.split("=|&");
        for (int i = 0; i < strings2.length; i++) {
            System.out.println(strings2[i]);
        }

    }

2.8 其他操作方法

其他操作方法：

String trim() ：去掉字符串中的左右空格,保留中间空格。

String toUpperCase()：字符串转大写。

String toLowerCase() ：字符串转小写。

String.format（）：修改输出形式。

2.8.1 String trim()

public static void main(String[] args) {
        String s2="    abcd  ";
        System.out.println(s2);
        String ret1=s2.trim();
        System.out.println(ret1);
    }

2.8.2 String toUpperCase()

public static void main12(String[] args) {
        String s="abcd";
        System.out.println(s.toUpperCase());
        String s2="ABCd";
        System.out.println(s2.toLowerCase());
    }

2.8.3 String.format（）

public static void main7(String[] args) {
        String s1="hello";
        char[] array=s1.toCharArray();
        for(int i=0;i<array.length;i++){
            System.out.println(array[i]+" ");
        }
        System.out.println();

        String s=String.format("%d-%d-%d",2004,6,2);
        System.out.println(s);
    }

3. 总结！

方法	作用
charAt()	输入下标，找单个字符
toUpperCase()	字母由小写转换成大写
toLowerCase()	字母由大写转换成小写
replace()/replaceAll()	代替字符串中的字符
replaceFrist()	代替字符串中的首个字符
String.equals()	比较字符串相不相等，返回boolean类型
String.compareTo()	比较字符串相不相等，返回int类型
equalsToIgnoreCase()	忽略字母大小写，比较字符串相不相等
split()	对字符串进行拆分，注意特殊字符，需要进行转义
trim()	去字符串，首部和尾部的空格，但要保留中间空格
format()	格式化输出
String.valueof()	数字转字符串
Integer.parselnt()/Integer.valueOf()	字符串转数字
indexOf()	从前往后找字符串或字符，返回下标
lastIndexOf()	从后往前找字符串或字符，返回下标
subString()	截取字符串
toCharArray()	字符串转数组
new String()	数组转字符串