黑马程序员————java基础————常用类String类

                                              ——- android培训、java培训、期待与您交流！ ———-

常见对象(String类的概述)(掌握)

    A:什么是字符串
        字符串是由多个字符组成的一串数据(字符序列)
        字符串可以看成是字符数组
    B:String类的概述    
        通过JDK提供的API，查看String类的说明
        
        可以看到这样的两句话。
        a:字符串字面值"abc"也可以看成是一个字符串对象。
        b:字符串是常量，一旦被创建，就不能被改变。

常见对象(String类的构造方法)(掌握)

    A:常见构造方法
        public String():空构造
        public String(byte[] bytes):把字节数组转成字符串    
        public String(byte[] bytes,int index,int length):把字节数组的一部分转成字符串
                                //(index:表示的是从第几个索引开始, length表示的是长度)

        public String(char[] value):把字符数组转成字符串
        public String(char[] value,int index,int count):把字符数组的一部分转成字符串
        public String(String original):把字符串常量值转成字符串
    
        

常见对象(String的特点一旦被创建就不能改变)(掌握)

    A:String的特点
        一旦被创建就不能改变
    B:案例演示    
        a:如何理解这句话
            String s = "hello"; s += "world"; 问s的结果是多少?
            "helloworld"。字符串对象一旦被创建就不能改变，但它的引用可以改变。
            s+="world";是对引用s做操作，实际是将s指向常量池中的"helloworld"

        b:画内存图解释

            内容不能变，引用可以变

常见对象(String类的常见面试题)(掌握)

    A:面试题1
        String s = new String(“hello”)和String s = “hello”;的区别
        前者创建了两个对象一个在堆内存一个在常量池，后者只创建了一个对象在常量池
    B:面试题2
        ==和equals()的区别?
        前者比较的是地址值，后者比较的是内容
    C:面试题3
        看程序写结果

        String s1 = new String("hello");        String s2 = new String("hello");        System.out.println(s1 == s2);        //false  一个对象一个地址值        System.out.println(s1.equals(s2));    //true    比较内容        String s3 = new String("hello");        String s4 = "hello";        System.out.println(s3 == s4);        //false  s3的引用在堆内存中，s4的在方法区中的常量池        System.out.println(s3.equals(s4));    //true    内容一样        String s5 = "hello";        String s6 = "hello";        System.out.println(s5 == s6);        //true    都指向常量池中的一个地址        System.out.println(s5.equals(s6));    //true    内容一样

    D:面试题4
        看程序写结果

        String s1 = "hello";        String s2 = "world";        String s3 = "helloworld";        String s4 = "hello" + "world" ;        System.out.println( s3 == s1 + s2);    //false  变量相加底层用的是StringBuffer，                                            //s1+s2的地址值指向堆内存中        System.out.println( s3 == s4 );        //true   java优化机制，字符串和字符串相加引向常量池，                                            //所以地址值相同        System.out.println( s3.equals((s1 + s2)));//true  内容一样常见对象

常见对象(String类的判断功能)(掌握)

    A:String类的判断功能
        public boolean equals(Object obj):                比较字符串的内容是否相同,区分大小写
        public boolean equalsIgnoreCase(String str):    比较字符串的内容是否相同,忽略大小写
        public boolean contains(String str):            判断字符串中是否包含传递进来的字符串
        public boolean startsWith(String str):            判断字符串是否以传递进来的字符串开头
        public boolean endsWith(String str):            判断字符串是否以传递进来的字符串结尾
        public boolean isEmpty():                        判断字符串的内容是否为空。
    

常见对象(模拟用户登录)(掌握)

    A:案例演示
        需求：模拟登录,给三次机会,并提示还有几次。

