15_常用API_第15天（Object、String、StringBuffer、用户登陆注册）_讲义

水深无声 2022-04-18 05:23 139阅读 0赞

今日内容介绍  
1、Object  
2、String  
3、StringBuilder  
第1章 Java的API及Object类  
在以前的学习过程中，我们都在学习对象基本特征、对象的使用以及对象的关系。接下来我们开始使用对象做事情，那么在使用对象做事情之前，我们要学习一些API中提供的常用对象。首先在学习API中的Object类之前,先来学习如何使用API。  
1.1 Java 的API  
Java 的API（API: Application(应用) Programming(程序) Interface(接口)）  
Java API就是JDK中提供给我们使用的类，这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可。  
在JDK安装目录下有个src.zip文件，这个文件解压缩后里面的内容是所有Java类的源文件。可以在其中查看相对应的类的源码。  
我们在每次查看类中的方法时，都打开源代码进行查看，这种方式过于麻烦。其实，我们可以通过查帮助文档的方式，来了解Java提供的API如何使用。如下图操作：查找Object类  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]  
通过帮助文档中类与方法的介绍，我们就能够使用这个类了。  
1.2 Object类概述  
Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。  
在Object类众多方法中，我们先学习equals方法与toString方法，其他方法后面课程中会陆续学到。  
1.3 equals方法  
![在这里插入图片描述][20181110100703492.jpg]  
equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是比较运算符。  
在开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较，也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。  
03 equals方法比较内存地址  
A:equals方法比较内存地址  
a: Object类中的equals方法  
用于比较两个对象是否相同，Object类中就是使用两个对象的内存地址在比较。  
Object类中的equals方法内部使用的就是比较运算符。  
b: 案例代码  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]

