黑马程序员————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
4000
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已经给我们提供了，我们只需记住他们的用法和格式

就会给我们开发带来很大的帮助