常见对象---String类

String类

目标：

1. 字节数组或字符数组与字符串的相互转换；
   构造方法,字节数组或字符数组转为字符串 String(byte[] bytes)，String(char[] value)
   字符串转为字符数组 getBytes(String str)
   字符串转为字节数组 tocharArray(String str)
   任意类型转为字符串 static String valueOf(Object obj)
2. 引号赋值出来的字符串会进入字符串常量池(在堆内存中)，new出来的不会；
3. 字符串重写了equals()方法，比较的是内容是否相同；
4. 遍历字符串，判断、查找、截取、替换等功能。
   length()获取长度，
   charAt(int index) 返回指定索引处的字符，indexO(int ch)返回指定字符的索引；
   substring(int beginIndex, int endIndex) 截取
   concat(Sring str) 拼接
   repalce(char oldChar, char newChar)替换

1. 概述

java.lang.String，字符串
A. Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。
B. 字符串是常量，它们的值在创建之后不能更改。

2. 构造方法

public String() 无参构造
public String(byte[] bytes) 把字节数组转成字符串
public String(byte[] bytes, int offset, int length) 把字节数组中从某个索引开始的指定长度内容转成字符串
public String(char[] value) 把字符数组转成字符串
public String(char[] value, int offset, int length) 把字符数组中从某个索引开始的指定长度内容转成字符串
public String(String original) 把字符串常量值转成字符串

示例：

package cn.itcast;

public class demo {
    public static void main(String[] args) {
        //创建对象
        String s1 = new String();
        System.out.println("s1:" + s1);
        System.out.println("s1的长度是：" + s1.length());
        
		//把字节数组转成字符串
        byte[] bys = {97, 98, 99, 100, 101};
        String s2 = new String(bys);
        System.out.println("s2:" + s2);
        System.out.println("s2的长度是：" + s2.length());
	
		//把字节数组转成字符串,指定从索引1开始，长度为3
        String s3 = new String(bys, 1, 3);
        System.out.println("s3:" + s3);
        System.out.println("s3的长度是：" + s3.length());
		
		//把字符数组转成字符串
        char[] chars = {'h','e','l','l','o','j','a','v','a'};
        String s4 = new String(chars);
        System.out.println("s4:"+s4);
        System.out.println("s4的长度是："+s4.length());
        
		//把字符数组转成字符串，指定从索引1开始，长度为3
        String s5 = new String(bys, 1, 3);
        System.out.println("s5:" + s5);
        System.out.println("s5的长度是：" + s5.length());
        
		//把字符串常量值转成字符串,意义不大
        String s6 = new String("hellojava");
        System.out.println("s6:"+s6);
        System.out.println("s6的长度是："+s6.length());
		
		//字符串字面值就可以看成一个字符串对象，最常用
		String s7 = "HelloWorld";
        System.out.println("s7:"+s7);
        System.out.println("s7的长度是："+s7.length());
    }
}

输出结果：
			s1:
			s1的长度是：0
			s2:abcde
			s2的长度是：5
			s3:bcd
			s3的长度是：3
			s4:hellojava
			s4的长度是：9
			s5:bcd
			s5的长度是：3
			s6:hellojava
			s6的长度是：9
			s7:HelloWorld
			s7的长度是：10

注意：
（1）堆内存中有一块区域是字符串常量池，字符串直接赋值的方式是先到字符串常量池里面去找，如果有就直接返回，没有就创建并返回。一旦被赋值，值就不能被改变。而new出来的字符串不会去常量池。
（2）两个字符串变量拼接，是先开内存空间再拼接；而两个字符串常量拼接，是先拼接，然后在常量池里找，如果有就直接返回，否则就创建。

面试题：
1.String s1= new String("hello"); 和 String s2 = "hello"; 的区别?

• 题目2：

package cn.itcast;

public class demo {
    public static void main(String[] args) {
        //创建对象
        String s1 = new String("hello");
        String s2 = new String("hello");
        System.out.println(s1==s2);  //==比较地址
        System.out.println(s1.equals(s2));  // equals()方法比较内容
        System.out.println("------------------");

        String s3 = new String("hello");
        String s4 = "hello";
        System.out.println(s3==s4);
        System.out.println(s3.equals(s4));
        System.out.println("------------------");

        String s5 = "hello";
        String s6 = "hello";
        System.out.println(s5==s6); //常量池中存在"hello"，直接用，因此地址值相同
        System.out.println(s5.equals(s6));
        System.out.println("------------------");
    }
}

输出结果：
		false
		true
		------------------
		false
		true
		------------------
		true
		true
		------------------

• 题目3：

package cn.itcast;

public class demo {
    public static void main(String[] args) {
        //创建对象
        String s1 = "hello";
        String s2 = "world";
        String s3 = "helloworld";
        System.out.println(s3 == s1 + s2);  //两个字符串变量拼接，是先开内存空间再拼接
        System.out.println(s3.equals(s1 + s2));
        System.out.println(s3 == "hello" + "world");  //两个字符串常量拼接，是先拼接，然后在常量池里找，如果有就直接返回，否则就创建
        System.out.println(s3.equals("hello" + "world"));
    }
}

输出结果：
		false
		true
		true
		true

3. 常用方法

