基础API与常见算法
和数学相关的类
数学类Math:构造器私有,方法都是静态方法
//静态导入:导入某一个类中的静态资源,可以省略类名直接调用
import static java.lang.Math.*;
public class MathTest {
public static void main(String[] args) {
//绝对值
System.out.println(Math.abs(-1));// 1
//向上取整
System.out.println(Math.ceil(3.14));// 4.0
//向下取整
System.out.println(Math.floor(9.8));// 9.0
//随机数[0,1); [m,n]:(int)(Math.random()*(n-m+1)+m);
System.out.println(Math.random());
//求平方
System.out.println(Math.pow(2, 4));// 16.0
//开平方
System.out.println(Math.sqrt(9));// 3.0
//四舍五入
System.out.println(Math.round(3.14));// 3
//圆周率
System.out.println(Math.PI);// 3.141592653589793
System.out.println(PI);//静态导入后可以省略类名直接调用
}
}
BigInteger类:存储大的整数
import java.math.BigInteger;
public class BIgTest {
public static void main(String[] args) {
/*
BigInteger 大的整数
存储大的整数
*/
System.out.println(Long.MAX_VALUE);//9223372036854775807
BigInteger bigInteger = new BigInteger("9223372036854775807123");
System.out.println(bigInteger);//9223372036854775807123
//基本数据类型
int a = 10;
int b = 20;
System.out.println(a + b);//30
//引用数据类型
BigInteger b1 = new BigInteger("10");
BigInteger b2 = new BigInteger("20");
//System.out.println(b1 + b2);引用数据类型不能直接相加
System.out.println("加法"+b1.add(b2));//30
System.out.println("减法"+b1.subtract(b2));//-10
System.out.println("乘法"+b1.multiply(b2));//200
System.out.println("除法"+b1.divide(b2));// 0
System.out.println("取余"+b1.remainder(b2));//10
}
}
RoundingMode枚举类
BigDecimal类:用于存储确切的小数
import java.math.BigDecimal;
public class BIgTest {
public static void main(String[] args) {
BigDecimal b3 = new BigDecimal("10");
BigDecimal b4 = new BigDecimal("20");
System.out.println("加法"+b3.add(b4));//30
System.out.println("减法"+b3.subtract(b4));//-10
System.out.println("乘法"+b3.multiply(b4));//200
System.out.println("除法"+b3.divide(b4));//0.5
System.out.println("取余"+b3.remainder(b4));//10
BigDecimal b5 = new BigDecimal("10.0");
BigDecimal b6 = new BigDecimal("3.0");
//不能整除要放入舍入模式
System.out.println(b5.divide(b6,10,BigDecimal.ROUND_FLOOR));//3.3333333333
System.out.println(b5.divide(b6,BigDecimal.ROUND_FLOOR));//3.3
System.out.println(b5.divide(b6,BigDecimal.ROUND_CEILING));//3.4
}
}
Random类
import java.util.Random;
public class Test{
public static void main(String [] args){
//当种子固定的时候,产生的随机数是相同的:Random random = new Random(1);
Random random = new Random();
//random.nextInt(n) [0,n)范围内的int类型的随机数
for (int i = 0; i < 10; i++) {
//System.out.println(random.nextDouble());//[0,1)
//System.out.println(random.nextBoolean());//true false
System.out.println(random.nextInt(10));
}
}
日期时间API
jdk1.8前
Date类
import java.util.Date;
public class DataTest {
public static void main(String[] args) {
//过时方法
Date date = new Date();
System.out.println(date);
System.out.println("年:"+(date.getYear()+1900));//+1900表示现在年
System.out.println("月:"+(date.getMonth()+1));//0代表1月
System.out.println("日:"+date.getDate());
System.out.println("一周的第几天:"+date.getDay());
long time = date.getTime();//当前时间转换毫秒数
System.out.println(time);
Date date1 = new Date(1654519577433L);//毫秒数转日期
System.out.println(date1);
String string = date1.toLocaleString();
System.out.println(string);//2022-6-6 20:46:17
//同一个类中需要同名对象需要全路径导入
//只有年月日没有时分秒
java.sql.Date date2 = new java.sql.Date(1654519577433L);
System.out.println(date2);//2022-06-06
}
}
Calendar类
import java.util.Calendar;
public class DataTest {
public static void main(String[] args) {
//Calender抽象类 不能直接创建对象,需要通过子类实现功能,
// 或者调用getInstance()方法创建Calender对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar);//获取全部信息
System.out.println(calendar.get(Calendar.YEAR));//月从0开始
//修改日期 calendar.add(属性,值);
calendar.add(Calendar.YEAR,2);//2022+2
System.out.println(calendar.get(Calendar.YEAR));//2024
//设置指定日期
calendar.set(2000,1,1);
}
}
获取时区:了解
String[] availableIDs = TimeZone.getAvailableIDs();
for (String availableID:availableIDs) {
System.out.println(availableID);
}
日期格式化
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DataTest {
public static void main(String[] args) throws ParseException {
/*
* 日期转换
* 新建日期格式化对象
* DateFormat df =new SimpleDateFormat("格式");
日期转字符串
* df.format(日期对象);
* date--》2022-06-07 10:00:16 星期二
*
* 字符串转日期
* Date date = df.parse(字符串)
* 要解析的字符串内容必须与格式完全匹配,否则报错:
* ParseException: Unparseable date: "2022-06-0710:00:16"
* */
//hh:12小时制 HH:24小时制
DateFormat df =new SimpleDateFormat("yyyy-MM-dd hh:mm:ss E");
Date date =new Date();
String s = df.format(date);
System.out.println(s);
String ss = "2022-06-07 10:00:16";//字符串格式与日期格式化格式必须一直
//新建日期格式化对象
DateFormat d =new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
Date date1 = d.parse(ss);//编译时异常
System.out.println(date1);
}
}
jdk1.8后
本地日期时间
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Month;
public class NewDate {
public static void main(String[] args) {
/*
LocalDate:年月日
不可变的日期,一旦对日期做出修改,会生成一个新的LocalDate记录改变后的日期
minusDays:日期减少
plusDays:日期增加
*/
LocalDate of = LocalDate.of(2019,1,1);
System.out.println(of);//输出指定日期
LocalDate now = LocalDate.now();
System.out.println(now);//输出现在年月日
int year = now.getYear();
System.out.println(year);//输出年
Month month = now.getMonth();
System.out.println(month.getValue());//输出月
System.out.println(now.getDayOfMonth());//输出日
//让当前日期-2
LocalDate localDate = now.minusDays(2);
System.out.println(localDate);//
//让当前日期+2
LocalDate localDate1 = now.plusDays(2);
System.out.println(localDate1);
LocalTime of1 = LocalTime.of(5,1,1,3);
System.out.println(of1);//设置指定时间
LocalTime localTime = LocalTime.now();
System.out.println(localTime);//输出当前时分秒毫秒
System.out.println(localTime.getHour());//输出时
System.out.println(localTime.getMinute());//输出分
System.out.println(localTime.getSecond());//输出秒
}
}
指定时区日期时间:了解
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);
ZonedDateTime now1 = ZonedDateTime.now(ZoneId.of("America/New_York"));
System.out.println(now1);
持续日期/时间:Period和Duration
import java.time.*;
public class NewDate {
public static void main(String[] args) {
//计算日期差
LocalDate l1 = LocalDate.now();
LocalDate l2 = LocalDate.of(2019,1,1);
Period between = Period.between(l2, l1);
System.out.println(between);
System.out.println(between.getYears());//差几年
System.out.println(between.getMonths());//差几月
System.out.println(between.getDays());//差几日
//计算时间差
LocalDateTime l3 = LocalDateTime.now();
LocalDateTime l4 = LocalDateTime.of(2019,2,2,2,2,2);
Duration duration = Duration.between(l4, l3);
System.out.println(duration);
//获取两个时间段相隔多少天
System.out.println(duration.toDays());
}
}
日期格式化类:DateTimeFormatter类
//DateTimeFormatter有提供好的模板,直接使用;将日起对象转为字符串
DateTimeFormatter formatter = DateTimeFormatter.ISO_DATE;
LocalDateTime localDateTime = LocalDateTime.now();
System.out.println(formatter.format(localDateTime));
//自定义
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
System.out.println(formatter1.format(localDateTime));
//将字符串转为日期
//新的日期格式化小时使用HH
String string = "2022-06-07 12:22:29";
LocalDateTime localDateTime1 = LocalDateTime.parse(string, formatter1);
System.out.println(localDateTime1);
系统相关类
System类&Runtime类
import java.util.Properties;
public class Test {
public static void main(String[] args) {
//获取当前时间的毫秒数
long l = System.currentTimeMillis();
System.out.println(l);
System.gc();//运行垃圾收集器
int[] arr = {1,2,3};
int[] newArr = new int[arr.length];
//赋值字符串
System.arraycopy(arr,0,newArr,0,3);
for (int i : newArr) {
System.out.println(i);
}
Properties properties = System.getProperties();
properties.list(System.out);//所有java系统属性
System.out.println(System.getProperty("java.version"));
//Runtime类:了解
Runtime r1 = Runtime.getRuntime();
Runtime r2 = Runtime.getRuntime();
System.out.println(r1 == r2);//true
System.out.println(r1.totalMemory());//总运行内存
System.out.println(r1.freeMemory());//剩余空闲运行内存
}
}
数组的算法升华
数组的交换
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8};
System.out.println("交换前"+Arrays.toString(arr));
//首尾交换,只需一般数据交换
for (int i = 0; i < arr.length/2; i++) {
int temp = arr[i];
arr[i] = arr[arr.length-i-1];
arr[arr.length-i-1] = temp;
}
System.out.println("交换后"+Arrays.toString(arr));
}
}
二分查找
/*二分查找
前提:数据必须有序,从小到大的顺序
*/
public class BinarySearch {
public static void main(String[] args) {
int[] arr = {1,2,3,4,5,6,7,8,9,10};
int index = binarySearch1(arr, 9);
if (index != -1){
System.out.println("指定元素对应的下标是:"+index);
}else {
System.out.println("无此元素");
}
}
/**
*二分查找法
* @param arr 要查找的数组
* @param i 要查找的元素
*/
private static int binarySearch1(int[] arr, int i) {
//获取开始下标和结束下标
int startIndex = 0;
int endIndex = arr.length-1;
//使用循环完成
while (startIndex<=endIndex){
//获取中间下标
int midIndex = (startIndex+endIndex)/2;
//找到中间下标对应的元素
int midValue = arr[midIndex];
//当要查找的元素 > 中间下标对应的元素 :开始下标 = 中间下标+1
if (i > midValue) {
startIndex = midIndex+1;
}//当要查找的元素 < 中间下标对应的元素 :结束下标 = 中间下标-1
else if(i < midIndex){
endIndex = midIndex-1;
} //当要查找的元素 == 中间下标对应的元素
else {
return midIndex;
}
}
return -1;
}
}
数组的扩容
public class DilatationArr {
public static void main(String[] args) {
//当原来的数组长度不够了需要扩容
//旧数组
String[] strArr = {"张三","李四","王五"};
//扩容
String[] newArr = new String[strArr.length+1];
System.arraycopy(strArr,0,newArr,0,strArr.length);
//新增元素
newArr[3] = "赵六";
//把新数组的地址赋值给旧数组
strArr = newArr;
for (String s : strArr) {
System.out.println(s);
}
}
}
数组的插入
public class ArrInsert {
public static void main(String[] args) {
//数组元素的插入 数组未满 数组已满
//1、数组未满
String [] arr = new String[5];
arr[0] = "张三";
arr[1] = "李四";
arr[2] = "王五";
//下标为1 的位置插入元素
System.arraycopy(arr,1,arr,2,2);
arr[1] = "赵六";
for (String s : arr) {
System.out.println(s);
}
//2、数组已满 再次插入数据要进行扩容
String [] arr1 = {"张三","李四","王五"};
//在下标为1的位置插入元素
String [] newArr = new String[arr1.length+1];
System.arraycopy(arr1,0,newArr,0,1);
System.arraycopy(arr1,1,newArr,2,2);
newArr [1] = "赵六";
arr1 = newArr;
for (String s : arr1) {
System.out.println(s);
}
}
}
数组元素的删除
public class ArrDelete {
public static void main(String[] args) {
String [] arr = {"张三","李四","王五"};
/*
思路一:
新建一个新数组,存储俩元素
将删除元素前后的元素放到新数组内
将新数组的地址赋给旧数组
遍历旧数组
思路二:
在数组arr里将 王五向前移动一位 ,元素3的位置为null 即为删除李四
*/
System.arraycopy(arr,2,arr,1,1);
arr[2] = null;
for (String s : arr) {
System.out.println(s);
}
}
}
选择排序
import java.util.Arrays;
public class SelectionSort {
public static void main(String[] args) {
int[] arr = {1,8,9,2,6,7,5,3,4,10};
for (int i = 0; i < arr.length - 1; i++) {
//假设此位置就是最小值
int minIndex = i;
//假设的值与假设之后的值比较
for (int j = i+1; j < arr.length; j++) {
//进行比较,找真正最小值的下标
//如果一个数比假设的最小值小,说明此数是小数
if (arr[j]<arr[minIndex]) {
//切换最小值的下标
minIndex = j;
}
}
//循环结束后,假设的最小值的下标发生了变化,则进行交换俩数的位置
if (minIndex != i) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
System.out.println("排序中"+Arrays.toString(arr));
}
//遍历排序后数组
for (int i : arr) {
System.out.println(i);
}
}
}
数组的工具类:Arrays
熟练掌握:toString()、sort()、copyOf()、binarySearch()
import java.util.Arrays;
/*
如果比较是系统类型可直接使用Arrays.sort()
如果是自定义类型:
Student[] ss = {s1,s2,s3};
自定义类实现了Comparable接口
Arrays.sort(ss);
自定义类没有实现Comparable接口
Arrays.sort(ss,比较规则);
*/
public class ArrayTest {
public static void main(String[] args) {
int[] arr = {6,5,4,3,2,1};
System.out.println(Arrays.toString(arr));//输出数组 [6, 5, 4, 3, 2, 1]
//Arrays.sort(排序的数组,开始的下标,结束的下标); [开始下标,结束下标)
Arrays.sort(arr,0,4);
System.out.println(Arrays.toString(arr));//[3, 4, 5, 6, 2, 1]
Arrays.sort(arr);//从小到大排序
System.out.println(Arrays.toString(arr));//[1, 2, 3, 4, 5, 6]
int[] arr1 = new int[5];
Arrays.fill(arr1,10);//填充数组
System.out.println(Arrays.toString(arr1));//[10, 10, 10, 10, 10]
//按照指定范围填充元素 Arrays.fill(数组名,开始下标,结束下标,填充元素);
Arrays.fill(arr1,0,3,20);//[0,3)填充数组
System.out.println(Arrays.toString(arr1));//[20, 20, 20, 10, 10]
String[] s = {"张三","李四","王五"};
//复制旧数组,创建一个新数组,改动新数组不会对旧数组造成影响
String[] ss = Arrays.copyOf(s,2);
//复制指定范围的数组Arrays.copyOfRange(数组名, 开始下标, 结束下标);
String[] sss = Arrays.copyOfRange(s, 0, 1);//[0,1)
System.out.println(Arrays.toString(s));//[张三, 李四, 王五]
System.out.println(Arrays.toString(ss));//[张三, 李四]
System.out.println(Arrays.toString(sss));//[张三]
int[][] arrInt = {{1,2},{3,4},{5,6}};
//遍历二维数组Arrays.deepToString(数组名)
System.out.println(Arrays.deepToString(arrInt));
int[] a1 ={1,2};
int[] a2 ={1,2};
System.out.println(a1 == a2);//false :比较的是地址值
//Arrays.equals(a1, a2);比较的内容和下标必须完全一样才会是true
System.out.println(Arrays.equals(a1, a2));//true
//二分查找 前提数组必须有序 返回-1 说明数组内不含此元素
int[] arrInt1 = {2,4,6,7,1,3,5,6};
Arrays.sort(arrInt1);
System.out.println(Arrays.toString(arrInt1));//[1, 2, 3, 4, 5, 6, 6, 7]
System.out.println(Arrays.binarySearch(arrInt1, 3));//2
}
}
java.lang.String
String类是一个final类,不能被继承
String是不可变的字符序列,任何一次操作的产生都是新的对象
String字符串的底层采用的是char[]数组存储数据(jdk1.9char[]–>byte[])
package string;
/*字符串的创建*/
public class StringTest {
public static void main(String[] args) {
//1、字符串常量对象,1个,在常量池中
String mess = "你好";
//2
char[] c = {'a','b'};
String s = new String(c);
System.out.println(s);
String s5 = new String(c, 0, 1);
System.out.println(s5);
//3、字符串的普通对象和常量对象一起
//s1首先指向堆中的一个字符串对象,然后堆中字符串的value数组指向常量池中常量对象的value数组
String s1 = new String("你好");
System.out.println(s1);
//4、创建一个空的字符串
String s2 = new String();
System.out.println("s2=" + s2 + "=s2");
//5、注意会将byte类型中数字解析成对应的字符
byte[] bytes = {65,66,67,97};
String s3 = new String(bytes);
System.out.println(s3);
//String s4 = new String(byte类型的数组, 开始的下标, 获取几个元素);
String s4 = new String(bytes, 0, 2);
System.out.println(s4);
int a = 10;
String s6 = ""+a;
String s7 = String.valueOf(a);
System.out.println(s6 +" "+ s7);
String ss1 = "hello";//字符串变量s1 ---> "helLo"在常量池中的位置
String ss2 = "world" ;//字符串变量s2---> "world"在常量池中的位置
String ss3 = "hello" + "world" ;//常量+常量==>常量
String ss4 = "helloworld" ;// helloworld字符串常量
String ss5 = ss1 + ss2;//变量+变量在堆中
String ss6 = ss1 + "wor1d" ;//变量+常量在堆中
System.out.println(ss3 == ss4); //true
System.out.println(ss5 ==ss4);//false
System.out.println(ss6 == ss5);//false
System.out.println(ss6 == ss4);//false
String hello = new String( "hello");
System.out.println(hello == ss1);//false
// hello.intern()调用此方法会将数据直接存到常量池
System.out.println(hello.intern() == ss1);//true
}
}
String常用方法
import java.util.Arrays;
public class StringMethod {
public static void main(String[] args) {
//字符串所有方法不会对原有数据造成影响,都是新建一个去做
int[] arrInt = {1,2};
System.out.println("arrInt.length = " + arrInt.length);
String mess = "你好";
System.out.println("mess.length() = " + mess.length());
String s2 = "world";
String s3 = mess+s2;
String s5 ="你好world";
System.out.println("s3 = " + s3);
//合并字符串
String s4 = mess.concat(s2);
System.out.println("s4 = " + s4);
System.out.println(s5==s4);//false
//小写全变大写
String s = s2.toUpperCase();
System.out.println("s = " + s);//s = WORLD
//大写全变小写
String s1 = s.toLowerCase();
System.out.println("s1 = " + s1);//s1 = world
String ss = "abcDEF";
String ss1 = "ABCdef";
//严格区分大小写
System.out.println("ss.equals(ss1) = " + ss.equals(ss1));//ss.equals(ss1) = false
//忽略大小写比较
System.out.println("ss.equalsIgnoreCase(ss1) = " + ss.equalsIgnoreCase(ss1));//ss.equalsIgnoreCase(ss1) = true
String m1 = "a";
String m2 = "c";
System.out.println(m1.compareTo(m2) + " " + m2.compareTo(m1));//-2 2
String[] arr = {"b","a","z","h"};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));//[a, b, h, z]
// trim()去除字符串两端的空格
String sss = " A B C ";
System.out.println("---"+sss+"---");//--- A B C ---
String trim = sss.trim();
System.out.println("---"+trim+"---");//---A B C---
}
}
package string;
import java.io.UnsupportedEncodingException;
import java.util.Arrays;
public class StringMethod2 {
public static void main(String[] args) throws UnsupportedEncodingException {
String mess = "hello";
//判断是否包含指定的字符串
System.out.println(mess.contains("hel"));//true
//查找指定元素第一次出现的下标(不存在返回-1)
System.out.println(mess.indexOf("l"));//2
//查找指定元素最后一次出现的下标(不存在返回-1)
System.out.println(mess.lastIndexOf("l"));//3
//从指定下标截取到末尾
System.out.println(mess.substring(1));//ello
//截取指定范围的字符串[开始下标,结束下标)
System.out.println(mess.substring(1, 3));//el
//获取指定位置的字符
System.out.println(mess.charAt(mess.length() - 1));//o
//将字符串转为char类型数组
System.out.println(Arrays.toString(mess.toCharArray()));//[h, e, l, l, o]
String mess2 = "ABCDE";
//判断是否以指定的内容开头
System.out.println(mess2.startsWith("ABC"));//true
//判断是否以指定的内容结尾
System.out.println(mess2.endsWith("DE"));//true
//替换字符串,如果查找内容不存在则返回原字符串
System.out.println(mess2.replace("A", "eee"));//eeeBCDE
//编码与解码
String mess1 = "你好";
byte[] bytes = mess1.getBytes();
System.out.println("Arrays.toString(bytes) = " + Arrays.toString(bytes));
byte[] messBytes = mess.getBytes("iso8859-1");
System.out.println(Arrays.toString(messBytes));
System.out.println(mess1.getBytes( "gbk").length);//一个汉字俩字节 4 一个字母一个字节
System.out.println(mess1.getBytes( "utf-8").length);//一个汉字三个字节 6 一个字母一个字节
}
}
正则
package string;
import java.util.Arrays;
public class StringMethod3 {
public static void main(String[] args) {
/*
正则:独立的语言
文本校验
判断输入的文本是否满足要求
[]:代表一个字符
[a-z]:小写字母a-z任意一个都可以
+:一个或多个
*:0个或多个
?:0个或1个
[^a]:代表匹配不是a的数据
java里要加\转义 例:\\d
\d:代表任意一个数字0-9
\w:代表字母和数字以及下划线
^ :代表什么开始
$:以什么结尾
*/
String mess = "abc";
System.out.println(mess.matches("[a-z]+"));//true
System.out.println(mess.matches("[^a]+"));//false
String mess1 = "01";
System.out.println(mess1.matches("\\d+"));//true
//匹配手机号
String ss = "17678900944";
System.out.println(ss.matches("1[3578]\\d{9}"));//true
String str = "hello23091wor.;090ld";
//除了字母全部去掉
System.out.println(str.replaceAll("[^a-zA-Z]+", ""));//helloworld
String sss = "a1b1c";
//按照指定的要求进行切割
String[] split = sss.split( "1");
System.out.println(Arrays.toString(split));//[a, b, c]
String mess2 ="AB1CD3jk8op" ;
//按照数字进行切割
String[] split1 = mess2.split("\\d");
System.out.println( Arrays.toString(split1));//[AB, CD, jk, op]
String mess3="1AB1cD32jk8op2";
//"^\d|\d$"以数字开头或者以数字结尾
String s = mess3.replaceAll("^\\d|\\d$", "");//AB1cD32jk8op
System.out.println(s);
System.out.println(Arrays.toString(s.split("\\d+")));//[AB, cD, jk, op]
}
}
StringBuffer和StringBuilder可变字符序列
String是不可变的字符序列,涉及到字符串的改变会创建大量的对象
- StringBuffer :一个是线程安全的 ;效率低
- StringBuilder: 线程不安全的 ;效率高
- 共同点:
1. 底层是采用char类型的数组存储数据,char数组默认长度是16
2. 他们的父类都是 AbstractStringBuilder抽象类
3. 方法相同 - 效率:StringBuilder>StringBuffer>>String
package string;
public class Test {
public static void main(String[] args) {
StringBuffer stringBuffer = new StringBuffer("HelloWorld");
//append()在原有字符串的末尾进行追加
StringBuffer append = stringBuffer.append(10).append(20).append(3.14);
System.out.println(append);
System.out.println(append.length());//18
//指定长度
append.setLength(60);
System.out.println(append.length());//60
//返回指定元素第一次出现的下标
System.out.println(append.indexOf("l"));//2
//返回指定元素最后一次出现的下标
System.out.println(append.lastIndexOf("l"));//8
//将指定元素插入到指定的位置
append.insert(0,"你好");
System.out.println(append);//你好HelloWorld10203.14
//删除指定范围内元素[开始元素下标,结束元素下标)
append.delete(0,2);
System.out.println(append);//HelloWorld10203.14
//删除指定位置的字符
append.deleteCharAt(15);
System.out.println(append);//HelloWorld1020314
//设置指定位置字符
append.setCharAt(0,'嘿');
System.out.println(append);//嘿elloWorld1020314
//方法相同
StringBuilder stringBuilder = new StringBuilder();
}
}