day11

day11

一、String类

String 类代表字符串。Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。 比如随便在程序中定义一个 “HelloWorld” 只要是在双引号之中，就都属于String类型的对象。

字符串是常量，它们的值在创建之后不能更改。

1.1 构造方法

String() 
String(byte[] bytes) 
String(byte[] bytes, int offset, int length) 
String(char[] value) 
String(char[] value, int offset, int count) 
String(String original) 

public class Demo {

    public static void main(String[] args) {

        //String()      创建一个空的字符串对象，相当于一个 ""
//        String s = new String();
        //注意：经过验证我们发现String类中的toString方法已经重写了，并且打印的是字符串中的内容
//        System.out.println(s);
//        System.out.println(s.toString());

        //String(byte[] bytes)   将一个字节数组转为一个字符串
//        byte[] bys = {97, 98, 99, 100, 101};
//        String s = new String(bys);
//        System.out.println(s);          //abcde

        //String(byte[] bytes, int offset, int length)   将字节数组的一部分转为字符串（从offset开始length个长度的长度）
//        byte[] bys = {97, 98, 99, 100, 101};
//        String s = new String(bys, 2, 3);
//        System.out.println(s);    //cde
//        String s2 = new String(bys, 1, 2);
//        System.out.println(s2);   //bc

        //String(char[] value)      将一个字符数组转为一个字符串
//        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        String s = new String(chs);
//        System.out.println(s);      //abcde

        //String(char[] value, int offset, int count)       将字符数组的一部分转为字符串（从offset开始count个长度的长度）
//        char[] chs = {'a', 'b', 'c', 'd', 'e'};
//        String s = new String(chs, 4, 1);
//        System.out.println(s);       //e

        //String(String original)
        String s = new String("abcde");
        System.out.println(s);        //abcde

    }
}

注意：字符串String实际上是由数组组成的，只不过JDK8之前是由字符数组组成，而JDK9之后变为了字节数组组成

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Nc3xLibf-1620291189773)(img/image-20210420102504213.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-S7cerpev-1620291189775)(img/image-20210420113807699.png)]

1.2 创建对象两种方式的区别

两种方式

方式一：通过构造方法创建 
	byte[] bys = {97, 98, 99};
	String s = new String(bys);
	
方式二：直接赋值创建
	String s = "abc";
	
以上两种方式都可以创建出来一个字符串abc，但是是有区别的
	方式一构造方法创建，内容虽然是相同的，但是因为涉及到了new对象，所以每一个对象的地址都是不相同的
	方式二直接赋值创建，内容都是直接从常量池中获取的，并且相同内容的字符串常量是共享的，所以每一个对象的地址都是一模一样的

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-K79F5722-1620291189776)(img/image-20210420104541239.png)]

1.3 常见方法

判断功能

boolean equals(Object anObject) 
boolean equalsIgnoreCase(String anotherString) 
boolean contains(CharSequence s) 
boolean startsWith(String prefix)   
boolean endsWith(String suffix)  
boolean isEmpty() 

public class Demo3 {

    public static void main(String[] args) {

        String s = "HelloWorld";
        String s2 = new String("HelloWorld");

        //boolean equals(Object anObject)    比较两个字符串的内容是否相同
        //此方法的形式参数要的是Object类型（注意：Object类型是所有类型的父类），所以我们可以放String类型
        //注意：String中重写了equals方法，并且比较的是字符串的内容
//        System.out.println(s.equals(s2));            //true
//        System.out.println(s.equals("helloWorld"));  //false

        //boolean equalsIgnoreCase(String anotherString)   忽略大小写的比较两个字符串的内容是否相同
//        System.out.println(s.equalsIgnoreCase("helloWorld"));   //true
//        System.out.println(s.equalsIgnoreCase("Hello"));        //false

        //boolean contains(String s)        判断一个字符串中是否包含另外一个字符串（这个字符串必须要是连续的）
//        System.out.println(s.contains("abc"));   //false
//        System.out.println(s.contains("HeWo"));  //false
//        System.out.println(s.contains("lloWo")); //true

        //boolean startsWith(String prefix)  判断字符串是否以传入的字符串开头
//        System.out.println(s.startsWith("Hello"));           //true
//        System.out.println(s.startsWith("World"));           //false
//        System.out.println(s.startsWith("HelloWorld"));      //true

        //boolean endsWith(String suffix)    判断字符串是否以传入的字符串结尾
//        System.out.println(s.endsWith("Hello"));           //false
//        System.out.println(s.endsWith("World"));           //true
//        System.out.println(s.endsWith("HelloWorld"));      //true

        //boolean isEmpty()  判断字符串是否为空
        System.out.println(s.isEmpty());    //false
        System.out.println("".isEmpty());   //true
        System.out.println(" ".isEmpty());  //false

    }
}