(1) 判断功能

boolean equals(Object anObject) 比较字符串的内容是否相同，区分大小写
boolean equalsIgnoreCase(String anotherString) 比较字符串的内容是否相同，忽略大小写
boolean contains(CharSequence s) 判断大字符串中是否包含小字符串
boolean startsWith(String prefix) 判断字符串是否以某个指定的字符开头
boolean endsWith(String suffix) 判断字符串是否以某个指定的字符结尾
boolean isEmpty() 判断字符串是否为空。注意与null的区别

(2) 获取功能

int length() 返回此字符串的长度
char charAt(int dex) 返回指定索引处的 char 值
int indexOf(int ch) 返回指定字符在此字符串中第一次出现处的索引。没有则返回-1
int indexOf(int ch, int fromIndex) 返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。 没有则返回-1
int indexOf(String str) 返回指定子字符串在此字符串中第一次出现处的索引。 没有则返回-1
int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。 没有则返回-1
String substring(int beginIndex) 从指定索引处开始截取字符串返回，默认到末尾
String substring(int beginIndex, int endIndex) 从指定索引处开始到指定索引处结束截取字符串返回，注意是左闭右开区间。

• 统计输入的字符串中大写，小写和数字字符的个数(仅考虑字母和数字)

package cn.itcast;

import java.util.Scanner;

public class demo {
    public static void main(String[] args) {
        //获取键盘输入的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串(仅限字母和数字)：");
        String s = sc.nextLine();

        //定义三个变量分别用于统计大写、小写和数字出现的次数
        int bigCount=0;
        int smallCount=0;
        int numberCount=0;

        //用length()和charAt()遍历字符串
        for (int i = 0; i <s.length() ; i++) {
            char ch = s.charAt(i);
            
            //直接对字符进行判断
            //也可以ASCII码对字符进行判断，0---48，A---65,a---97
            if(ch >= '0'&& ch <+ '9'){
                numberCount++;
            }else if (ch >='a'&&ch <= 'z') {
                smallCount++;
            }else if (ch >= 'A'&& ch <= 'Z') {
                bigCount++;
            }
        }
        System.out.println("大写字母有："+bigCount+"个");
        System.out.println("小写字母有："+smallCount+"个");
        System.out.println("数字有："+numberCount+"个");
    }
}

输出结果：
		请输入一个字符串(仅限字母和数字)：
		helloJAVA520
		大写字母有：4个
		小写字母有：5个
		数字有：3个

(3) 转换功能

byte[] getBytes() 把字符串转换为字节数组并返回
char[] toCharArray() 把字符串转换为字符数组并返回
static String valueOf(char[] data) 把字符数组转换为字符串并返回
static String valueOf(char[] data, int offset, int count) 把字符数组转换为字符串并返回，从指定索引处开始，指定个数
static String valueOf(int i) 把int类型的数据转换为字符串并返回
注意： String类的valueOf()方法可以把任意类型的数据转成字符串
String toLowerCase() 把字符串转成小写并返回
String toUpperCase() 把字符串转大写并返回
String concat(String str) 拼接字符串并返回
注意：返回的都是是一个新的字符串。

• 遍历字符串两种方法
  A. 用length()和charAt()遍历；
  B. 用Char[] toCharArray() 方法把字符串转换为字符数组，遍历数组

(4) 其他功能

• 替换

String replace(char oldChar, char newChar) 用 newChar 替换此字符串中出现的所有 oldChar 得到一个新的字符串返回
String replaceAll(String regex, String replacement) 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

• 去除字符串两端的空格

String trim() 忽略前导空白和尾部空白并返回字符串的副本

• 比较

int compareTo(String anotherString) 按字典顺序比较两个字符串,区分大小写；
int conpareToIgnoreCase(String anotherString) 按字典顺序比较两个字符串，不区分大小写。

int compareTo()方法
比较过程：如果两个字符串的第一个字符不同，则返回两个字符的ACSII码差值
如果字符相同，则继续往下比；如果都一样，则返回0.
如果像"hello"和"hel"这种类型，则返回两个字符串长度之差。
示例：

package cn.itcast;

public class demo {
    public static void main(String[] args) {
        String s1 = "HelloWorld";
        String s2 = "Hello";
        System.out.println(s1.compareTo(s2)); //输出的是S1的长度和s2的长度之差

    }
}

输出结果：
		5

compareTo()方法源码：

   public int compareTo(String anotherString) {
        int len1 = value.length;    //自己的长度--s1
        int len2 = anotherString.value.length;     //另一个字符串的长度--s2
        int lim = Math.min(len1, len2);  //lim为两个长度中最小值
        char v1[] = value;   //把自己转换为字符数组，相当于s1.toCharArray()
        char v2[] = anotherString.value;  //另一个字符转换为字符数组，相当于s2.toCharArray()

        int k = 0;  //用于记录比较的次数
        while (k < lim) {    //当次数<两个字符串长度的最小值时进入比较
            char c1 = v1[k];
            char c2 = v2[k];
            if (c1 != c2) {
                return c1 - c2;     //如果字符不同，则返回两个字符的ASCII码差值
            }
            k++;
        }
        return len1 - len2;    //如果前面比较的字符都相同，则返回长度相减
    }