文章目录
- 第二章-实用类
- 1、枚举类型
- 2、包装类
- 3、包装类的常用方法
- 4、包装类的自动装箱和拆箱
- 5、String类
- 6、StringBuffer对象
- String,StringBuffer,StringBuilder比较
- 7、Math类
- 8、Random类 -- java.util.Random类
- 9、日期操作类
- 10.实用类,日期类,日历类常用方法代码示例
第二章-实用类
1、枚举类型
枚举
枚举类更加直观,类型安全。使用常量会有以下几个缺陷:
- 类型不安全,可以随便赋值,而枚举类型的话,就只能传入枚举类中包含的对象。
- 没有命名空间。开发者要在常量命名的时候以固定格式开头,这样另外一个开发者再看这段代码的时候,才知常量的含义。
使用场景:
1)作为常量使用
枚举,可以把相关的常量分组到一个枚举类型里。
public enum CarEnum {
BMW, AUDI, BENZ
}
备注:
enum和class、interface的地位一样
使用enum定义的枚举类默认继承了java.lang.Enum,而不是继承Object类。
枚举类的所有实例都必须放在第一行展示,不需使用new 关键字。自动添加public static final修饰。
2)使用Switch选择结构
// 当匹配枚举类型时,会自动强校验,case的值,必须是枚举类中声明的枚举类型变量
CarEnum carEnum = CarEnum.BMW;
switch (carEnum) {
case BMW:
System.out.println("喜提宝马740");
break;
case AUDI:
System.out.println("喜提奥迪RS");
break;
case BENZ:
System.out.println("喜提奔驰E200");
break;
default:
break;
}
3)枚举类内也可以定义属性和方法。注意必须加对应的属性和构造方法(还有普通方法来获取属性)才可以,否则报错
public enum CarEnum {
//枚举类型实例必须放在第一行
BMW("1", "宝马"), AUDI("2", "奥迪"),BENZ("3","奔驰");
private String index;
private String name;
// 构造方法
private CarEnum(String index, String name) {
this.index = index;
this.name = name;
}
// 普通方法
public static String getNameByIndex(String index) {
for (CarEnum car : CarEnum.values()) {
if (car.index.equals(index)) {
return car.name;
}
}
return null;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getIndex() {
return index;
}
public void setIndex(String index) {
this.index = index;
}
/**
* 重新toString方法,输出枚举类型内容
*/
@Override
public String toString() {
return "CarEnum{name="+ name + ",index=" + index + "}";
}
}
2、包装类
java中的基本数据类型int,double等不是对象,无法通过向上转型获取到Object提供的方法,而像String却可以,只因为String是一个类而不是一个类型。基本数据类型由于这样的特性,导致无法参与转型,泛型等过程。为了弥补这个缺陷,java提供了包装类,包装类都在java.lang包下面。
包装类作用:
1)提供了一系列实用的方法,作为基本数据类型对应的类类型,提供了一系列实用的对象操作,如类型转换。
2)集合不允许存放基本数据类型数据,存放数字时,要用包装类型。
3)包含了每种基本数据类型的相关属性,如最大值、最小值、所占位数等
//获取基本数据类型的相关属性
System.out.println(Byte.SIZE);//8
System.out.println(Byte.MIN_VALUE);//-128
System.out.println(Byte.MAX_VALUE);//127
4)所有包装类都是final类型,不能创建它们的子类
5)JDK1.5后,允许基本数据类型和包装类型进行混合数学运算,包装类并不是用来取代基本数据类型的,在基本数据类型需要用对象表示时使用
基本类型和包装类的对应关系:
byte-Byte int-Integer short-Short long-Long float-Float
double-Double boolean-Boolean char-Character
基本数据类型的长度(位-bit)-- 一个字节占8位,char两个字节,可以存放汉字。
System.out.println(Byte.SIZE); //8
System.out.println(Short.SIZE); //16
System.out.println(Integer.SIZE); //32
System.out.println(Long.SIZE); //64
System.out.println(Float.SIZE); //32
System.out.println(Double.SIZE); //64
System.out.println(Character.SIZE);//16
所有包装类都可将与之对应的基本数据类型作为参数,来构造它们的实例:
Integer a = new Integer(100);
Double b = new Double(100.00);
Character c = new Character('A');
Boolean d = new Boolean(true);
除Character类外,其他包装类可将一个字符串作为参数构造它们的实例:
Integer a1 = new Integer("100");
Double d1 = new Double("100.00");
Boolean b1 = new Boolean("true");
注意:
1.Boolean类构造方法参数为String类型时,若该字符串内容为true(不考虑大小写),则该Boolean对象表示true,否则表示false
Boolean d2 = new Boolean("True");
Boolean d3 = new Boolean("TRUE");
Boolean d4 = new Boolean("hello");
2.当包装类构造方法参数为String 类型时,字符串不能为null,且该字符串必须可解析为相应的基本数据类型的数据,否则编译通过,运行时NumberFormatException异常
java
Integer a2 = new Integer("");// NumberFormatException: For input string: ""
Integer a3 = new Integer(null);// NumberFormatException: null
Integer a4 = new Integer("abc");// NumberFormatException: For input string: "abc"
3、包装类的常用方法
1)valueOf
Integer intValue = Integer.valueOf(21);
除Character类外,其他包装类都可以如下操作:
Integer intValue = Integer.valueOf("12");
2) xxxValue()--包装类转换为基本数据类型
Integer in1 = new Integer(100);
int in2 = in1.intValue();
3)toString()--以字符串形式返回包装对象表示的基本类型数据
String str = Integer.toString(50);//自动装箱并调用toString()方法,这也是将基本类型转换为包装类的好处。
String sex = Character.toString('男');
// String str = String.valueOf(21); -- String类提供的方法
4)parseXXX():把字符串转换为相应的基本数据类型数据(Character除外)
int num1 = Integer.parseInt("100");
System.out.println(num1); //100
boolean bool = Boolean.parseBoolean("false");
4、包装类的自动装箱和拆箱
装箱:基本类型转换为包装类的对象
拆箱:包装类对象转换为基本类型的值
//自动装箱
int m = 10;
Integer in = m;
System.out.println(in);//10
//自动拆箱
Integer inn = new Integer(10);
int n = inn;
System.out.println(n);//10
5、String类
定义字符串两种方式:
String s = "Hello World"; // 常用
String s = new String("Hello World");
注意:字符串一经定义,不可以修改,因为是引用地址,所以重新赋值只是指向新的地址
常用方法:
1)length()方法,确定字符串的长度,返回字符串中的字符数
注意:是length()方法,数组是length属性
2)equals()方法,比较存储在两个字符串对象的内容是否一致,区别于==(判断两个字符串在内存中的地址, 即判断是否是同一个字符串对象,object类中equals方法和==是一致的)。
3)equalsIgnoreCase()方法:不区分大小写的判断值是否一致
toLowerCase()方法:转换为小写
toUpperCase()方法:转换为大写
4) 字符串连接
方式1:使用 +
String str = "aa"+"bb"+"cc";
方式2:使用 concat 方法
String str = "aa".concat("bb").concat("cc");
5)字符串提取方法
字符串中单个字符查找
indexOf(int ch/String str)
查找当前字符串中字符或子串,返回字符或子串在当前字符串中从左边起首次出现的位置,若没有返回-1。
indexOf(int ch/String str, int fromIndex)
与第一种类似,区别在于该方法从fromIndex位置向后查找。
lastIndexOf(int ch/String str)
该方法与第一种类似,区别在于该方法从字符串的末尾位置向前查找,返回的位置仍然是左起位置。
lastIndexOf(int ch/String str, int fromIndex)
该方法与第二种方法类似,区别于该方法从fromIndex位置向前查找。
字符串截取:substring方法可以提取字符串中的子串,该方法有两种常用参数:
1)substring(int begin)
//该方法从begin位置(下标)起,从当前字符串中取出剩余的字符作为一个新的字符串返回。
2)substring(int beg, int end)
//该方法从begin位置(下标)起,从当前字符串中取出到end-1位置的字符作为一个新的字符串返回。
字符串去除首尾空格: trim()方法
截去字符串两端的空格,但对于中间的空格不处理。
字符串判断开始、结束
statWith(String prefix)
endWith(String suffix)
用来比较当前字符串的起始字符或子字符串prefix和终止字符或子字符串suffix是否和当前字符串相同
字符串判断是否包含子串
contains(String str)
判断子字符串是否被包含在字符串中,并返回一个布尔类型的值。
字符串分割
split()方法,将一个字符串分割为子字符串,结果作为字符串数组返回
6、StringBuffer对象
特点:
1)可变字符串类,创建StringBuffer类的对象后可以随意修改字符串的内容。
每个StringBuffer 类的对象都能够存储指定容量的字符串,如果字符串的长度超过了 StringBuffer 类对象的容量,则该对象的容量会自动扩大。
2)对字符串频繁修改(如字符串连接)时,使用StringBuffer类可以大大提高程序执行效率
语法:
StringBuffer() 构造一个空的字符串缓冲区,并且初始化为 16 个字符的容量。底层实现是16个字符长度的数组。
StringBuffer(int length) 创建一个空的字符串缓冲区,并且初始化为指定长度 length 的容量。
StringBuffer(String str) 创建一个字符串缓冲区,并将其内容初始化为指定的字符串内容 str,字符串缓冲区的初始容量为 16 加上字符串 str 的长度。
输出字符串的容量大小
capacity()方法返回字符串的容量大小
使用
1)toString -- 转换为String类型
2)append() -- 用于向原有 StringBuffer 对象中追加字符串,常用方法 *
append追加内容到当前 StringBuffer 对象的末尾,类似于字符串的连接。调用该方法以后,StringBuffer 对象的内容也发生了改变。
使用 append() 方法时,如果长度超过了字符串存储空间大小就需要进行扩容,它会重新分配内存,创建一个更大的数组,这个数组的容量是原来的 2 倍 + 2 的大小,并将原先的数组复制过来,再丢弃旧的数组。
3)插入字符串 -- 了解
insert(1, "**");
4)字符串倒序输出:
reverse()方法,可以将字符串内容倒序
String,StringBuffer,StringBuilder比较
1)String是不可变对象,经常改变内容的字符串最好不要使用String,任何对String的改变都 会引发新的String对象的生成
2)StringBuffer是可变的字符串,字符串经常改变的情况可使用StringBuffer,更高效,任何对它所指代的字符串的改变都不会产生新的对象。
3)JDK1.5后提供了StringBuilder,等价StringBuffer。作为一个简易替代,他们的原理和操作基本相同,区别在于StringBuffer支持并发操作,线性安全的,适合多线程中使用。StringBuilder不支持并发操作,线性不安全的,不适合多线程中使用,而且大量字符操作时候,相对来说执行会快.
因此:
String:适用于少量的字符串操作的情况
StringBuilder:适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer:适用多线程下在字符缓冲区进行大量操作的情况
7、Math类
java.lang.Math类提供了常用的数学运算方法和两个静态常量E(自然对数的底数) 和PI(圆周率)
Math.abs(-3.5); //返回3.5
Math.max(2.5, 90.5);//返回90.5
int random = (int) (Math.random() * 10); //生成一个[0,10)之间的随机数
注:Math类方法很多,需要使用直接看API文档即可,不需要全部掌握
8、Random类 – java.util.Random类
简单介绍使用示例,不需要全部掌握,用到时候查下文档即可
//创建一个Random对象
Random rand=new Random();
for(int i=0;i<20;i++){
//随机生成20个随机整数,并显示
int num=rand.nextInt(10);//返回下一个伪随机数,整型的
System.out.println("第"+(i+1)+"个随机数是:"+num);
}
9、日期操作类
1)java.util.Date类:表示日期和时间,提供操作日期和时间各组成部分的方法
Date对象本身所存储的毫秒数可以通过date.getTime()方法得到(long型的值);该函数返回自1970年1月1日 00:00:00 GMT(格林威治平时(Greenwich Mean Time))以来此对象表示的毫秒数(实际中国获取的,是需要加上时区的概念,中国8时区,即我们获取的是1970年1月1日 08:00:00)。
日期转换:
java.text.SimpleDateFormat类
// Date指定格式:yyyy-MM-dd HH:mm:ss
// yyyy -- 年
// MM -- 月
// dd -- 天
// HH -- 24小时制 hh -- 12进制
// mm -- 分钟
// ss -- 秒
// SSS -- 毫秒
// 日期转字符串
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 创建一个date对象保存当前时间
Date date = new Date();
String dateStr = simpleDateFormat.format(date);
// 字符串转日期:
// 已知日期字符串,如何获取当前日期对象
String date1 = "2010-10-01 11:11:11";
try {
Date date2 = sdf.parse(date1);
System.out.println(date2);
} catch (ParseException e) {
e.printStackTrace();
}
//调用parse()方法时 注意 传入的格式必须符合simpleDateFormat对象的格式,即"yyyy-MM-dd HH:mm:ss" 否则会报错!!
且抛出转换异常,需要捕获异常处理。
备注:
模式字母含义:只需要知道常用的几种(一定注意大小写,容易导致数据问题,比如数据库条件用24小时制,而代码处理用12小时制,会出问题)
y 年 Year
M 年中的月份 Month
D 年中的天数 Number
d 月份中的天数 Number
a Am/pm 标记 Text
H 一天中的小时数(0-23)
h am/pm 中的小时数(1-12)
m 小时中的分钟数 Number
s 分钟中的秒数 Number
S 毫秒数 Number
扩展:日期的比较,不能直接使用 > 或者 <
// 方式一:getTime方法,比较两个日期的毫秒数大小
long time1 = date1.getTime();
long time2 = date2.getTime();
if(time1 > time2){
System.out.println("第一个日期大于第二个日期");
} else {
System.out.println("第一个日期小于第二个日期");
}
// 方式二:使用before方法,或者after方法
if(date1.before(date2)){
System.out.println("第一个日期小于第二个日期");
} else {
System.out.println("第一个日期大于第二个日期");
}
// 当前时间加1个小时
Date date3 = new Date();
System.out.println(sdf.format(date3));
long time3 = date3.getTime();
time3 += 60*60*1000;
Date date4 = new Date(time3);
System.out.println(sdf.format(date4));
2)日历Calendar类,java.util.Calendar
用于设置和获取日期/时间数据的特定部分
示例:
// 创建一个代表系统当前日期的Calendar对象
Calendar calendar = Calendar.getInstance();//默认是当前日期
方法或属性:
int get(int field) -- 返回给定日历字段的值
// 获取年
int year = calendar.get(Calendar.YEAR);
// 获取月,这里需要需要月份的范围为0~11,因此获取月份的时候需要+1才是当前月份值
int month = calendar.get(Calendar.MONTH) + 1;
// 获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 获取时
int hour = calendar.get(Calendar.HOUR);
// int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
// 获取分
int minute = calendar.get(Calendar.MINUTE);
// 获取秒
int second = calendar.get(Calendar.SECOND);
// 星期,英语国家星期从星期日开始计算
int weekday = calendar.get(Calendar.DAY_OF_WEEK);
设置指定日期:
// 首先创建一个Calendar的对象,然后再设定该对象中的年月日参数来完成。
// 创建一个Calendar对象
Calendar c1 = Calendar.getInstance();
// c1.set(int year,int month,int day)
c1.set(2018, 11 - 1, 21);// month从0开始
// 也可以单独设置:
c1.set(Calendar.YEAR, 2017);
// 通过日历类获取当前日期对象
Date date = calendar.getTime();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdf.format(date));
Calendar和Date之间的转换:
1)Calendar转Date
// Calendar-->Date
Calendar calendar = Calendar.getInstance();
Date time = calendar.getTime();
2)Date转Calendar
// 日历类和日期类型的转换
String str1 = "2010-10-01 11:11:11";
Date date2 = null;
try {
date2 = sdf.parse(str1);
System.out.println(date2);
} catch (ParseException e) {
e.printStackTrace();
}
// 通过setTime方法,将日期类转换为日历类
Calendar calendar2 = Calendar.getInstance();
calendar2.setTime(date2);
// 获取当前多少周
int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println("当前周数:" + weeks);
// 通过日历类,当前时间加一个小时
Calendar calendar3 = Calendar.getInstance();
calendar3.add(Calendar.HOUR, 1);
System.out.println(sdf.format(calendar3.getTime()));
10.实用类,日期类,日历类常用方法代码示例
public class Test {
public static void main(String[] args) {
/**
* 包装类
*/
Integer i1 = new Integer("1");//包装
Integer i = new Integer(1);//自动装箱
int j =i;//自动拆箱
System.out.println(j);
Character c = new Character('c');
//Character c = new Character("s");不支持char的包装类用字符串构造对象
//Integer i2 =new Integer("");不可以,NumberFormatException异常
//System.out.println(i2);
Boolean b = new Boolean("TRue");//只要是true四个字母不分大小写都对,不是都错
Boolean b1 = new Boolean(true);
System.out.println(b.toString());
Integer is = Integer.valueOf(100);//基本类型转包装类
Character cc = Character.valueOf('c');
int a = Integer.parseInt("11");//字符串转基本类型
System.out.println(a);
int aa = is.intValue();//包装类转基本类型
System.out.println(aa);
System.out.println(cc.toString());//所有包装类都有toString()方法
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Random工具类
*/
Random r1 = new Random();
System.out.println(r1.nextInt(11));
Random r2 = new Random(1);//种子相同,每次随机的值相同
Random r3 = new Random(1);
System.out.println(r2.nextInt());
System.out.println(r3.nextInt());
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Math工具类
*/
System.out.println(Math.random()*10);//随机生成[0,10)
System.out.println(Math.abs(-2));//取绝对值
System.out.println(Math.max(1, 4));//取最大值
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* StringBuffer工具类
*/
StringBuffer sbf = new StringBuffer();
System.out.println(sbf.capacity());
StringBuffer sbf1 = new StringBuffer(10);
System.out.println(sbf1.capacity());
StringBuffer sbf2 = new StringBuffer("abc");
System.out.println(sbf2.capacity());
System.out.println(sbf2.toString());
System.out.println(sbf2.reverse());
sbf2.append("sfa");
System.out.println(sbf2);
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Date工具类
*/
Date date1 = new Date();
long time = date1.getTime();//获得当前毫秒数
System.out.println(time);
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//模板
System.out.println(sdf.format(date1));
time+=60*60*1000;
date1.setTime(time);
System.out.println(time);
System.out.println(sdf.format(date1));
try {
sdf.parse(sdf.format(date1));//date转换为字符串
System.out.println(sdf.parse(sdf.format(date1)));//字符串转换为date
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Date date2 = new Date();
if(date1.getTime()>date2.getTime()){
System.out.println("第一个时间大于第二个");
}else{
System.out.println("第一个时间小于第二个");
}
if(date1.before(date2)){
System.out.println("第一个时间小于第二个");
}else{
System.out.println("第一个时间大于第二个");
}
if(date1.after(date2)){
System.out.println("第一个时间大于第二个");
}else{
System.out.println("第一个时间小于第二个");
}
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* Calendar工具类
*/
Calendar calendar = Calendar.getInstance();
int year =calendar.get(Calendar.YEAR);
System.out.println(year);
int month =calendar.get(Calendar.MONTH);//月的范围为0到11
System.out.println(month+1);
int day =calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
int weekday =calendar.get(Calendar.DAY_OF_WEEK);//从周天开始
System.out.println(weekday);
//指定日期
calendar.set(Calendar.YEAR, 2011);
calendar.set(2022, 11-1, 8);
Date date = calendar.getTime();//将日历类转换为日期类
SimpleDateFormat sdfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sdfs.format(date));
calendar.setTime(date);//日期转换为日历类
int weeks = calendar.get(Calendar.WEEK_OF_YEAR);
System.out.println("当前周数:" + weeks);
System.out.println(sdf.format(calendar.getTime()));
calendar.add(Calendar.MONTH, 1);
System.out.println(sdf.format(calendar.getTime()));
System.out.println();
System.out.println();
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println();
/**
* String工具类
*/
//注意:String:字符串有下标,字符串初始化
String s1 = new String("aa");
String s2 = "bb";
String s3 ="BB";
//注意:为什么字符串是不可变的?因为String是个特殊类,final修饰,改变字符串就是改变地址的指向
//1.s1.length()
System.out.println(s1.length());
//2.equals()由于String类重写了equals()方法,因此比较的是字符串的内容
System.out.println(s1.equals(s2));
//3.equalsIngoreCase()忽视大小写
System.out.println(s2.equalsIgnoreCase(s3));
//toUpperCase()转为大写字母
System.out.println(s2.toUpperCase());
//toLowerCase()转为小写字母
System.out.println(s3.toLowerCase());
//4.字符串的连接
System.out.println(s1.concat("bb").concat("xz"));
//5.字符数组转为字符串
char c1[] = new char[]{'a','b','c'};
String s4 = new String(c1);
System.out.println(s4);
//6,字符串查找子串,从左到右indexOf()
String s5="asdlkjfsda";
System.out.println(s5.indexOf(97));//传入的是ASCII码值,找到的是下标值,没有找到为-1
System.out.println(s5.indexOf("b"));//传入字符串包含的字串,找到的是第一个字母的下标值,没有找到为-1
System.out.println(s5.indexOf(97,0));//第一个参数是ASCII码值,第二个参数是下标值,返回值为下标值,没有找到为-1
System.out.println(s5.indexOf("a",0));//第一个参数是字串,第二个参数是下标值,返回值为下标值,没有找到为-1
//字符串查找子串,从右到左lastIndexOf()
System.out.println(s5.lastIndexOf(97));//从右往左找第一个a出现的地方,传入的是ASCII码值,找到的是下标值,没有找到为-1
System.out.println(s5.lastIndexOf("kj"));//从右往左传入字符串包含的字串,找到的是第一个字母的下标值,没有找到为-1
System.out.println(s5.lastIndexOf(97, 4));//第一个参数是ASCII码值,第二个参数是下标值,返回值为下标值,没有找到为-1
System.out.println(s5.lastIndexOf("kj", 3));//第一个参数是字串,第二个参数是下标值,返回值为下标值,没有找到为-1
//7.字符串截取substring():包前不包后
System.out.println(s5.substring(1));//第一种,截取下标从1开始到s5.length()
System.out.println(s5.substring(2, 4));//第二中,截取下标从2到4的字符串,(包前不包后,2取的上4取不上)
//8.trim()去两头空格,中间无法去掉
String s6=" asd sfsda ";
System.out.println(s6.trim());
//9.startWith():以什么开头
System.out.println(s6.trim().startsWith("a"));//以a开头
System.out.println(s6.trim().startsWith("a", 1));//以a开头,下标为1
//endsWith():以什么结尾
System.out.println(s6.trim().concat(".java").endsWith("java"));//以java结尾
//10.contains()是否包含a,可以用indexOf代替,不为-1则存在
System.out.println(s6.contains("a"));
//11.split()
String s7 = "asfls!asd#adfj";
String s8[] = s7.split("!|#");//以!与#划分
System.out.println(Arrays.toString(s8));
//12.chatAt(下标)
String ss="";
for(int n =0 ;n<s7.length();n++){
char cc1 =s7.charAt(n);
ss += Character.toString(cc1);
}
System.out.print(ss);
//13.replace(oldStr,newStr)
System.out.println();
String ss8 = "sdjflmllfsa";
System.out.println(ss8.replace("sdjf", "jklkl"));
//13.toCharArray()
char[] s9 = ss8.toCharArray();
String ss9 = new String(s9);
System.out.println(ss9);
//14.将字符串打散为字节数组
String ss0 ="dsafsdalakfj";
byte[] bytes = ss0.getBytes();
System.out.println(Arrays.toString(bytes));
}
}