import java.util.Scanner;public class LianXi {    public static void main(String[] args) {        // 需求：模拟登录,给三次机会,并提示还有几次。        /*         * 1.模拟: 用户名 admin 密码 helloworld 2.键盘录入接收数据 用户名 密码 3. 定义登录的次数变量         *         * 匹配 用户名和 密码和 模拟的做比较 如果 : 成功 : 登录成功         *         * 否则 : 错误 , 提示还有几次机会         */        // 模拟 用户        String username = "admin";        String password = "helloworld";        System.out.println("欢迎光临~~~~~");        // 接收 键盘录入        Scanner sc = new Scanner(System.in);        int limit = 3; // 限制次数        int count = 0;        while (count < limit) {            count++;            System.out.println("请输入用户名: "); // 如果做循环输入,你必须在录入处循环            String name = sc.nextLine();            System.out.println("请输入密码: ");            String pw = sc.nextLine();            // 判断            if (username.equals(name) && password.equals(pw)) {                System.out.println("用户登录成功! ");                return;            } else {                if (count == limit) {                    System.out.println("用户名或者密码错误,次数已到,请联系客服妹子!");                    return;                } else {                    System.out.println("用户名或者密码错误,请重新输入!");                    // 提示还有几次机会                    System.out.println("您今日还有 " + (limit - count) + " 次机会");                }            }        }    }}

常见对象(String类的获取功能)(掌握)

    A:String类的获取功能
        public int length():                            获取字符串的长度。
        public char charAt(int index):                    获取指定索引位置的字符
        public int indexOf(int ch):                        返回指定字符在此字符串中第一次出现处的索引。
        public int indexOf(String str):                    返回指定字符串在此字符串中第一次出现处的索引。
        public int indexOf(int ch,int fromIndex):            返回指定字符在此字符串中从指定位置后第一次出现处的索引。
        public int indexOf(String str,int fromIndex):        返回指定字符串在此字符串中从指定位置后第一次出现处的索引。
            
        public String substring(int start):                从指定位置开始截取字符串,默认到末尾。
        public String substring(int start,int end):        从指定位置开始到指定位置结束截取字符串。
    
常见对象(字符串的遍历)(掌握)

    A:案例演示
        需求：遍历字符串

public class LianXi {    public static void main(String[] args) {        String s = "爱我中华";        for(int i=0;i<s.length();i++){        System.out.println(s.charAt(i));        }    }}        常见对象(统计不同类型字符个数)(掌握)    A:案例演示        需求：统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)public class LianXi {    public static void main(String[] args) {        String s = "kd1K52djfAdf56FDd3df54";        // 定义变量        int countD = 0; // 统计大写的        int countX = 0; // 统计小写的        int countN = 0; // 统计数字的        // 遍历 使用charAt 获取到每一个字符        for (int i = 0; i < s.length(); i++) {            // 获取到每一个字符            char ch = s.charAt(i);            // 比较 每一个字符 的范围 'A' countDa++ 'Z' | 'a' countXiao++ 'z' | 0            // countNum++ 9|            if (ch >= 'A' && ch <= 'Z') {                // 说明 ch 是大写字母                countD++;            } else if (ch >= 'a' && ch <= 'z') {                countX++;            } else if (ch >= '0' && ch <= '9') {                countN++;            }        }        // 输出        System.out.println("大写字母个数 : " + countD);        System.out.println("小写字母个数 : " + countX);        System.out.println("数字个数 : " + countN);    }}

常见对象(String类的转换功能)(掌握)

    A:String的转换功能：
        public byte[] getBytes():                    把字符串转换为字节数组。
        public char[] toCharArray():                    把字符串转换为字符数组。
        public static String valueOf(char[] chs):            把字符数组转成字符串。
        public static String valueOf(int i):                把int类型的数据转成字符串。
            注意：String类的valueOf方法可以把任意类型的数据转成字符串。
        public String toLowerCase():                    把字符串转成小写。
        public String toUpperCase():                    把字符串转成大写。
        public String concat(String str):                把字符串拼接。
    
        
常见对象(按要求转换字符)(掌握)

    A:案例演示
        需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)

public class LianXi {    public static void main(String[] args) {        // * A:案例演示        // 需求：把一个字符串的首字母转成大写，其余为小写。(只考虑英文大小写字母字符)        String s = "adsjfaldHHKJjflka";        // 截取第一个        String headStr = s.substring(0, 1);        // 截取后面的        String tailStr = s.substring(1);        // 第一个变大写,其他变小写        String upperCase = headStr.toUpperCase();        String lowerCase = tailStr.toLowerCase();        // 拼起来        String newStr = upperCase + lowerCase;        // 输出        System.out.println(newStr);    }}

        //以上可以简化成以下格式，你看懂了吗？
 

   String concat = s.substring(0, 1).toUpperCase().concat(s.substring(1).toLowerCase());        System.out.println(concat);

常见对象(String类的其他功能)(掌握)

    A:String的替换功能
        public String replace(char old,char new)        将指定字符进行互换
        public String replace(String old,String new)        将指定字符串进行互换
    B:String的去除字符串两空格
        public String trim()                    去除两端空格
    C:String的按字典顺序比较两个字符串
        public int compareTo(String str)
        public int compareToIgnoreCase(String str)

常见对象(把数组转成字符串)(掌握)

    A:案例演示
        需求：把数组中的数据按照指定个格式拼接成一个字符串
            举例：
                int[] arr = {1,2,3};    
            拼接结果：
                "[1, 2, 3]"

public class LianXi {    public static void main(String[] args) {        //定义一个int类型数组        int[] arr = {1,2,3};        //定义一个String类型变量temp进行拼接        String temp = "[";        //遍历数组进行拼接        for (int i = 0; i < arr.length; i++) {            if (i!= arr.length-1) {                temp += arr[i]+", ";            }else{                temp += arr[i] +"]";            }                    //输出        System.out.println(temp);        }    }    }    

常见对象(字符串反转)(掌握)

    A:案例演示
        需求：把字符串反转
            举例：键盘录入"abc"        
            反转结果："cba"

/* * 字符串反转 * 举例：键盘录入”abc”         * 输出结果：”cba” * * 分析： *         A:键盘录入一个字符串 *         B:定义一个新字符串 *         C:倒着遍历字符串，得到每一个字符 *             a:length()和charAt()结合 *             b:把字符串转成字符数组 *         D:用新字符串把每一个字符拼接起来 *         E:输出新串 */import java.util.Scanner;public class LianXi {    public static void main(String[] args) {        // 键盘录入一个字符串        Scanner sc = new Scanner(System.in);        System.out.println("请输入一个字符串：");        String line = sc.nextLine();        // 定义一个新字符串        String result = "";        // 把字符串转成字符数组        char[] chs = line.toCharArray();        // 倒着遍历字符串，得到每一个字符        for (int x = chs.length - 1; x >= 0; x--) {            // 用新字符串把每一个字符拼接起来            result += chs[x];        }        // 输出新串        System.out.println("反转后的结果是：" + result);    }}

常见对象(在大串中查找小串出现的次数代码实现)(掌握)

    A:案例演示    
        统计大串中小串出现的次数

/* * 统计大串中小串出现的次数 * 举例： *         在字符串"woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun" *         java出现了几次 * * 分析： *         前提：是已经知道了大串和小串。 * *         A:定义一个统计变量，初始化值是0 *         B:先在大串中查找一次小串第一次出现的位置 *             a:索引是-1，说明不存在了，就返回统计变量 *             b:索引不是-1，说明存在，统计变量++ *         C:把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串 *         D:回到B */public class LianXi {    public static void main(String[] args) {        // 定义大串        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";        // 定义小串        String minString = "java";        // 写功能实现        int count = getCount(maxString, minString);        System.out.println("Java在大串中出现了：" + count + "次");    }    /*     * 两个明确： 返回值类型：int 参数列表：两个字符串     */    public static int getCount(String maxString, String minString) {        // 定义一个统计变量，初始化值是0        int count = 0;        // 先在大串中查找一次小串第一次出现的位置        int index = maxString.indexOf(minString);        // 索引不是-1，说明存在，统计变量++        while (index != -1) {            count++;            // 把刚才的索引+小串的长度作为开始位置截取上一次的大串，返回一个新的字符串，并把该字符串的值重新赋值给大串            int startIndex = index + minString.length();            maxString = maxString.substring(startIndex);            // 继续查            index = maxString.indexOf(minString);        }        return count;    }}

常见对象(在大串中查找小串出现的次数代码优化)(掌握)

    上面的代码我们还可以进行优化

public class LianXi {    public static void main(String[] args) {        // 定义大串        String maxString = "woaijavawozhenaijavawozhendeaijavawozhendehenaijavaxinbuxinwoaijavagun";        // 定义小串        String minString = "java";        // 写功能实现        int count = getCount(maxString, minString);        System.out.println("Java在大串中出现了：" + count + "次");    }    /*     * 两个明确： 返回值类型：int 参数列表：两个字符串     */    public static int getCount(String maxString, String minString) {        // 定义一个统计变量，初始化值是0        int count = 0;        int index;        //先查，赋值，判断        while((index=maxString.indexOf(minString))!=-1){            count++;            maxString = maxString.substring(index + minString.length());        }        return count;    }}

是不是更简单了呢
通过API的学习我们会发现，很多有用的方法java已经给我们提供了，我们只需记住他们的用法和格式
就会给我们开发带来很大的帮助