==和equals的区别

==： 既可以比较基本数据类型，也可以比较引用数据类型
		比较基本数据类型，比较的是具体的值
		比较引用数据类型，比较的是地址
	
equals方法：只能用来比较引用数据类型
		重写之前（也就是Object中的equals方法），比较的是地址值是否相同
		重写之后（也就是String将Object中的equals方法重写了），比较的是内容是否相同

public class Demo4 {

    public static void main(String[] args) {

        String s = new String("HelloWorld");
        String s2 = new String("HelloWorld");

        System.out.println(s == s2);        //false
        System.out.println(s.equals(s2));   //true
        System.out.println("-----------------------");

        String ss = "HelloWorld";
        String ss2 = "HelloWorld";
        System.out.println(ss == ss2);      //true
        System.out.println(ss.equals(ss2)); //true

    }
}

练习：
模拟用户登录，通过键盘分别录入账号和密码，一共有三次机会，如果账号和密码都正确，那么显示“登录成功”,如果账号或密码不正确，那么提示“您还剩多少次机会”。如果最后一次机会也失败了，那么提示“您的账号已锁定”。请完成如上题。
	账号：admin
	密码：666
涉及到的内容：变量、键盘录入、分支结构、循环结构、逻辑运算符、equals方法、跳转语句

public class Test {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //写一个for循环，提供三次机会
        for(int i = 2; i >= 0; i--){  //i = 2 1 0

            //放在for循环中，目的是每进行一次循环，都能重新接收一遍新的账号和密码
            System.out.println("请输入您的账号");
            String username = sc.nextLine();
            System.out.println("请输入您的密码");
            String password = sc.nextLine();

             //判断账号和密码是否都正确
            if(username.equals("admin") && password.equals("666")){
                //正确
                System.out.println("登录成功");
                break;    //因为有一个for要执行三次，如果第一次就完全正确，那么就通过break退出，不用再去执行剩余的两次了
            }else{
                //账号或密码不正确
                if(i == 0){
                    //这是最后一次机会，直接提示已锁定
                    System.out.println("您的账号已锁定");
                }else{
                    System.out.println("您还剩" + i + "次机会");
                }
            }
        }

    }
}

获取功能

char charAt(int index)  
int length()  
String substring(int beginIndex)  
String substring(int beginIndex, int endIndex)  
String concat(String str)  

int indexOf(int ch)  
int indexOf(int ch, int fromIndex)  
int indexOf(String str)  
int indexOf(String str, int fromIndex)  
    
注意：字符串也有索引，索引也是从0开始的

public class Demo5 {

    public static void main(String[] args) {

        String s = "HelloWorld";

        //char charAt(int index)   获取字符中指定索引处的字符
//        System.out.println(s.charAt(0));        //H
//        System.out.println(s.charAt(1));        //e

        //int length()             获取字符串中字符的个数（实际上就是字符串的长度）
//        System.out.println(s.length());           //10

        //使用charAt和length方法遍历字符串，获取字符串中每一个字符
//        for(int i = 0; i < s.length(); i++){
//
//            System.out.println(s.charAt(i));
//        }

        //String substring(int beginIndex)    返回一个新的字符串，它是此字符串的一个子字符串。该子字符串从指定索引处的字符开始，直到此字符串末尾。（包括起始的索引）
//        System.out.println(s.substring(0));     //HelloWorld
//        System.out.println(s.substring(5));     //World

        //String substring(int beginIndex, int endIndex)    （包括开头，不包括结尾）
//        System.out.println(s.substring(0, 5));    //Hello
//        System.out.println(s.substring(3, 7));    //loWo

        //String concat(String str)     拼接两个字符串
//        String ss = "China";
//        System.out.println(s.concat(ss));       //HelloWorldChina

        //int indexOf(int ch)           获取一个字符在字符串中第一次的索引
//        System.out.println(s.indexOf('H'));  //0
//        System.out.println(s.indexOf('o'));  //4

        //int indexOf(int ch, int fromIndex)    返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。
//        System.out.println(s.indexOf('o', 5));  //6

        //int indexOf(String str)
//        String ss = "Hellowolorlold";
//        System.out.println(ss.indexOf("lo"));   //3

        //int indexOf(String str, int fromIndex)
        String ss = "Hellowolorlold";
        System.out.println(ss.indexOf("lo", 4));    //7

    }
}

练习：
	1. 键盘录入一个字符串，通过程序统计字符串中大写字母、小写字母、数字字符出现的次数，并输出（不考虑其它字符的情况）
	2. 将数组{11, 22, 33}转换为如下格式 [11, 22, 33]的字符串，并输出。
			int[] arr = {11, 22, 33};

import java.util.Scanner;

/*
    键盘录入一个字符串，通过程序统计字符串中大写字母、小写字母、数字字符出现的次数，并输出（不考虑其它字符的情况）
 */