package cn.itcast.demo;
    
    public class Person {
    	private String name;
    	private int age;
    	//无参函数
    	public Person(){}
    	
    	//满参函数
    	public Person(String name, int age) {
    		this.name = name;
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	/*
    	 * 将父类的equals方法写过来,重写父类的方法
    	 * 但是,也不改变父类方法的源码,方法equals比较两个对象的内存地址
    	 */
    	public boolean equals(Object obj){
    		return this == obj;
    	}
    	
    }

package cn.itcast.demo;
    
    public class TestEquals {
    
    	public static void main(String[] args) {
    		//Person类继承Object类,继承下来了父类的方法equals
    		Person p1 = new Person("张三",12);
    		Person p2 = new Person("张三",22);
    		
    		//Person对象p1,调用父类的方法equals,进行对象的比较
    		//正常两个对象new出来,内存地址是不同的,没有可比性
    		System.out.println(p1.equals(p2));
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]  
04 重写equals方法  
A: 重写equals方法  
**a: 开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较  
b: 在开发经常需要子类重写equals方法根据对象的属性值进行比较。**  
**c: ==号和equals方法的区别**  
**==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,基本数据类型比较的是值,引用数据类型比较的是地址值**  
**equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,如果没有重写Object类中的equals方法,**  
equals方法和==号比较引用数据类型无区别,**重写后的equals方法比较的是对象中的属性**  
d: 案例代码  
注意：在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。

package cn.itcast.demo01;
    
    public class Person extends Object{
    	private String name;
    	private int age;
    	
    	public Person() {
    		super();	
    	}
    	public Person(String name,int age) {
    		this.name = name;
    		this.age = age;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	/*
    	 * 	重写Object类equals方法
    	 * 比较两个对象的内存地址
    	 * 比较两个对象的成员变量age
    	 * 两个对象成员变量age,相同返回true,不同返回true
    	 * 重写父类equals方法,自己定义自己对象的比较方式
    	 */
    	public boolean equals(Object obj){
    		//以下加的健壮性判断
    		//1.跟自己比,没有意义
    		//boolean b2 = p1.equals(p1)
    		if(this == obj){
    			return true;
    		}
    		
    		//2.对参数obj,非null判断
    		//boolean b1 = p1.equals(null);
    		if(null == obj){
    			return false;
    		}
    		
    		//3.
    		if(obj instanceof Person){
    			//多态的弊端：无法执行子类的特有内容
    			//需要向下转型,obj转成Person类型
    			Person p = (Person)obj;
    			System.out.println("子类重写了");
    			return this.age == p.age;
    		}
    		return false;
    	}
    	/*
    	 * 重写父类的toString()
    	 * 没有必要让调用者看到内存地址
    	 * 要求：方法中,返回类中所有成员变量(不能写静态方法,因为这个是需要对象调用)
    	 * 重写toString方法的好处
    	 */
    	public String toString(){
    		return name+age;
    	}
    }

package cn.itcast.demo01;
    
    import java.util.ArrayList;
    
    /*
     * equals方法，用于比较两个对象是否相同
     * 它其实就是使用两个对象的内存地址在比较
     * Object类中的equals方法内部使用的就是==比较运算符。
     */
    public class TestEquals {
    
    	public static void main(String[] args) {
    		//Person类继承Object类,继承下来父类的方法equals
    		Person p1 = new Person("张三",12);
    		Person p2 = new Person("张三",12);
    		//正常两个对象new出来,内存地址是不同的,没有可比性
    		System.out.println(p1.equals(p2));//1
    		
    		//让两个内存地址相同,输出才会true
    		p1 = p2;
    		//Person对象P1,调用父类的方法equals
    		//比较两个对象的内存地址
    		System.out.println(p1.equals(p2));//2
    		//这里可说明：public boolean equals(Object obj)
    		//这个十分有风险性,什么类型都能给Object类型给吸收掉,但是只能是Person才接受
    		ArrayList<String> array = new ArrayList<>();
    		boolean b = p1.equals(array);
    		System.out.println(b);//3
    		//null
    		boolean b1 = p1.equals(null);
    		System.out.println(b1);//4
    		//调用者是自己
    		boolean b2 = p1.equals(p1);
    		System.out.println(b2);//5
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]  
1.4 toString方法  
![在这里插入图片描述][20181110100858889.jpg]

package cn.itcast.demo01;
    
    import java.util.Random;
    import java.util.Scanner;
    
    public class TestToString {
    
    	public static void main(String[] args) {
    		//调用Person类的方法toString()
    		//输出语句,写的是一个对象,默认调用对象的toString方法
    		Person p = new Person("张三",20);
    		String s = p.toString();
    		System.out.println(p);
    		System.out.println(s);
    		/*
    		 * System.out.println(p)
    		 * System.out.println(p.toString())
    		 */
    		Random r = new Random();
    		System.out.println(r.toString());
    		
    		Scanner sc = new Scanner(System.in);
    		System.out.println(sc.toString());
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]  
**toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。**  
**由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。**

class Person extends Object{
    	int age ;
    	//根据Person类的属性重写toString方法
    	public String toString() {
    		return "Person [age=" + age + "]";
    	}
    }

第2章 String类  
2.1 String类的概念和不变性  
A: String类的概念和不变性  
a:String类  
API中的String类的描述，发现String 类代表字符串  
Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。  
字符串是常量,在创建之后不能更改  
其实就是说一旦这个字符串确定了，那么就会在内存区域中就生成了这个字符串。字符串本身不能改变，但str变量中记录的地址值是可以改变的。  
源码分析,String类底层采用的是字符数组:  
private final char value\[\]  
private 修饰说明value只能在String类内部使用,而且又没有提供get方法,所以外部无法获取value数组,就无法改变数组中元素的值  
final修饰说明value是常量,一旦创建,就不能被改变,value一旦被初始化成某个数组,将永远指向这个数组,不可能再指向其它的数组了  
b: 案例代码

package cn.itcast.demo02;
    /*
     * String类特点：
     * 		一切都是对象,字符串事物""也是对象
     * 		类是描述事物,String类, 描述字符串对象的类
     * 		所有的""都是String类的对象
     * 
     * 字符串是一个常量,一旦创建,不能改变
     *  private final char value[];
     *  定义一维数组,[]写char[] 或者卸载value[]都可以
     */
    public class StringDemo {
    	public static void main(String[] args) {
    		//引用变量str指向内存变化
    		//定义好的字符串对象不变,一旦生成,不允许改变
    		String str = "itcast";
    		//因为String类重写了Object父类的toString方法
    		System.out.println(str);
    		str = "itheima";
    		System.out.println(str);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]  
2.1 String类创建方式和比较  
A: String类创建方式和比较  
a: 创建对象的数量比较  
String s3 = “abc”;  
在内存中只有一个对象。这个对象在字符串常量池中  
String s4 = new String(“abc”);  
在内存中有两个对象。一个new的对象在堆中，一个字符串本身对象，在字符串常量池中  
b: 案例代码

package cn.itcast.demo02;
    /*
     * equals方法，用于比较两个对象是否相同，
     * 它其实就是使用两个对象的内存地址在比较。
     * Object类中的equals方法内部使用的就是==比较运算符
     */
    public class StringDemo2 {
    	public static void main(String[] args) {
    		//字符串定义方式2个,直接= 使用String类的构造方法
    		String str1 = new String("abc");
    		String str2 = "abc";
    		System.out.println(str1);
    		System.out.println(str2);
    		//引用数据类型,比较对象的地址false
    		System.out.println(str1 == str2);
    		//String类继承Object,重写了父类的方法equals,建立了字符串自己的比较方式
    		//字符串中每个字符是否相同
    //		 public boolean equals(Object anObject) {
    //		        if (this == anObject) {
    //		            return true;
    //		        }
    //		        if (anObject instanceof String) {
    //		            String anotherString = (String) anObject;
    //		            int n = value.length;
    //		            if (n == anotherString.value.length) {
    //		                char v1[] = value;
    //		                char v2[] = anotherString.value;
    //		                int i = 0;
    //		                while (n-- != 0) {
    //		                    if (v1[i] != v2[i])
    //		                            return false;
    //		                    i++;
    //		                }
    //		                return true;
    //		            }
    //		        }
    //		        return false;
    //		    }
    		System.out.println(str1.equals(str2));//true
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]  
2.2 String类构造方法  
A: String类构造方法  
a: 常见构造方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]

package cn.itcast.demo02;
    /*
     * String类构造方法
     * String类的构造方法,重载方式
     */
    public class StringDemo3 {
    	public static void main(String[] args) {
    		function();
    		System.out.println();
    		funtion_1();
    	}
    	/*
    	 * String(char[] value) 传递字符数组
    	 * 将字符数组,转成字符串,字符数组的参数,不查询编码表
    	 * 
    	 * String(char[] value, int offset, int count) 传递字符数组
    	 * value - 作为字符源的数组。
    	 * offset - 初始偏移量
    	 * count - 个数,转几个(不是结束的索引) 
    	 */
    	public static void funtion_1(){
    //		char ch[] = {'a','b','c'};
    		char[] ch = {'a','b','c'};
    		//调用String构造方法,传递字符数组
    		String s = new String(ch);
    		System.out.println(s);
    		
    		String s1 = new String(ch,0,3);
    		System.out.println(s1);
    	}
    	/*
    	 * 定义方法,String类的构造方法
    	 * String(byte[] bytes)  传递字节数组
    	 * 字节数组转成字符串
    	 * 通过使用平台的默认字符集节码指定的byte数组,构造一个新的String
    	 * 平台：指操作系统
    	 * 默认字符集：操作系统中的默认编码表,传递字节数组
    	 * 将字节数组中的每个字节,查询了编码表,得到的结果
    	 * 字节是负数,汉字的字节编码就是负数,默认编码表,一个汉字采用2个字节表示
    	 * 
    	 * String(byte[] bytes, int offset, int length) 传递字节数组
    	 * 字节数组的一部分转成字符串
    	 * offset	数组的起始索引
    	 * length	个数,转几个(不是结束的索引)
    	 */
    	public static void function(){
    		byte[] bytes = {-97,-98,-60,-61};
    		//调用String类的构造方法,传递字节数组
    		String s = new String(bytes);
    		System.out.println(s);
    		
    		byte[] bytes1 = {65,66,67,69};
    		//调用String构造方法,传递数组,传递2个int值
    		String s1 = new String(bytes1,0,2);
    		System.out.println(s1);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]  
2.3 String类的方法查找  
tring类中有很多的常用的方法，我们在学习一个类的时候，不要盲目的把所有的方法尝试去使用一遍，这时我们应该根据这个对象的特点分析这个对象应该具备那些功能，这样大家应用起来更方便。  
字符串是一个对象，那么它的方法必然是围绕操作这个对象的数据而定义的。我们想想字符串中有哪些功能呢？  
 字符串中有多少个字符?  
![在这里插入图片描述][20181111173104926.png]

String str = "abcde";
    int len = str.length();
    System.out.println("len="+len);

 获取部分字符串。  
![在这里插入图片描述][2018111117321541.png]

String str = "abcde";
    String s1 = str.substring(1); //返回一个新字符串，内容为指定位置开始到字符串末尾的所有字符
    String s2 = str.substring(2, 4);//返回一个新字符串，内容为指定位置开始到指定位置结束所有字符
    System.out.println("str="+str);
    System.out.println("s1="+s1);
    System.out.println("s2="+s2);

2.4 String类中方法查找练习  
前面给大家简单介绍了几个字符串中常用的方法，这个过程中主要让大家学会如何去查阅API，如何找到自己想用的方法。接下来我们来练习下字符串方法的查找。  
 字符串是否以指定字符串开头。结尾同理。  
![在这里插入图片描述][20181111173328972.png]

String str = "StringDemo.java";
    boolean b1 = str.startsWith("Demo");//判断是否以给定字符串开头
    boolean b2 = str.startsWith("String");
    boolean b3 = str.endsWith("java");//判断是否以给定字符串结尾

 字符串中是否包含另一个字符串。  
![在这里插入图片描述][20181111173412779.png]

String str = "abcde";
    int index = str.indexOf(“bcd”); //判断是否包含指定字符串，包含则返回第一次出现该字符串的索引，不包含则返回-1
    boolean b2 = str.contains("bcd");//判断是否包含指定字符串，包含返回true，不包含返回false

 将字符串转成一个字符数组。或者字节数组。  
![在这里插入图片描述][2018111118511495.jpg]

String str = "abcde";
    char[] chs = str.toCharArray();
    byte[] bytes = str.getBytes();

 判断两个字符串中的内容是否相同  
![在这里插入图片描述][20181111185212527.jpg]

String str = "abcde";
    String str2 = "abcde";
    String str3 = "hello";
    boolean b1 = str.equals(str2);
    boolean b2 = str.equals(str3);

 获取该字符串对象中的内容  
![在这里插入图片描述][20181111185311377.jpg]

String str = new String("hello");
    System.out.println( str.toString() );
    System.out.pintln( str );

package cn.itcast.demo02;
    /*
     * String类的查找功能
     */
    public class StringDemo4 {
    	public static void main(String[] args) {
    		System.out.println("function():");
    		function();
    		System.out.println("funtion_1():");
    		funtion_1();
    		System.out.println("funtion_3():");
    		funtion_3();
    		System.out.println("funtion_4():");
    		funtion_4();
    		System.out.println("funtion_5():");
    		funtion_5();
    		System.out.println("funtion_6():");
    		funtion_6();
    		System.out.println("funtion_7():");
    		funtion_7();
    		System.out.println("funtion_8():");
    		funtion_8();
    		System.out.println("funtion_9():");
    		funtion_9();
    	}
    	/*
    	 * boolean equals(Object anObject) 将此字符串与指定的对象比较 
    	 * boolean equalsIgnoreCase(String anotherString) 
    	 * 将此 String 与另一个 String 比较，不考虑大小写 
    	 */
    	public static void funtion_9(){
    		String str = "abc";
    		String str1 = "Abc";
    		//调用String类的方法
    		boolean b1 = str.equals(str1);
    		boolean b2 = str.equalsIgnoreCase(str1);
    		System.out.println(b1);
    		System.out.println(b2);		
    	}
    	/*
    	 *  char[] toCharArray() 将此字符串转换为一个新的字符数组 
    	 */
    	public static void funtion_8(){
    		String str = "abc";
    		//调用String类的方法
    		char[] b = str.toCharArray();
    		for (int i = 0; i < b.length; i++) {
    			System.out.println(b[i]);
    		}
    	}
    	/*
    	 *  byte[] getBytes() 
    	 * 使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
    	 */
    	public static void funtion_7(){
    		String str = "abc";
    		//调用String类的方法
    		 byte[] b = str.getBytes();
    		for (int i = 0; i < b.length; i++) {
    			System.out.println(b[i]);
    		}
    	}
    	/*
    	 * indexOf(String str) 
    	 * 返回指定子字符串在此字符串中第一次出现处的索引。
    	 */
    	public static void funtion_6(){
    		String str = "howareyou";
    		//调用String类的方法
    		int b = str.indexOf("are");
    		System.out.println(b);
    	}
    	/*
    	 * boolean contains(String s)
    	 * 判断一个字符串中,是不是包含另一个字符串
    	 */
    	public static void funtion_5(){
    		String str = "howareyou";
    		//调用String类的方法
    		boolean b = str.contains("are");
    		System.out.println(b);
    	}
    	/*
    	 * public boolean endsWith(String prefix)
    	 * 判断一个字符串是不是另一个字符串的后缀或者结尾
    	 */
    	public static void funtion_4(){
    		String str = "howareyou";
    		//调用String类的方法
    		boolean b = str.endsWith("you");
    		System.out.println(b);
    	}
    	/*
    	 * public boolean startsWith(String prefix)
    	 * 判断一个字符串是不是另一个字符串的前缀或者开头
    	 * howareyou
    	 * hOw
    	 */
    	public static void funtion_3(){
    		String str = "howareyou";
    		//调用String类的方法
    		boolean b = str.startsWith("How");
    		System.out.println(b);
    	}
    	/*
    	 * substring(int beginIndex, int endIndex) 
    	 * 返回一个新字符串，它是此字符串的一个子字符串。
    	 * beginIndex - 起始索引（包括）
    	 * endIndex - 结束索引（不包括）。 
    	 * 不包含尾巴
    	 * 
    	 * String substring(int beginIndex)获取字符串的一部分
    	 * 包含头,后面字符全要
    	 */
    	public static void funtion_1(){
    		String str = "howareyou";
    		//substring(int beginIndex, int endIndex)
    		str = str.substring(1,5);
    		System.out.println(str);
    		
    		String str2 = "Hello world";
    		//String substring(int beginIndex)获取字符串的一部分
    		str2 = str2.substring(1);
    		System.out.println(str2);
    	}
    	/*
    	 * int length() 返回字符串的长度
    	 * 包含多少个字符
    	 */
    	public static void function(){
    		String str = "adfadfgasdf";
    		//调用String类方法length,获取字符串长度
    		System.out.println(str.length());
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]  
直接打印引用类型变量时，默认调用该类型进行重写后的toString方法  
下面的需求所对应的方法，要求大家自己动手在API中查找，并进行方法使用。  
 判断该字符串的内容是否为空的字符串  
 获取给定的字符，在该字符串中第一次出现的位置  
 获取该字符串中指定位置上的字符  
 把该字符串转换成 小写字符串  
 把该字符串转换成 大写字符串  
 在该字符串中，将给定的旧字符，用新字符替换  
 在该字符串中， 将给定的旧字符串，用新字符串替换  
 去除字符串两端空格，中间的不会去除，返回一个新字符串  
2.5 String类方法使用练习  
 题目一：获取指定字符串中，大写字母、小写字母、数字的个数。  
 思路：1.为了统计大写字母、小写字母、数字的个数。创建3个计数的变量。  
2.为了获取到字符串中的每个字符，进行字符串的遍历，得到每个字符。  
3.对得到的字符进行判断，如果该字符为大写字母，则大写字母个数+1；如果该字符为小写字母，则小写字母个数+1；如果该字符为数字，则数字个数+1。  
4.显示大写字母、小写字母、数字的个数  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]

package cn.itcast.demo04;
    
    public class StringTest {
    
    	public static void main(String[] args) {
    		getCount("adfsdAAA123");
    		System.out.println(toConvert("abcdefBB"));
    		System.out.println(getStringCount("javahellojava,nihaojava,javazhenbang","java"));
    	}
    	/*
    	 * 获取一个字符串中,另一个字符串出现的次数
    	 * 思想：
    	 * 		1.indexOf到字符串中到第一次出现的索引
    	 * 		2.找到索引+被找的字符串长度,截取字符串
    	 * 		3.计数器++
    	 */
    	public  static int getStringCount(String str,String key){
    		//定义计数器
    		int count = 0;
    		//定义变量,保存indexOf查找后的索引结果
    		int index = 0;
    		//开始循环,条件,indexOf == -1 字符串查询完毕
    		while((index = str.indexOf(key)) != -1){
    			count++;
    			//获取到的索引,和字符串长度求和,用于接下来截取字符串,继续索引查询key
    			str = str.substring(index + key.length());
    		}
    		return count;
    	}
    	/*
    	 * 将字符串的首字母转成大写,其他内容转成小写
    	 * 思想：
    	 * 		获取首字母,charAt(0)-（这个用起来需要char类型）	substring(0,1)
    	 * 		转成大写toUpperCase()
    	 * 		
    	 * 		获取剩余字符串,substring(1) toLowerCase()
    	 */
    	public static String toConvert(String str){
    		//定义变量,保存首字母,和剩余字符
    		// String substring(int beginIndex, int endIndex)  
    		//返回一个新字符串，它是此字符串的一个子字符串。该子字符串从指定的 beginIndex 处开始，直到索引 endIndex - 1 处的字符。
    		//因此，该子字符串的长度为 endIndex-beginIndex。 
    		String first = str.substring(0, 1);
    		String after = str.substring(1);
    		//调用String方法,大写 小写转换
    		first = first.toUpperCase();
    		after = after.toLowerCase();
    		return first + after;
    	}
    	/*
    	 * 题目一：获取指定字符串中，大写字母、小写字母、数字的个数
    	 * 思想：
    	 * 		1.计数器,就是int变量,满足条件++
    	 * 		2.遍历字符串,长度方法length() + charAt()遍历
    	 * 		3.字符判断是大写,小写还是数字
    	 */
    	public static void getCount(String str){
    		//定义三个变量,计数
    		int upper = 0;
    		int lower = 0;
    		int digit = 0;
    		//对字符串遍历
    		for (int i = 0; i < str.length(); i++) {
    			//String方法charAt,索引,获取字符
    			char c = str.charAt(i);
    			//利用编码表65-90 97-122 48-57
    			if(c >= 'A' && c <= 90){
    				upper++;
    			}else if(c >= 97 && c <= 122){
    				lower++;
    			}else if(c >= 48 && c <= 57){
    				digit++;
    			}
    		}
    		System.out.println("大写字母个数：" + upper + "小写字母个数：" + lower + "数字个数：" + digit);
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]  
第3章 字符串缓冲区  
3.1 StringBuffer类  
在学习String类时，API中说字符串缓冲区支持可变的字符串，什么是字符串缓冲区呢？接下来我们来研究下字符串缓冲区。  
查阅StringBuffer的API，StringBuffer又称为可变字符序列，它是一个类似于 String 的字符串缓冲区，通过某些方法调用可以改变该序列的长度和内容。  
原来StringBuffer是个字符串的缓冲区，即就是它是一个容器，容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。  
A:StringBuffer类概述  
通过JDK提供的API，查看StringBuffer类的说明  
线程安全的可变字符序列  
底层采用字符数组实现,初始容量为16  
B:StringBuffer和String的区别  
String是一个不可变的字符序列  
StringBuffer是一个可变的字符序列  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]  
3.2 StringBuffer类的方法  
A: StringBuffer类的方法  
a: 方法介绍  
StringBuffer append(), 将任意类型的数据,添加缓冲区  
append 返回值,写return this  
调用者是谁,返回值就是谁  
delete(int start,int end): 删除缓冲区中字符  
开始索引包含,结尾索引不包含  
insert(int index, 任意类型): 将任意类型数据,插入到缓冲区的指定索引上  
replace(int start,int end, String str): 将指定的索引范围内的所有字符,替换成新的字符串  
reverse(): 将缓冲区中的字符反转  
String toString(): 继承Object,重写toString()  
将缓冲区中的所有字符,变成字符串  
b: 案例代码

package cn.itcast.demo03;
    
    public class StringBufferDemo {
    
    	public static void main(String[] args) {
    		System.out.println("function()");
    		function();
    		System.out.println("function_1()");
    		function_1();
    		System.out.println("function_2()");
    		function_2();
    		System.out.println("function_3()");
    		function_3();
    		System.out.println("function_4()");
    		function_4();
    		System.out.println("function_5()");
    		function_5();
    	}
    	/*
    	 * StringBuffer类方法
    	 * String toString() 继承Object,重写toString()
    	 * 将缓冲区的所有字符,变成字符串
    	 */
    	public static void function_5(){
    		StringBuffer buffer = new StringBuffer();
    		buffer.append("abcdef");
    		buffer.append(12345);
    		
    		//将可变的字符串缓冲区对象,变成了不可变的String对象
    		String s = buffer.toString();
    		System.out.println(s);
    	}
    	/*
    	 * StringBuffer类方法
    	 * StringBuffer reverse()  将缓冲区中的字符反转
    	 */
    	public static void function_4(){
    		StringBuffer buffer = new StringBuffer();
    		buffer.append("abcdef");
    		buffer.reverse();
    		System.out.println(buffer);
    	}
    	/*
    	 * StringBuffer类方法
    	 * StringBuffer replace(int start, int end, String str) 
    	 * 将指定的索引范围内的所有字符,替换成新的字符串
    	 */
    	public static void function_3(){
    		StringBuffer buffer = new StringBuffer();
    		buffer.append("abcdef");
    		buffer.replace(1, 3, "QQ");
    		System.out.println(buffer);
    	}
    	/*
    	 * StringBuffer类方法
    	 * StringBuffer insert(int offset, 任意类型 c)   
    	 * 将任意类型数据,插入到缓冲区的指定索引上
    	 */
    	public static void function_2(){
    		StringBuffer buffer = new StringBuffer();
    		buffer.append("abcdef");
    		buffer.insert(3, 5.20);
    		System.out.println(buffer);
    	}
    	
    	/*
    	 * StringBuffer类方法
    	 * StringBuffer delete(int start, int end)  
    	 * 移除此序列的子字符串中的字符
    	 * 开始索引是包含的,结尾索引不包含
    	 */
    	public static void function_1(){
    		StringBuffer buffer = new StringBuffer();
    		buffer.append("abcdef");
    		buffer.delete(1, 5);
    		System.out.println(buffer);
    	}
    	/*
    	 * StringBuffer类方法
    	 * StringBuffer	append 将任意类型的数据,添加缓冲区
    	 * append 返回值,写return this
    	 * 调用者是谁,返回值就是谁
    	 */
    	public static void function(){
    		StringBuffer buffer = new StringBuffer();
    		//调用StringBuffer方法append向缓冲区添加内容
    		buffer.append(6).append(false);//方法调用链条,因为append返回值是return this的原因
    		System.out.println(buffer);
    	}
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]  
3.3 StringBuffer类方法查找练习  
下面的需求所对应的方法，要求大家自己动手在API中查找，并进行方法使用。  
 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串  
 在原有字符串缓冲区内容基础上，删除指定位置上的字符  
3.4 对象的方法链式调用  
在我们开发中，会遇到调用一个方法后，返回一个对象的情况。然后使用返回的对象继续调用方法。这种时候，我们就可以把代码现在一起，如append方法一样，代码如下：

创建一个字符串缓冲区对象。用于存储数据。
    StringBuffer sb = new StringBuffer();
    添加数据。不断的添加数据后，要对缓冲区的最后的数据进行操作，必须转成字符串才可以。
    String str = sb.append(true).append("hehe").toString();

3.5 StringBuffer练习

package cn.itcast.demo04;
    /*
     * int[] arr = {34,12,89,68};将一个int[]中元素转成字符串  格式 [34,12,89,68]
     * 格式[34,12,89,68]
     * String s = "["
     * 数组遍历
     * 		s+=arr[i]
     * s+"]"
     * StringBuffer实现,节约内存空间,String+在缓冲区中,append方法
     */
    public class StringBufferTest {
    	public static void main(String[] args) {
    		int[] arr = {34,12,89,68};
    		System.out.println(toString(arr));
    	}
    	public static String toString(int[] arr){
    		//创建字符缓冲区
    		StringBuffer buffer = new StringBuffer();
    		buffer.append("[");
    		//数组遍历
    		for (int i = 0; i < arr.length; i++) {
    			//判断是否是数组的最后一个元素
    			if(i == arr.length - 1){
    				buffer.append(arr[i]).append("]");
    			}else{
    				buffer.append(arr[i]).append(",");
    			}
    		}
    		//将缓冲区的所有字符,变成字符串
    		return buffer.toString();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]  
3.6 StringBuilder类  
查阅API发现还有一个StringBuilder类，它也是字符串缓冲区，StringBuilder与它和StringBuffer的有什么不同呢？  
我们阅读StringBuilder的API说明发现，它也是一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。(安全的永远要慢点)  
目前，我们还没有涉及到线程与同步，知道结论StringBuilder比StringBuffer快即可。为什么快，我们会在学习线程时讲解。  
A:StringBuilder的概述  
通过查看API了解一下StringBuilder类  
B:面试题  
String,StringBuffer,StringBuilder的区别  
StringBuffer和StringBuilder的区别  
StringBuffer是jdk1.0版本的,是线程安全的,效率低  
StringBuilder是jdk1.5版本的,是线程不安全的,效率高  
String和StringBuffer,StringBuilder的区别  
String是一个不可变的字符序列  
StringBuffer,StringBuilder是可变的字符序列  
第4章 总结  
4.1 知识点总结  
 Object: 它是所有类的超类，祖宗类。java中所有的类都直接或间接的继承这个类  
 方法  
public String toString() 返回当前对象中的内容, 对于Object类默认操作来说，返回的对象的类型+@+内存地址值  
public boolean equals(Object obj) 比较两个对象内容是否相同，对于Object类默认操作来说,比较的是地址值

 String: 字符串类，字符串是常量；它们的值在创建之后不能更改  
 方法  
boolean equals(Object obj) 判断两个字符串中的内容是否相同  
boolean equalsIgnoreCase(String str) 判断两个字符串中的内容是否相同, 忽略大小写  
boolean contains(String str) 判断该字符串中 是否包含给定的字符串  
boolean startsWith(String str) 判断该字符串 是否以给定的字符串开头  
boolean endsWith(String str) 判断该字符串 是否以给定的字符串结尾  
boolean isEmpty() 判断该字符串的内容是否为空的字符串 “”  
int length() 获取该字符串的长度  
char charAt(int index) 获取该字符串中指定位置上的字符  
String substring(int start) 从指定位置开始，到末尾结束，截取该字符串，返回新字符串  
String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串，返回新字符串  
int indexOf(int ch ) 获取给定的字符，在该字符串中第一次出现的位置  
int indexOf(String str) 获取给定的字符串，在该字符串中第一次出现的位置  
int indexOf(int ch,int fromIndex) 从指定位置开始，获取给定的字符，在该字符  
byte\[\] getBytes() 把该字符串 转换成 字节数组  
char\[\] toCharArray() 把该字符串 转换成 字符数组  
String replace(char old,char new) 在该字符串中，将给定的旧字符，用新字符替换  
String replace(String old,String new) 在该字符串中， 将给定的旧字符串，用新字符串替换  
String trim() 去除字符串两端空格，中间的不会去除，返回一个新字符串  
String toLowerCase() 把该字符串转换成 小写字符串  
String toUpperCase() 把该字符串转换成 大写字符串  
int indexOf(String str,int fromIndex) 从指定位置开始，获取给定的字符串，在该字符串中第一次出现的位置

 StringBuffer/StringBuilder:  
 方法  
public StringBuffer append(String str) 在原有字符串缓冲区内容基础上，在末尾追加新数据  
public StringBuffer insert(int offset,String str) 在原有字符串缓冲区内容基础上，在指定位置插入新数据  
public StringBuffer deleteCharAt(int index) 在原有字符串缓冲区内容基础上，删除指定位置上的字符  
public StringBuffer delete(int start,int end) 在原有字符串缓冲区内容基础上，删除指定范围内的多个字符  
public StringBuffer replace(int start,int end,String str)在原有字符串缓冲区内容基础上，将指定范围内的多个字符 用给定的字符串替换  
public StringBuffer reverse() 将字符串缓冲区的内容 反转 “abc”----“cba”  
public String substring(int start) 从指定位置开始，到末尾结束，截取该字符串缓冲区，返回新字符串  
public String substring(int start,int end) 从指定位置开始，到指定位置结束，截取该字符串缓冲区，返回新字符串

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70]: /images/20220418/2c2961f144c64cfdb23b632b8d76e9eb.png
[20181110100703492.jpg]: /images/20220418/d7cc5c344f71480c838e51c4ed18ac50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 1]: /images/20220418/2eb163cff67249fe9be9dddffa546658.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 2]: /images/20220418/4d6d3fa72faf4edc8ebf20b1f5120864.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 3]: /images/20220418/e1361b34b45b4858b69355d5b87b33fb.png
[20181110100858889.jpg]: /images/20220418/d366f83a09e948caa79fc2c9b213d772.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 4]: /images/20220418/6ba4c149bddd42a5b7837fedd04d53ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 5]: /images/20220418/10f72c96042f49ffae79585ca217a3bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 6]: /images/20220418/c2bf81140124480e83dea8316611ab1d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 7]: /images/20220418/e4efdb555034436dae786172e14a35df.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 8]: /images/20220418/c71981f8170443dd95841fbb5612fe40.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 9]: /images/20220418/382511a44ff047c3abebb5cf292cca90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 10]: /images/20220418/e8e9657b62a04b60b9dc48f864b238c8.png
[20181111173104926.png]: /images/20220418/31659ef2267442b8b578f02c631affad.png
[2018111117321541.png]: /images/20220418/d61cb086d2d641b09ac0ad86a6567ec7.png
[20181111173328972.png]: /images/20220418/7c6ba629c6aa43a089dbb028acc9d9c6.png
[20181111173412779.png]: /images/20220418/701254d9388d44cd9a18d2a8a6f57ad2.png
[2018111118511495.jpg]: /images/20220418/115ad60937804fd8a277309c663e4054.png
[20181111185212527.jpg]: /images/20220418/1768a5bb216949e1ab8dd2c5f53f7106.png
[20181111185311377.jpg]: /images/20220418/1ab8f9b5b50a4ffa9d256d90309e53c1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 11]: /images/20220418/d4a9800c693f4489a42537df8ffa28b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 12]: /images/20220418/180b1eab4cc5461db0f4d397ee1a035d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 13]: /images/20220418/cadc0e619e28486db492eb5479161db0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 14]: /images/20220418/f3559fcae678421b904dd2be6561f459.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 15]: /images/20220418/86c85279f2764efaa941e1cce7613f8d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MDgwNzI0Nw_size_16_color_FFFFFF_t_70 16]: /images/20220418/2d4dfb06d1df43e2838f3502e272281b.png