1.常用类
1.1 包装类
1.包装类的分类
1.针对八中基本数据类型相应的引用类型–包装类
2.有了类的特点，就可以调用类中的方法
2.包装类和基本数据类型的转换
*装箱：基本类型 --> 包装类型
//手动装箱
int n1 = 100;
Integer integer = new Integer(n1);
Integer integer1 = Integer.valueOf(n1);//自动装箱
//int -> Integer
int n2 = 200;
Integer integer2 = n2;
*拆箱：包装类型 --> 基本类型
//手动拆箱
//Integer -- > int
int i = integer.intValue();
3.包装类型和String类型的相互转换
//包装类(Integer) ->String
Integer i = 100;//自动装箱
//方式1
String str1 = i + "";//方式2
String str2 = i.toString();//方式3
String str3 = String.valueOf(i);//String -> 包装类(Integer)
//方式1
String str4 = "12345";
Integer i2 = Integer.parseInt(str4);//自动装箱//方式2
Integer integer = new Integer(str4); //构造器4.Integer和Character常用的方法
System.out.println(Integer.MIN_VALUE);//返回最小值
System.out.println(Integer.MAX_VALUE);//返回最大值System.out.println(Character.isDigit('a'));//判断是不是数字
System.out.println(Character.isLetter('a'));//判断是不是字母
System.out.println(Character.isUpperCase('a'));//判断是不是大写
System.out.println(Character.isLowerCase('a'));//判断是否为小写System.out.println(Character.isWhitespace('a'));//判断是不是空格
System.out.println(Character.toUpperCase('a'));//转成大写
System.out.println(Character.toLowerCase('A'));//转成小写
*valueOf范围为-128 —127，否则就会new Integer(xx);
*如果xx在IntegerCache.low(-128)~IntegerCache.high(127),就直接从数组返回
1.2 String类
*String 对象用于保存字符串
*字符串常量对象是用双引号括起来的字符序列
*字符串的字符使用Unicode字符编码，一个字符(不区分字母还是汉字)占两个字节
*String类常用构造器
String s1 = new String();
String s2 = new String(String original);
String s3 = new String(char[] a);
String s4 = new String(char[] a,int startIndex,int count)
1.创建String对象的两种方式
1.直接赋值
String s = "hspedu";
2.调用构造器
String s2 = new String("hspedu");
2.字符串的特性
1.String是一个final类，代表不可变的字符序列
2.字符串是不可变的，一个字符串对象一但被分配，其内容不可变。(如果想要改变就是直接更改指向地址)
3.String类的常见方法
*String类是保存字符串常量的，每次更新都需要重新开辟空间，效率较低，因此还提供了StringBuilder和StringBuffer来增强String的功能
1.equals
//区分大小写，判断内容是否相等
直接用==号的话，判断的是地址是否相同
str1.equals(str2);
2.equalsIgnoreCase
//忽略大小写的判断内容是否相等
str1.equalsIgnoreCase(str2);
3.length
//获取字符的个数，字符串的长度
str1.length();
4.indexOf
//获取字符在字符串中第一次出现的索引，索引从0开始，如果找不到，返回-1
str1.indexOf("@"); //@符号第一次出现的位置
5.lastIndexOf
//获取字符在字符串中最后一次出现的索引，索引从0开始，如找不到，返回-1，同时查找两个字符则返回第一个字符的位置
6.substring
//截取指定范围的字串
String name = "hello,wisth";
//下面name.substring(6) 从索引6开始截取后面所有的内容
System.out.println(name.substring(6)); //截取后面的字符
System.out.println(name.substring(0,5)); //表示从索引0开始截取，截取到索引 5-1=4的位置，5不包括
7.trim
//去前后空格
8.charAt
//获取某索引处的字符，注意不能使用Str[index]这种方式
str1.charAt(0); //获取字符串0号位置的字符
9.toUpperCase
//转换成大写
String s = "hello";
System.out.println(s.toUpperCase());
10.toLowerCase
//转换成小写
11.concat
//拼接字符串
String s1 = "宝玉";
s1 = s1.concat("123").concat("456").concat("789");
12.replace
//替换字符串中的字符
s1 = s1.replace("123","789"); //把所有的123替换成789
//s1.replace() 方法执行后，返回的结果才是替换过的
//replace对s1没有任何影响
String s11 = s1.replace("123","789");
13.split
//分割字符串，对于某些分割字符，我们需要转义比如 | \\等，两个斜杠表示一个斜杠
String poem = "锄禾日当午，汗滴禾下土，谁知盘中餐，粒粒皆辛苦";
String[] split = poem.split("，"); //以，为标准对poem进行分割，返回一个数组
for(int i =0;i<split.length;i++)
{System.out.println(split[i]);
}
14.toCharArray
转成字符数组
s = "happy";
char[] chs = s.toCharArray();
for(int i =0;i < chs.length;i++)
{System.out.println(chs[i]);
}
15.compareTo
比较两个字符串的大小
//如果前者大，则返回正数，后者大，则返回负数，如果相等，则返回0
1.如果长度相同，并且每个字符也相同，返回0
2.如果长度相同或者不相同，但是比较时，可以区分大小
就返回 if ( c1 != c2) {
return c1 - c2;
}
3.如果前面的部分都相同，就返回 str1.len - str2.len
String a = "jcck";
String b = "jack";
System.out.println(a.compareTo(b)); //返回值是'c'-'a' = 2的值
16.format
格式字符串，用占位符填充
1.占位符%d,%s,%.2f,%c
2.这些变量由后面的变量来替换
3.%d 用整数替换
4.%s 表示由后面的字符串替换
5.%.2f 用小数来替换，替换后，保留两位小数，并进行四舍五入的处理
6.%c 用char类型数据替换
String str2 = String.format("我的姓名是%s 年龄是 %d，成绩是%.2f 性别是 %c，希望大家喜欢我", name,age,score,gender);//或者
String formatStr = "我的姓名是%s 年龄是 %d，成绩是%.2f 性别是 %c，希望大家喜欢我";String info2 = String.format(formatStr,name,age,score,gender)
1.3 StringBuffer类
*StringBuffer代表可变字符序列，可以对字符串内容进行增删
*很多方法与String相同
*StringBuffer是一个容器
StringBuffer stringBuffer = new StringBuffer(“hello”);
1.StringBuffer构造器
//1.创建一个大小为16的char[]，用于存放字符内容
StringBuffer stringBuffer = new StringBuffer();StringBuffer stringBuffer1 = new StringBuffer("123");//2.通过构造器指定char[]大小
StringBuffer stringBuffer2 = new StringBuffer(100);//3.通过给一个String创建一个StringBuffer，此时char[]大小就是hello.length()+16
StringBuffer hello = new StringBuffer("hello");
2.StringBuffer和String的转换
1.String —> StringBuffer
String str = "hello tom";
//1.使用构造器
//返回的才是StringBuffer对象,对str本身没有影响
StringBuffer stringBuffer = new StringBuffer(str);//2.使用append方法
StringBuffer stringBuffer1 = new StringBuffer();
StringBuffer1 = stringBuffer1.append(str);
2.StringBuffer —> String
StringBuffer stringBuffer3 = new StringBuffer("小吴");
//1.使用toString方法
String s= stringBuffer3.toString();//2.使用构造器来搞定
Stirng s1 = new String(stringBuffer3);
3.常用方法
1.append //增加
2.delete //删除
s.delete(11,14);
//删除11~14的字符 [11,14)，不包括14号位置的字符
3.replace //替换
s.replace(9,11,"小树苗");
//使用小树苗替换索引9-11的字符，不包括11，如果9-10为两个字符，则用小树苗替换这两个字符
4.indexOf //查找
5.insert //插入
s.insert(9,"赵明");
//在索引为9的位置插入“赵明”，原来索引为9的位置内容自动后移
1.4 StringBuilder类
*一个可变的字符序列，此类提供一个与StringBuffer兼容的API，但不保证同步(StringBuilder不是线程安全)，该类被设计用作StringBuffer的一个简易替换，用在字符串缓冲区被单个线程使用的时候，如果可能，建议优先采用该类，因为大多数实现中，它比StringBuffer快
*在StringBuilder上主要操作是appends和insert方法，可重载这些方法，以接受任意类型的数据
*String,StringBuffer,StringBuilder比较
1.5 Math类
*Math类包含用于执行基本数学运算的方法，如初等指数，对数，平方根和三角函数
1.abs
//绝对值
int a = Math.abs(-9);
2.pow
//求幂
double pow = Math.pow(2,4);//2的四次方
3.ceil
//向上取整(转成double)
double pow = Math.ceil(-3.0001);//返回-3
4.floor
//向下取整(转成double)
double pow = Math.floor(3.0001);//返回3
5.round
//四舍五入
long round = Math.round(-5.001);
6.sqrt
//求开方
double sqrt = Math.sqrt(9.0);
7.random
//求随机数
8.max
//求两个数的最大值
max(1,14);
9.min
//求两个数的最小值
1.6 Arrays类
1.toString
//1.toString 返回数组的字符串形式
Arrays.toString(arr);Integer[] integers = {1,20,90};
System.out.println(Arrays.toString(integers));
2.sort
//排序
Integer arr[] = {1,-1,7,0};
//进行排序
Arrays.sort(arr,new Comparator()); //comparator返回的值大于0则升序(冒泡排序)，小于0则降序
//sort排序代码
3.binarySearch
//通过二分搜索法进行查找，要求必须排好序
Integer[] arr = {1,2,90,123,567}//数组为有序的才可以使用
//如果数组中不存在该元素，就返回-1
int index = Arrays.binarySearch(arr, 3);
*key not found 返回 - (应该在的位置+1)
4.copyOf
*从arr数组中，拷贝arr.length个元素到newArr数组中
*如果拷贝的长度 > arr.length就在新数组的后面增加null
//数组元素的复制
Integer[] newArr = Arrays.copyOf(arr, arr.length);
5.fill
//数组元素的填充
//用99替换原来的元素
Integer[] num = new Integer[]{9,3,2};
Arrays.fill(num, 99);
6.equals
//比较两个数组元素内容是否完全一致
boolean equals = Arrays.equals(arr,arr2);
7.asList
//将一组值，转换成list
List<Integer> asList = Arrays.asList(2,3,4,5,6,1);System.out.println("asList=" + asList);
1.7 System类
1.exit
//退出当前程序
System.exit(0);
//0表示一个状态，正常状态
2.arrays.copy
//复制数组元素，适合底层调用，一般使用Arrays.copyOf完成复制数组
int[] src = {1,2,3};
int[] dest = new int[3];
System.arraycopy(src,0,dest,0,3);//src.length()
3.currentTimeMillens
//返回当前时间距离1970-1-1的毫秒数
System.out.println(System.currentTimeMillens());
4.gc
//运行垃圾回收机制
1.8 BigInteger和BigDecimal类
BigInteger bigInteger = new BigInteger("2379999999999999999999999");//转成字符串
BigInteger bigInteger = new BigInteger("100");//1.在对BigInteger进行加减乘除的时候，需要使用对应的方法，不能直接进行 + - * /
BigInteger add = bigInteger.add(bigInteger2);
*BigInteger 大整数(整型)
*BigDecimal 大精度(小数)
1.add
//加
2.subtract
//减
3.multiply
//乘
4.divide
//除
BigDecimal bigDecimal = new BigDecimal("19999.111111111111999999999");
BigDecimal bigDecimal2 = new BigDecimal("2");
//在调用divide方法时，指定精度即可，BigDecimal.ROUND_CEILING
//如果有无限循环小数，就会保留分子的精度
System.out.println(bigDecimal.divide(bigDecimal2,BigDecimal.ROUND_CEILING)
1.9 Date类
*java.util.Date包下
1.第一代日期类
1.Date：精确到毫秒，代表特定的瞬间
2.SimpleDateFormat：格式和解析日期的类
SimpleDateFormat 格式化和解析日期的具体类。它允许进行格式化(日期->文本)、解析(文本->日期)和规范化
Date d1 = new Date(); //获取当前系统时间
System.println("当前系统时间为："+ d1);
//默认输出的日期格式是国外的方式，因此通常需要对格式进行转换Date d2 = new Dae(9234567); //通过指定毫秒数得到时间
System.out.println(d1.getTime()); //获取某个时间对应的毫秒数//1.创建SimpleDateFormat对象，可以指定对应的格式
//2.这里的格式使用的字母是规定的，如下表
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss E");
String format = sdf.format(d1);//1.把一个格式化的String转成对应的Date
//2.在把String -> Date使用的sdf格式需要和你给的String格式一样，否则会抛出转换异常String s = "1996年01月01日 10:20:30 星期一";
Date parse = sdf.parse(s);
2.第二代日期类
*Calender(日历)
*Calender类是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段提供了一些方法
//1.Calender是一个抽象类，并且构造器是private
//2.可以通过getInstance() 来获取实例
//3.提供大量的方法和字段提供给程序员
Calender c = Calender.getInstance();//2.获取日历对象的某个日历字段
System.out.println("年："+c.get(Calendar.YEAR));//月要+1，因为Calendar返回月时，是按照0开始编号
System.out.println("月："+(c.get(Calendar.MONTH) + 1));
System.out.println("日："+c.get(Calendar.DAY_OF_MONTH));
System.out.println("小时："+c.get(Calendar.HOUR));//HOUR_OF_DAY 改为24小时制
System.out.println("分钟:"+c.get(Calendar.MINUTE));
System.out.println("秒："c.get(Calendar.SECOND));//Calendar没有专门的格式化方法，所以需要自己来组合显示
3.第三代日期类
*可变性：像日期和时间这样的类应该是不可变的
*偏移性：Date中的年份是从1900开始的，而月份都从0开始
*格式化：格式化只对Date有用，Calender不行
*不是线程安全的；不能处理润秒(每隔2天，多出1s)
1.常见方法
1.LocalDate(日期、年月日)、LocalTime(时间、时分秒)、LocalDateTime(日期时间、年月日、时分秒)
//1.使用Now返回当前日期时间的对象
LocalDateTime ldt = LocalDateTime.now();
System.out.println(ldt);ldt.getYear();
ldt.getMonthValue(); //数字的Month
ldt.getMonth(); //英文的Month
ldt.getDayOfMonth();
ldt.getHour();
ldt.getMinute();
ldt.getSecond();
2.DateTimeFormatter格式日期类
类似于SimpleDateFormat
DateTimeFormat dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH小时mm分钟ss秒");
String str = dtf.format(日期对象);
3.Instant //时间戳
//提供了一系列和Date类转换的方式
//Instant--->Date
Date date = Date.from(instant);//Date--->Instant
Instant instant = date.toInstant();//1.通过静态方法Now()获取表示当前时间戳的对象
Instant now = Instant.now();
*其它方法可以自己上网查