public class Test2 {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串：");
        String s = sc.nextLine();

        //统计次数的变量
        int small = 0;
        int big = 0;
        int number = 0;

        //遍历字符串获取字符中每一个字符
        for(int i = 0; i < s.length(); i++){

            char ch = s.charAt(i);
            if(ch >= 'a' && ch <= 'z'){
                small++;
            }
            if(ch >= 'A' && ch <= 'Z'){
                big++;
            }
            if(ch >= '0' && ch <= '9'){
                number++;
            }
        }

        //输出结果
        System.out.println("小写字母有：" + small + "个");
        System.out.println("大写字母有：" + big + "个");
        System.out.println("数字有：" + number + "个");

    }
}

/*
    将数组{11, 22, 33}转换为如下格式 [11, 22, 33]的字符串，并输出。
			int[] arr = {11, 22, 33};
 */
public class Test4 {

    public static void main(String[] args) {

        int[] arr = {11, 22, 33};

        //定义一个字符串用来存储最后的结果
        String s = "[";

        //1. 遍历数组获取到每一个数据
        for (int i = 0; i < arr.length; i++) {

            int number = arr[i];
            if(i == arr.length-1){
                //如果是最后一个元素，那么拼接上最后一个元素，并且拼接上 "]"
                s = s + number + "]";
            }else{
                //如果不是最后一个元素，那么拼接上当前元素，并且拼接上 ", "
                s = s + number + ", ";
            }

        }

        //输出结果
        System.out.println(s);
    }
}

转换功能

byte[] getBytes() 
char[] toCharArray() 
String toUpperCase() 
String toLowerCase()  
String toString()  

valueOf系列：
static String valueOf(int i) 

public class Demo6 {

    public static void main(String[] args) {

        String s = "HelloWorld";

        //byte[] getBytes()   将字符串转为字节数组
//        byte[] bys = s.getBytes();
//        for (int i = 0; i < bys.length; i++) {
//            System.out.print((char)bys[i]);
//        }

        //char[] toCharArray() 将字符串转为字符数组
//        char[] chs = s.toCharArray();
//        for (int i = 0; i < chs.length; i++) {
//            System.out.print(chs[i]);
//        }

        //String toUpperCase()  将字符串中的小写字母都转为大写的
//        System.out.println(s.toUpperCase());      //HELLOWORLD

        //String toLowerCase()  将字符串中的大写字母都转为小写的
//        System.out.println(s.toLowerCase());      //helloworld

        //String toString()  返回此对象本身
//        System.out.println(s.toString());         //HelloWorld

        //static String valueOf(int i)  将整数类型转为字符串类型
        String ss = String.valueOf(666);
        System.out.println(ss);     //666

    }

}

练习：
	有一个字符串 "i loVe jAVA"改为"I love java"（也就是字符串的第一个字符改为大写，其余字符都改为小写），然后输出

public class Test5 {

    public static void main(String[] args) {

        String s = "i loVe jAVA";

        //1. 获取字符串的第一个字符，并转为大写状态
        String s1 = s.substring(0, 1).toUpperCase();
        //2. 获取字符串的剩余部分，并转为小写状态
        String s2 = s.substring(1).toLowerCase();
        //3. 拼接以上两个字符串
        String ss = s1.concat(s2);
        System.out.println(ss);

        System.out.println("-----------------");

        //链式编程 【不推荐，可读性很差】
        System.out.println(s.substring(0, 1).toUpperCase().concat(s.substring(1).toLowerCase()));
    }
}

其它功能

String trim()  
String replaceAll(String regex, String replacement) 
String[] split(String regex)  

public class Demo7 {

    public static void main(String[] args) {

        //String trim()  去除字符串两端的空格
//        String s = "   Hello  World     ";
//        System.out.println(s.trim());

        //String replaceAll(String regex, String replacement)   用新的字符串，替换所有符合规则的旧字符串
//        String s = "HelloWorld";
//        System.out.println(s.replaceAll("o", "p"));   //HellpWprld

        //String[] split(String regex)   根据传入的字符串将原来进行分割，并且组成一个新的字符串数组
        String s = "2021-4-20";
        String[] split = s.split("-");
        for (int i = 0; i < split.length; i++) {

            System.out.println(split[i]);
        }

    }
}

ln(s.trim());

    //String replaceAll(String regex, String replacement)   用新的字符串，替换所有符合规则的旧字符串

// String s = “HelloWorld”;
// System.out.println(s.replaceAll(“o”, “p”)); //HellpWprld

    //String[] split(String regex)   根据传入的字符串将原来进行分割，并且组成一个新的字符串数组
    String s = "2021-4-20";
    String[] split = s.split("-");
    for (int i = 0; i < split.length; i++) {

        System.out.println(split[i]);
    }

}

}