?第六天：java中常用API，String类 StringBuild和StringBuffer
1.?Object类
1.1?概述
Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在创建对象的时候，最终找的父类就是Object。
在Object类众多方法中，我们先学习equals方法与toString方法，其他方法后面课程中会陆续学到。
1.2toString()方法
toString()方法是用来在控制台打印对象
默认的格式 ?
?全限定类名@对象在内存中的地址值（16进制形式）
com.bianyiit.api.Person@1324324c
由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。
/**
?* ?Person[name=xxx,age=xxx,sex=xxx]
?* @return
?*/
@Override
public String toString() {
????return "Person[name=" + name +",age=" + age + ",sex=" + sex + "]" ;
}
默认返回的是对象在内存中的地址值,hashCode（）返回的内存可以作为对象的唯一标识
@Override
public int hashCode() {
????return this.name.hashCode();
}
返回的是对象的字节码文件加载到方法区所形成的对象（代表字节码文件的对象）
equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类中的equals方法内部使用的就是==比较运算符。
在开发中要比较两个对象是否相同，经常会根据对象中的属性值进行比较，也就是在开发经常需要子类重写equals方法根据对象的属性值进行比较。
面试题目？
1.??==??号与 ?equals方法在比较对象的时候有什么异同
==?号在比较对象的时候是根据对象在内存中的的地址值进行比较，两个对象必须是同一个对象的时候才会返回true
equals方法在比较的时候默认也是比较对象在内存中的地址值，但是在一个类中我们可以重写equals方法，在方法中我们可以根据对象的属性去进行自己想要的比较
2.?toString方法的作用
提供对象的打印字符串
默认情况下，toString打印的是com.bianyiit.api.Person@1324324c
我们也可以重写toString方法
3.?equals?和 hashCode的关系
equals方法比较对象 是不是同一个对象???
hashCode（）返回的内容可以作为对象的唯一标识
在实际开发中重写了equals方法就需要重写hashCode方法
2.?System类
?System 类包含一些有用的类字段和方法。它不能被实例化。
2.0.1?成员属性
?in标准输入流 out标准输出流
2.0.2?成员方法
?static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) :
?????从src源数组的srcPos索引开始,复制length个元素
从destPost位置开始将这些元素放至到dest数组中
??static long currentTimeMillis()
??????返回以毫秒为单位的当前时间
//当前时间 ?计算机中默认当前时间使用毫秒值来表示的 ??int
// 在计算中当前时间的毫秒值都是从1970 -1- 1 ???UNIX ?Time ??long
long millis = System.currentTimeMillis();
System.out.println(System.currentTimeMillis());
??static void exit(int status)
??????终止当前正在运行的 Java 虚拟机
??static void gc() ?
运行垃圾回收器
Java中的垃圾回收机制
并不是堆内存中一有对象没有被变量引用就会立马回收对象，垃圾回收器是每隔一段时间（算法）去垃圾回收一次
3.?日期相关类? ??? ? ? ? ? ? ? ? ?
3.1?Date类
Date: 表示特定的瞬间，精确到毫秒，他可以通过方法来设定自己所表示的时间，可以表示任意的时间
3.1.1?Date类的构造方法
???Date() ：创建的是一个表示当前系统时间的Date对象
Date(long date) ：根据"指定时间"创建Date对象
3.1.2?Date类常用方法
void setTime(long time) ???//设置当前时间
long getTime() ???????????//获取当前时间
date.toLocaleString()????//获取当前时间的本地格式的字符串
3.2?DateFormat类 & SimpleDateFormat
???DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。日期/时间格式化子类（如 SimpleDateFormat类）允许进行格式化（也就是日期 -> 文本）、解析（文本-> 日期）和标准化。
我们通过这个类可以帮我们完成日期和文本之间的转换。
继续阅读API，DateFormat 可帮助进行格式化并解析任何语言环境的日期。对于月、星期 ???
DateFormat&SimpleDateFormat的常用方法
???要格式化一个当前语言环境下的日期也就是日期 -> 文本），要通过下面的方法来完成。DateFormat是抽象类，我们需要使用其子类SimpleDateFormat来创建对象。
A:SimpleDateFormat构造方法
B:DateFormat类方法
?例子：
public class DataDemo1 {
public static void main(String[] args) {
method();
//自定义日期格式"yyyy-MM-dd HH:mm:ss" 2021-12-05 15:48:19 年月日 时分秒
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date();
String s = simpleDateFormat.format(date);
System.out.println(s);//2021-12-05 15:48:19
}
//这是超级日期格式化器的默认格式
private static void method() {
//使得可以选择任何用户定义的日期-时间格式的模式。格式化日期工具
SimpleDateFormat sdf = new SimpleDateFormat();
Date d = new Date();//创建日期对象 没有格式化之前： Sun Dec 05 15:42:18 CST 2021
String s = sdf.format(d);//调用方法格式化日期
System.out.println(s);//输出格式化日期 格式化之后是： 21-12-5 下午3:43
//我们还可以自定义日期格式
}
}
将字符串转换成Date对象
将Date对象格式化成字符串
案例代码:
package com.bianyiit.datetest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
?* SimpleDateFormat:
?* 格式化：
?* Date --- String
?* 2049-8-26 2049年8月26日
?* String format(Date date)
?* 解析：
?* String --- Date
?* "2049-8-26"
?* Date parse(String source)
?*
?* 构造方法：
?* SimpleDateFormat() ：使用默认的模式进行对象的构建
?* SimpleDateFormat(String pattern) ：使用的指定的模式进行对象的构建
?*
?* 注意：Exception in thread "main" java.text.ParseException: Unparseable date: "49年9月26日 ?下午1:29"
?* ????解析的字符串，模式必须和构建对象的模式一样
?*
?*/
public class SimpleDateFormatDemo {
public static void main(String[] args) throws ParseException {
//method();
//method2();
//使用指定的模式进行对象的构建
//1999年9月1日 10:10:10
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
//格式化
Date date = new Date();
String s = sdf.format(date);
System.out.println(s);//2049年08月26日 13:39:12
//解析
Date d = sdf.parse("2049年08月26日 13:39:12");
System.out.println(d.toLocaleString());
}
private static void method2() throws ParseException {
//使用指定的模式进行对象的构建
//1999年9月1日
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");
//格式化
Date date = new Date();
String s = sdf.format(date);
System.out.println(s);//2049年08月26日
//解析
Date d = sdf.parse("2049年08月26日");
System.out.println(d.toLocaleString());
}
private static void method() throws ParseException {
//使用默认模式进行对象的构建
SimpleDateFormat sdf = new SimpleDateFormat();
//创建日期对象
Date date = new Date();
//格式化 把日期对象转换成字符串
String s = sdf.format(date);
System.out.println(s);//49-8-26 下午1:29
//解析 把字符串转换成日期对象
Date d = sdf.parse("49年9月26日 ?下午1:29");
System.out.println(d.toLocaleString());
}
}
3.Calendar类
3.1?Calendar类概述
?Calendar是日历类，在Date后出现，替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量，方便获取。
Calendar为抽象类，由于语言敏感性，Calendar类在创建对象时并非直接创建，而是通过静态方法创建，将语言敏感内容处理好，再返回子类对象，如下：
Calendar类静态方法
Calendar c?= Calendar.getInstance();??//返回当前时间
3.2?Calendar类常用方法
案例代码
package?com.bianyiit;
import?java.util.Calendar;
/*
?* Calendar：日历，提供了一些操作年月日时的方法
?*
?* 获取
?* 修改
?* 添加
*/
public?class?CalendarDemo {
public?static?void?main(String[] args) {
//static Calendar getInstance() ?
Calendar c = Calendar.getInstance();
//void set(int?field, int?value) ：把指定的字段修改成指定的值
//c.set(Calendar.DAY_OF_MONTH, 20);
//void add(int?field, int?amount): 在指定的字段上加上指定的值
c.add(Calendar.DAY_OF_MONTH, -1);
//int?get(int?field) // 返回给定日历字段的值
//public static final int?YEAR 1
//System.out.println(Calendar.YEAR);
//int?year = c.get(1);
int?year = c.get(Calendar.YEAR);
int?month = c.get(Calendar.MONTH) + 1;
int?day = c.get(Calendar.DAY_OF_MONTH);
System.out.println(year + "年"?+ month + "月"?+ day + "日");
}
}
4.?包装类
4.1?包装类
Java中提供了相应的对象来解决该问题，基本数据类型对象包装类：java将基本数据类型值封装成了对象。封装成对象有什么好处？可以提供更多的操作基本数值的功能。
8种基本类型对应的包装类如下：
其中需要注意int对应的是Integer，char对应的Character，其他6个都是基本类型首字母大写即可。
每个基本数据类型对应的包装类分别：
?byte Byte
?short Short
?char Character
?int Integer
?long Long
?float Float
?double Double
?boolean Boolean
4.2?案例代码
package?com.bianyiit;
/*
?* 需求：判断一个数是否符合int类型的范围
?* 由于基本数据类型只能做一些简单的操作和运算，所以Java为我们封装了基本数据类型，为每种基本数据类型提供了包装类
?* 包装类就是封装了基本数据类型的类，为我们提供了更多复杂的方法和一些变量
?* byte Byte
?* short Short
?* char Character
?* int Integer
?* long Long
?* float Float
?* double Double
?* boolean Boolean
?* Integer:
?* String --- int
?* 方式1：int?intValue()
?* 方式2： static int?parseInt(String s)
?* int?--- String
?* 方式1： + ""
?* 方式2：String toString()
?* 构造方法：
?* Integer(int?value)
?* Integer(String s)
?*/
public?class?IntegerDemo {
public?static?void?main(String[] args) {
/*int?n = 10;
if(n >= Math.pow(-2, 31) && n <= Math.pow(2, 31) -1) {
System.out.println("符合");
}
else {
System.out.println("不符合");
}*/
Integer i = new?Integer("10");
System.out.println(i);
int?a = i.intValue();
System.out.println(a + 10 );
int?b = Integer.parseInt("20");
System.out.println(b + 30);
Integer i2 = new?Integer(40);
String?s = i2.toString();
System.out.println(s);
String?s2 = Integer.toString(50);
System.out.println(s2);
}
}
4.3?包装类的自动装箱与拆箱
在需要的情况下，基本类型与包装类型可以通用。有些时候我们必须使用引用数据类型时，可以传入基本数据类型。
比如：
基本类型可以使用运算符直接进行计算，但是引用类型不可以。而基本类型包装类作为引用类型的一种却可以计算，原因在于，Java”偷偷地”自动地进行了对象向基本数据类型的转换。
相对应的，引用数据类型变量的值必须是new出来的内存空间地址值，而我们可以将一个基本类型的值赋值给一个基本类型包装类的引用。原因同样在于Java又”偷偷地”自动地进行了基本数据类型向对象的转换。
自动拆箱：对象转成基本数值
自动装箱：基本数值转成对象
1.?基本数据类型对应的包装类分别是什么？
2.?使用包装类型的数据有什么优势？
3.?解释自动装箱与自动拆箱是什么
Object----toSatring() ?euqals() ?getClass() ??hashcode()---地址值
System--系统的时间 ??关闭虚拟机 ?exit() ??gc() ?in ?out
Date ??DateFormat ?SimpleDateFormat ??Calendar(单独操作字段用的)
包装类： ?int ?a=1; ?变成一个类（包装类）
?Int----Integer
Char-Character
5.Random类
Random():无参构造方法
Random r = new Random();
成员方法
???public int nextInt(int n):产生的是一个[0,n)范围内的随机数
调用方法：
看返回值类型：人家返回什么类型，你就用什么类型接收
看方法名：名字不要写错了
看形式参数：人家要几个参数，你就给几个，人家要什么数据类型的，你就给什么数据类型的
int number = r.nextInt(100);
2.String类
字符串
String：是一个类 可以创建对象
例子：String s=new String("hi");//创建String对象,调用的是它的有参构造方法
String s1="hello";//创建字符串常量，因为它的长度是不能随意发生改变的
?
String a=”hello”；为什么看成是一个常量？
因为字符串长度是不可以更改的。
1.1.1?String类概述
通过JDK提供的API，查看String类的说明
A:"abc"是String类的一个实例,或者成为String类的一个对象
B:字符串是常量
字符串在内存中存储情况
?
见面试题2：
1.1.2?String类的构造方法
String(String original):把字符串数据封装成字符串对象
? String(char[] value):把字符数组的数据封装成字符串对象
? String(char[] value, int index, int count):把字符数组中的一部分数据封装
字符串对象
比较两个子串的内容和地址?
//字符串常量
String s1="hello";
String s2="hi";
String s3="hello";
System.out.println(s1.equals(s2));//false
System.out.println(s1==s2);//false
System.out.println(s1.equals(s3));//true 比较内容 因为这的equals方法是String类里面的，已经重写了（Object的）所以不会比较地址值
//String字符串常量值是存储在方法区中的常量池中，前面s1已经在常量池中开辟了一块内存空间存储了hello，
//s3在存储的话会覆盖前面的s1的内存空间，所有他们的地址值是一样的
System.out.println(s1==s3);//true 比较地址值
// 字符串String---类 可以创建对象
String s = new String("hello");
String s1="hello";
String s2 = new String("hello");
System.out.println(s);//重写了equals方法所以打印的是值（内容）
System.out.println(s.equals(s1));//true
System.out.println(s==s1);//false 因为s是new出来的是存储在堆内存中的 s1是存储方法区中的常量池的
System.out.println(s.equals(s2));//true
System.out.println(s==s2);//false
String s1="a"+"b"+"c";//方法区中有常量优化机制
String s2="abc";
System.out.println(s1.equals(s2));//true
System.out.println(s1==s2);//true
String s3="HI";
String S4="hi";
System.out.println(s3.equals(S4));//false 比较内容 不忽略大小写
System.out.println(s3.equalsIgnoreCase(S4));//true 忽略大小写
String s5="hihello";
System.out.println(s5.length());
System.out.println(s5.charAt(0));
//字符遍历的第一种方式
for (int i = 0; i <7 ; i++) {
System.out.print(s5.charAt(i));
}
System.out.println(s5.indexOf("h"));//0
System.out.println(s5.indexOf("oo"));//-1 表示没有
System.out.println(s5.substring(2));
System.out.println(s5.substring(3,6));//[3,6)
}
/*
?* 通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?
?* 通过构造方法创建字符串对象是在堆内存。
?* 直接赋值方式创建对象是在方法区的常量池。
?* ==:
?* 基本数据类型：比较的是基本数据类型的值是否相同
?* 引用数据类型：比较的是引用数据类型的地址值是否相同
?*/
public class StringDemo2 {
public static void main(String[] args) {
String s1 = new String("hello");
String s2 = "hello";
System.out.println("s1:"+s1);
System.out.println("s2:"+s2);
System.out.println("s1==s2:"+(s1==s2)); //false
String s3 = "hello";
System.out.println("s1==s3:"+(s1==s3)); //false
System.out.println("s2==s3:"+(s2==s3)); //true
}
}
1.1.3?String类的判断功能
boolean equals(Object obj):比较字符串的内容是否相同
??boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
??boolean startsWith(String str):判断字符串对象是否以指定的str开头
??boolean endsWith(String str):判断字符串对象是否以指定的str结尾
1.1.3.1?判断方法演示
1.1.3.1.1?案例代码
/*
?* Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。
?* 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。
?*
?* String类的判断功能：
?* boolean equals(Object obj):比较字符串的内容是否相同
?* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
?* boolean startsWith(String str):判断字符串对象是否以指定的str开头
?* boolean endsWith(String str):判断字符串对象是否以指定的str结尾
?*/
public class StringDemo {
public static void main(String[] args) {
//创建字符串对象
String s1 = "hello";
String s2 = "hello";
String s3 = "Hello";
//boolean equals(Object obj):比较字符串的内容是否相同
System.out.println(s1.equals(s2));
System.out.println(s1.equals(s3));
System.out.println("-----------");
//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写
System.out.println(s1.equalsIgnoreCase(s2));
System.out.println(s1.equalsIgnoreCase(s3));
System.out.println("-----------");
//boolean startsWith(String str):判断字符串对象是否以指定的str开头
System.out.println(s1.startsWith("he"));
System.out.println(s1.startsWith("ll"));
}
}
1.1.3.2?判断功能案例
需求:模拟登录,给三次机会,并提示还有几次
1.1.3.2.1?案例代码
public class LoginDemo {
????/**
?????* 需求:模拟登录,给三次机会,并提示还有几次
?????* @param args
?????*/
????public static void main(String[] args) {
????????String username = "tom";
????????String password = "123";
????????Scanner sc = new Scanner(System.in);
????????for (int i = 0; i < 3; i++) {
????????????System.out.println("请输入您的用户名：");
????????????String uName = sc.nextLine();
????????????System.out.println("请输入您的密码");
????????????String uPassword = sc.nextLine();
????// ???????System.out.println("用户输入的用户名为：" + uName ?+ " ???用户输入的密码为：" + uPassword);
????????????if (username.equals(uName) && password.equals(uPassword)){
????????????????System.out.println("用户登录成功！！！ 编易IT欢迎您" + uName);
????????????????break; ??//一旦用户登录成功，跳出循环
????????????}else {
????????????????System.out.println("您的用户名或者密码错误了，您还有" + (2-i) + "次机会" );
????????????}
????????}
????}
}
1.1.4?String类的获取功能
1.1.4.1?获取方法
int length():获取字符串的长度，其实也就是字符个数
char charAt(int index):获取指定索引处的字符
int indexOf(String str):获取str在字符串对象中第一次出现的索引
int lastIndexOf(String str):获取str在字符串对象中最后一次出现的索
String substring(int start):从start开始截取字符串
String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end
1.1.4.2?获取功能案例
遍历字符串(获取字符串中的每一个字符)
1.1.4.2.1??案例代码
public static void main(String[] args) {
// ???????method();
????????String str = "hellobianyiit";
????????for (int i = 0; i < str.length(); i++) {
????????????System.out.println(str.charAt(i));
????????}
????}
1.1.5?String类的转换功能
1.1.5.1?转换方法演示
char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串
/* char[] toCharArray():把字符串转换为字符数组
String toLowerCase():把字符串转换为小写字符串
String toUpperCase():把字符串转换为大写字符串*/
method1();
String s="HAHAHAHAHAHAHIHIHHI";
System.out.println(s.toLowerCase());// String toLowerCase():把字符串转换为小写字符串
// String s1 = s.toLowerCase();
// System.out.println(s1);
String s1="hihiihihii";
System.out.println(s1.toUpperCase());// String toUpperCase():把字符串转换为大写字符串*/
//需求：首字母大写 其他字母小写
String s2="GSHjssj";
String ss = s2.substring(0, 1).toUpperCase();//[0,1)
String sss = s2.substring(1).toLowerCase();//从1开始截取到最后
System.out.println(ss+sss);
}
private static void method1() {
String s="hiworld";
char[] arr = s.toCharArray();
//第二种遍历数组的方法 先把字符串转换为字符数组 在去遍历数组
for (int i = 0; i <arr.length ; i++) {
System.out.print(arr[i]+" ");
}
}
1.1.5.2?转换功能演示
String str = "bianYiIT";
System.out.println("原始字符串"+str);
String lowerCase = str.toLowerCase();
System.out.println("小写字符串"+lowerCase);
String upperCase = str.toUpperCase();
System.out.println("小大写字符串"+upperCase);
1.1.6?String类的其它功能
1.1.6.1?其它方法演示
去除字符串两端空格
? String trim()
按照指定符号分割字符串
String[] split(String str)
// 其它方法演示
// 去除字符串两端空格
// String trim()
// 去掉中间的空间 replace() 替代
// 按照指定符号分割字符串
// String[] split(String str)
String s=" =====hihihiihi=== ";
String s1=" =====hihih iihi=== ";
String s2="=====hihihi ihi=== ";
System.out.println(s);
System.out.println(s1);
System.out.println(s2);
System.out.println("================");
System.out.println(s.trim());//去掉字符串两边的空格
System.out.println(s1.trim());
System.out.println(s2.trim());
String s3="张三,李四,王五";
String[] arr = s3.split(",");//还可以用- =等等分割 按照指定符号分割字符串
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i]+" ");
}
1.1.7?String类的其它案例
1.1.7.1??案例代码:
/*
?* 把数组中的数据按照指定个格式拼接成一个字符串
?* 举例：int[] arr = {1,2,3};
?* 输出结果：[1, 2, 3]
?*
?* 分析：
?* A:定义一个int类型的数组
?* B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串
?* C:调用方法
?* D:输出结果
?*/
public class StringTest {
public static void main(String[] args) {
//定义一个int类型的数组
int[] arr = {1,2,3};
//写方法实现把数组中的元素按照指定的格式拼接成一个字符串
//调用方法
String s = arrayToString(arr);
//输出结果
System.out.println("s:"+s);
}
/*
?* 两个明确：
?* 返回值类型：String
?* 参数列表：int[] arr
?*/
public static String arrayToString(int[] arr) {
String s = "";
//[1, 2, 3]
s += "[";
for(int x=0; x<arr.length; x++) {
if(x==arr.length-1) {
s += arr[x];
}else {
s += arr[x];
s += ", ";
}
}
s += "]";
return s;
}
}
1.1.7.2??案例代码
需求：把字符串反转 ?？
/**
?????* 反转字符串
?????* @param srcStr ?要反转的字符串
?????* @return
?????*/
????public static String revese(String srcStr){
// ???????"abcdef"
????????String distStr = "";
????????for (int i = srcStr.length()-1; i >=0 ; i--) {
// ???????????System.out.println(srcStr.charAt(i));
????????????distStr = distStr + srcStr.charAt(i);
????????}
????????return distStr;
????}?
1.1.8?String常见面试题
1.?Object中的equals方法和String中的equals方法有什么区别
Object的equals方法比较的是内存中的地址值，只有两个变量在内存中指向同一个对象的时候才会返回true
String?重写了Object的equals方法，在比较两个字符串的时候，会根据字符串内存进行比较，只要两个字符串对象内容一样，返回的就是true
2.?判断两个字符串是否相等
String???str1 ??= ?“abc”;
String ??str2 ??= ?“abc”
3.?下面语句会在内存中创建几个对象
String??str?= new String(“bianyiit”);
4.?判断str1 和 str2两个字符串是否相等
a)??String??str1 =?“a”+ “b” + “c”;
String str2 = “abc”;? ? ? ??
b)??String str = “ab”;
String??str1 =?“abc”;
String str2 = str + “c”;
2.StringBuilder类
2.1?StringBuilder类概述
?StringBuilder:是一个可变的字符串。字符串缓冲区类。??
String和StringBuilder的区别：
String的内容是固定的
StringBuilder的内容是可变的
2.1.1?+=拼接字符串耗费内存原因:
每次拼接都会产生新的字符串对象,而利用StringBuilder来拼接字符串自始至终用的都是同一个StringBuilder容器
2.2?StringBuilder类的常用方法
2.1???A:构造方法:
?????StringBuilder()
public static void main(String[] args) {
/*StringBuilder：（高效字符串，缓冲字符串）
与String的区别:
String长度是固定的，而StringBuilder长度是可变的
*
*
* */
StringBuilder sb = new StringBuilder();
//往容器中添加数据
for (int i = 1; i <=15 ; i++) {
sb.append("hello");
}
/*
内容长度 5 15 20 30 35 70 75
容器长度 16 16 34 34 70 70 142
如果内容的长度大于容器的长度时，容器长度扩充规律
现在的长度=原先的长度*2+2
*
* */
//字符串内容的长度
System.out.println("内容的长度:"+sb.length());
System.out.println("容器的长度:"+sb.capacity());
}
2.1?添加功能
public static void main(String[] args) {
//创建高效字符串对象
StringBuilder sb = new StringBuilder();
//往容器中添加数据
/* StringBuilder append()
将 boolean 参数的字符串表示形式追加到序列*/
/* StringBuilder sb1 = sb.append(100);*/
//链式编程
sb.append(100).append("hello").append('男').append(true);
/* sb.append("hello");
sb.append('男');
sb.append(true);*/
System.out.println(sb);
}
2.4删除功能和
2.3替换
2.2?反转
public static void main(String[] args) {
/*StringBuffer delete(int start, int end)
移除此序列的子字符串中的字符。
StringBuffer deleteCharAt(int index)
移除此序列指定位置的 char。
*/
StringBuilder sb = new StringBuilder();
//添加数据
sb.append("hello").append("java").append("world").append("php");
/* System.out.println(sb.length());
//sb.delete(0,9);//[start,end)
System.out.println(sb);
sb.deleteCharAt(16);
System.out.println(sb);*/
//倒着遍历
sb.reverse();
System.out.println(sb);
}
2.5?获取
public static void main(String[] args) {
/*利用StringBuilder把数组拼接成一个字符串
举例：
int[] arr = {1,2,3};
结果：
[1, 2, 3]*/
int[] arr = {1,2,3};
StringBuilder sb = new StringBuilder();
sb.append("[");
for (int i = 0; i < arr.length; i++) {
if(i==arr.length-1){
sb .append(arr[i]).append("]");
}else{
sb.append(arr[i]).append(",");
}
}
System.out.println(sb);
}
?public int capacity():返回当前容量?(理论值)
?public int length():返回长度(已经存储的字符个数)
public StringBuilder append(任意类型):添加数据，并返回自身对象
public StringBuilder reverse():反转功能
2.2.3?案例代码
/*
?* StringBuilder:是一个可变的字符串。字符串缓冲区类。
?*
?* String和StringBuilder的区别：
?* String的内容是固定的。
?* StringBuilder的内容是可变的。
?*
?* 构造方法：
?* StringBuilder()
?* 成员方法：
?* public int capacity():返回当前容量
?* public int length():返回长度（字符数）
?* 容量：理论值
?* 长度：实际值
?*/
public class StringBuilderDemo {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
System.out.println("sb:"+sb);
System.out.println("sb.capacity():"+sb.capacity());
System.out.println("sb.length():"+sb.length());
}
}
2.2.4?案例代码:
/*
?* 添加功能
?* public StringBuilder append(任意类型):添加数据，并返回自身对象
?* 反转功能
?* public StringBuilder reverse()
?*/
public class StringBuilderDemo {
public static void main(String[] args) {
//创建对象
StringBuilder sb = new StringBuilder();
//public StringBuilder append(任意类型)
//StringBuilder sb2 = sb.append("hello");
/*
System.out.println("sb:"+sb);
System.out.println("sb2:"+sb2);
System.out.println(sb == sb2); //true
*/
/*
sb.append("hello");
sb.append("world");
sb.append(true);
sb.append(100);
*/
//链式编程
sb.append("hello").append("world").append(true).append(100);
System.out.println("sb:"+sb);
//public StringBuilder reverse()
sb.reverse();
System.out.println("sb:"+sb);
}
}
2.3?StringBuilder案例
2.3.1?案例:
StringBuilder和String通过方法完成相互转换
2.3.1?案例代码:
/*
?* StringBuilder和String的相互转换
?* StringBuilder -- String
?* public String toString():通过toString()就可以实现把StringBuilder转成String
?* String -- StringBuilder
?* StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder
?*/
public class StringBuilderTest {
public static void main(String[] args) {
//StringBuilder -- String
/*
StringBuilder sb = new StringBuilder();
sb.append("hello").append("world");
String s = sb.toString();
System.out.println(s);
*/
//String -- StringBuilder
String s = "helloworld";
StringBuilder sb = new StringBuilder(s);
System.out.println(sb);
}
}
StringBuilder和StringBuffer的区别？
StringBuffer：线程同步，效率低，因为一次只执行一个线程。?jdk1.0版本出现
StringBuilder：线程不同步， 效率高，?jdk1.5版本出现
今日学习感受：发现以前学习上欠的债，始终是要还的，我深有体会，路还是要一步一步走，要走的扎实，技术也是如此，慢慢来比较块，从量变到质变是需要过程的。当然，要相信自己，困难一定是有的，勇敢的去面对它，并且战胜它，你会发现，其实也不过如此。最后送孔子的名言：“学而不思则罔，思而不学则殆”。