常用类
包装类(Integer例)
-
基本介绍：
八种基本数据类型相应的引用类型——包装类
-
装箱和拆箱：
public class Integer01 { public static void main(String[] args) { //演示int <--> Integer 的装箱和拆箱 //jdk5前是手动装箱和拆箱 //手动装箱 int->Integer int n1 = 100; Integer integer = new Integer(n1); Integer integer1 = Integer.valueOf(n1); //手动拆箱 //Integer -> int int i = integer.intValue(); //jdk5后，就可以自动装箱和自动拆箱 int n2 = 200; //自动装箱 int->Integer Integer integer2 = n2; //底层使用的是 Integer.valueOf(n2) //自动拆箱 Integer->int int n3 = integer2; //底层仍然使用的是 intValue()方法 } } -
包装类方法：
public class WrapperVSString { public static void main(String[] args) { //包装类(Integer)->String Integer i = 100;//自动装箱 //方式1 String str1 = i + ""; //方式2 String str2 = i.toString(); //方式3 String str3 = String.valueOf(i); //String -> 包装类(Integer) String str4 = "12345"; Integer i2 = Integer.parseInt(str4);//使用到自动装箱 Integer i3 = new Integer(str4);//构造器 System.out.println("ok~~"); } } -
Integer创建机制：
public class WrapperExercise03 { public static void main(String[] args) { //示例一 Integer i1 = new Integer(127); Integer i2 = new Integer(127); System.out.println(i1 == i2);//F //示例二 Integer i3 = new Integer(128); Integer i4 = new Integer(128); System.out.println(i3 == i4);//F //示例三 Integer i5 = 127;//底层Integer.valueOf(127) Integer i6 = 127;//-128~127 System.out.println(i5 == i6); //T //示例四 Integer i7 = 128; Integer i8 = 128; System.out.println(i7 == i8);//F //示例五 Integer i9 = 127; //Integer.valueOf(127) Integer i10 = new Integer(127); System.out.println(i9 == i10);//F //示例六 Integer i11=127; int i12=127; //只有有基本数据类型，判断的是 //值是否相同 System.out.println(i11==i12); //T //示例七 Integer i13=128; int i14=128; System.out.println(i13==i14);//T } }
String⭐️
-
基本介绍：
-
String 对象用于保存字符串，也就是一组字符序列
-
字符串常量对象是用双引号括起的字符序列
-
字符串的字符使用Unicode宇符编码，一个字符(不区分字母还是汉字)占两个字节
-
-
创建String对象方式：
- 直接赋值 String s = "hsp";
- 调用构造器 String s2 = new String("hsp");
-
两种方式对比：
-
方式一：先从常量池查看是否有”hsp”数据空间，如果有，直接指向；
如果沒有则重新创建，然后指向。s最终指向的是常量池的空间地址
-
方式二：先在堆中创建空间，里面维护了value属性，指向常量池的hsp空间。如果常量池没有"hsp“，重新创建，如果有，直接通过value指向，最终指向的是堆中的空间地址
-
-
常用构造方法：
-
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);
-
-
注意事项和细节：
- String 是 final类，不能被继承
- string 有属性 private final char valve []; 用于存放字符串内容
- value 是一个final类型，不可以修改(值可以修改，地址不可修改)
- intern方法：返回常量池的地址对象
-
特性：
-
相等特性：
-
equals判断内容
-
==判断地址
public class StringExercise03 { public static void main(String[] args) { String a = "hsp"; //a 指向 常量池的 “hsp” String b =new String("hsp");//b 指向堆中对象 System.out.println(a.equals(b)); //T System.out.println(a==b); //F //b.intern() 方法返回常量池地址 System.out.println(a==b.intern()); //T //ntern方法：返回常量池的地址对象 System.out.println(b==b.intern()); //F } }public class StringExercise04 { public static void main(String[] args) { String s1 = "hspedu"; //指向常量池”hspedu” String s2 = "java"; //指向常量池”java” String s4 = "java";//指向常量池”java” String s3 = new String("java");//指向堆中对象 System.out.println(s2 == s3); // F System.out.println(s2 == s4); //T System.out.println(s2.equals(s3));//T System.out.println(s1 == s2); //F } }
public class StringExercise05 { public static void main(String[] args) { Person p1 = new Person(); p1.name = "hspedu"; Person p2 = new Person(); p2.name = "hspedu"; System.out.println(p1.name.equals(p2.name));//比较内容: True System.out.println(p1.name == p2.name); //T System.out.println(p1.name == "hspedu"); //T String s1 = new String("bcde"); String s2 = new String("bcde"); System.out.println(s1==s2); //False } } class Person { public String name; }
-
-
字符串特性：
-
String c1 =“ab”+"cd”;常量在池中相加
-
String c1 = a + b;变量在堆中相加
String s1 = "hello"; s1 = "haha"; //创建了两个对象，s1指向“hello”， //再在常量池中创建“haha”，s1指向"haha“String a = "hello" + "abc"; //等价于 String a = "helloabc" //判断创建的常量池对象，是否有引用指向public class StringExercise08 { public static void main(String[] args) { String a = "hello"; //创建 a对象 String b = "abc";//创建 b对象 //老韩解读 //1. 先 创建一个 StringBuilder sb = StringBuilder() //2. 执行 sb.append("hello"); //3. sb.append("abc"); //4. String c= sb.toString() //最后其实是 c 指向堆中的对象(String) value[] -> 池中 "helloabc" String c = a + b; String d = "helloabc"; System.out.println(c == d);//F c在堆中 String e = "hello" + "abc";//直接看池，e指向常量池 System.out.println(d == e);//T } } /*底层：String Builder sb = new String Builder(); sb.append(a);sb.append(b); sb是在堆中，井且append是在原来字符串的基础上追加的 重要规则：String c1 =“ab”+"cd”;常量在池中相加 String c1 = a + b;变量在堆中相加 */
-
public class StringExercise09 { public static void main(String[] args) { String s1 = "hspedu"; //s1 指向池中的 “hspedu” String s2 = "java"; // s2 指向池中的 “java” String s5 = "hspedujava"; //s5 指向池中的 “hspedujava” String s6 = (s1 + s2).intern();//s6 指向池中的 “hspedujava” System.out.println(s5 == s6); //T System.out.println(s5.equals(s6));//T } }-
综合训练
class Test1 { String str = new String("hsp"); final char[] ch = {'j', 'a', 'v', 'a'}; public void change(String str, char ch[]) { str = "java"; ch[0] = 'h'; } public static void main(String[] args) { Test1 ex = new Test1(); ex.change(ex.str, ex.ch); System.out.print(ex.str + " and "); System.out.println(ex.ch); } }
-
-
常用方法：
-
equals：区分大小写，判断内容是否相等
-
equalslgnoreCase：忽略大小写的判断内容是否相等
-
length：获取字符的个数，字符串的长度
-
indexOf：获取字符在字符串中第1次出现的索引,索引从0开始，如果找不到,返回-1
-
lastlndexOf：获取宇符在字符串中最后1次出现的索引,索引从0开始，如找不到,返回-1
-
substring： 截取指定范围的子串
-
trim：去前后空格
-
charAt：获取某索引处的字符，注意不能使用Str[index]这种方式
-
toUpperCase：大写字母
-
toLowerCase：小写字母
-
concat：拼接
-
replace：替换字符串中的字符
-
split：分割字符串
-
compareTo：比较两个字符串的大小
-
toCharArray：转换成字符数组
-
format：格式字符串
//1. equals 前面已经讲过了. 比较内容是否相同，区分大小写 String str1 = "hello"; String str2 = "Hello"; System.out.println(str1.equals(str2));// // 2.equalsIgnoreCase 忽略大小写的判断内容是否相等 String username = "johN"; if ("john".equalsIgnoreCase(username)) { System.out.println("Success!"); } else { System.out.println("Failure!"); } // 3.length 获取字符的个数，字符串的长度 System.out.println("韩顺平".length()); // 4.indexOf 获取字符在字符串对象中第一次出现的索引，索引从0开始，如果找不到，返回-1 String s1 = "wer@terwe@g"; int index = s1.indexOf('@'); System.out.println(index);// 3 System.out.println("weIndex=" + s1.indexOf("we"));//0 // 5.lastIndexOf 获取字符在字符串中最后一次出现的索引，索引从0开始，如果找不到，返回-1 s1 = "wer@terwe@g@"; index = s1.lastIndexOf('@'); System.out.println(index);//11 System.out.println("ter的位置=" + s1.lastIndexOf("ter"));//4 // 6.substring 截取指定范围的子串 String name = "hello,张三"; //下面name.substring(6) 从索引6开始截取后面所有的内容 System.out.println(name.substring(6));//截取后面的字符 //name.substring(0,5)表示从索引0开始截取，截取到索引 5-1=4位置 System.out.println(name.substring(2,5));//llo// 1.toUpperCase转换成大写 String s = "heLLo"; System.out.println(s.toUpperCase());//HELLO // 2.toLowerCase System.out.println(s.toLowerCase());//hello // 3.concat拼接字符串 String s1 = "宝玉"; s1 = s1.concat("林黛玉").concat("薛宝钗").concat("together"); System.out.println(s1);//宝玉林黛玉薛宝钗together // 4.replace 替换字符串中的字符 s1 = "宝玉 and 林黛玉 林黛玉 林黛玉"; //在s1中，将 所有的 林黛玉 替换成薛宝钗 // : s1.replace() 方法执行后，返回的结果才是替换过的. // 注意对 s1没有任何影响 String s11 = s1.replace("宝玉", "jack"); System.out.println(s1);//宝玉 and 林黛玉 林黛玉 林黛玉 System.out.println(s11);//jack and 林黛玉 林黛玉 林黛玉 // 5.split 分割字符串, 对于某些分割字符，我们需要 转义比如 | \\等 String poem = "锄禾日当午,汗滴禾下土,谁知盘中餐,粒粒皆辛苦"; //： // 1. 以 , 为标准对 poem 进行分割 , 返回一个数组 // 2. 在对字符串进行分割时，如果有特殊字符，需要加入 转义符 \ String[] split = poem.split(","); poem = "E:\\aaa\\bbb"; split = poem.split("\\\\"); System.out.println("==分割后内容==="); for (int i = 0; i < split.length; i++) { System.out.println(split[i]); } // 6.toCharArray 转换成字符数组 s = "happy"; char[] chs = s.toCharArray(); for (int i = 0; i < chs.length; i++) { System.out.println(chs[i]); } // 7.compareTo 比较两个字符串的大小，如果前者大， // 则返回正数，后者大，则返回负数，如果相等，返回0 // // (1) 如果长度相同，并且每个字符也相同，就返回 0 // (2) 如果长度相同或者不相同，但是在进行比较时，可以区分大小 // 就返回 if (c1 != c2) { // return c1 - c2; // } // (3) 如果前面的部分都相同，就返回 str1.len - str2.len String a = "jcck";// len = 3 String b = "jack";// len = 4 System.out.println(a.compareTo(b)); // 返回值是 'c' - 'a' = 2的值 // 8.format 格式字符串 /* 占位符有: * %s 字符串 %c 字符 %d 整型 %.2f 浮点型 * */ String name = "john"; int age = 10; double score = 56.857; char gender = '男'; //将所有的信息都拼接在一个字符串. String info = "我的姓名是" + name + "年龄是" + age + ",成绩是" + score + "性别是" + gender + "。希望大家喜欢我！"; System.out.println(info); //1. %s , %d , %.2f %c 称为占位符,这些占位符由后面变量来替换 //2. %s 由 字符串来替换 //3. %d 由 整数来替换 //4. %.2f 表示使用小数来替换，替换后，只会保留小数点两位, 并且进行四舍五入的处理 //5. %c 使用char 类型来替换 String formatStr = "我的姓名是%s 年龄是%d，成绩是%.2f 性别是%c.希望大家喜欢我！"; String info2 = String.format(formatStr, name, age, score, gender); System.out.println("info2=" + info2);
-
StringBuffer⭐️
-
基本介绍：
- java.lang.StringBuffer代表可变的字符序列，可以对字符串内容进行增删。
- 很多方法与String相同，但StringBuffer是可变长度的。
- String Buffer是一个容器。
-
注意事项和细节：
- StringBuffer 的直接父类是 AbstractstringBuilder
- StringBuffer 实现了 Serializable，即StringBuffer的对象可以串行化
- 在父类中 AbstractstringBuilder 有属性 char[] valve,不是final，该 valve 数组存放 宁符串内容，引出存放在堆中的
- StringBuffer 是一个final类，不能被继承
- StringBuffer 字符内容存在 char[] value，所以在变化〔增加/删除)不用每次都更换地址(即不是每次创建新对象)
-
String和StringBuffer对比：
- String保存的是宇符串常量，里面的值不能更改，每次String类的更新实际上就是更改地址
- StringBuffer保存的是字符串变量，里面的值可以更改，不用更新地址，效率高
-
构造器：
//1. 创建一个 大小为 16的 char[] ,用于存放字符内容 StringBuffer stringBuffer = new StringBuffer(); //2 通过构造器指定 char[] 大小 StringBuffer stringBuffer1 = new StringBuffer(100); //3. 通过 给一个String 创建 StringBuffer, char[] 大小就是 str.length() + 16 StringBuffer hello = new StringBuffer("hello"); -
String和StringBuffer转换：
// String——>StringBuffer String str = "hello tom"; //方式1 使用构造器 //注意： 返回的才是StringBuffer对象，对str 本身没有影响 StringBuffer stringBuffer = new StringBuffer(str); //方式2 使用的是append方法 StringBuffer stringBuffer1 = new StringBuffer(); stringBuffer1 = stringBuffer1.append(str); // StringBuffer ->String StringBuffer stringBuffer3 = new StringBuffer("韩顺平教育"); //方式1 使用StringBuffer提供的 toString方法 String s = stringBuffer3.toString(); //方式2: 使用构造器来搞定 String s1 = new String(stringBuffer3); -
常用方法：
-
增：append
-
删：delete(start,end)
-
改：replace (start,end,string)
-
查：indexOf
-
插：insert
-
获取长度：length
StringBuffer s = new StringBuffer("hello"); //增 s.append(',');// "hello," s.append("张三丰");//"hello,张三丰" s.append("赵敏").append(100).append(true).append(10.5);//"hello,张三丰赵敏100true10.5" System.out.println(s);//"hello,张三丰赵敏100true10.5" //删 /* * 删除索引为>=start && <end 处的字符 * : 删除 11~14的字符 [11, 14) */ s.delete(11, 14); System.out.println(s);//"hello,张三丰赵敏true10.5" //改 //，使用 周芷若 替换 索引9-11的字符 [9,11) s.replace(9, 11, "周芷若"); System.out.println(s);//"hello,张三丰周芷若true10.5" //查找指定的子串在字符串第一次出现的索引，如果找不到返回-1 int indexOf = s.indexOf("张三丰"); System.out.println(indexOf);//6 //插 //，在索引为9的位置插入 "赵敏",原来索引为9的内容自动后移 s.insert(9, "赵敏"); System.out.println(s);//"hello,张三丰赵敏周芷若true10.5" //长度 System.out.println(s.length());//22 System.out.println(s);
-
StringBulider⭐️
-
基本介绍：
- 一个可变的字符序列。此类提供一个与 StringBuffer 兼容的 API，但不保证同步，
- 该类被设计用作 String Buffer 的个简易替换，用在字符串缓冲区被单个线程使用的时候
- 如果可能，建议优先采用该类，因为在大多数实现中，它比StringBuffer 快
- 在 StringBuilder 上的主要操作是 append 和 insert 方法，可重载这些方法，以接受任意类型的数据
-
注意事项和细节：
- StringBuilder 继承 AbstractstringBuilder 类
- 实现了 Serializable，说明StringBuilder对象是可以串行化(对象可以网络传输，可以保存到文件)
- StringBuilder 是final类，不能被继承
- StringBuitder对象字符序列仍然足存放在其父类 AbstractstringBuilder的 char [I valve;因此，字符序列是堆中
- StringBoilder 的方法，没有做互斥的处理，即没有synchronized 关键字，网此在单线程的情況下使用
-
常用方法：
- 和StringBuffer相同
-
三类对比：
- String：不可变字符序列，效率低,但是复用率高
- StringBuffer：可变字符序列，效率较高(增删)，线程安全
- String Builder：可变字符序列、效率最高、线程不安全
- StringBuilder 和 StringBuffer 非常类似，均代表可变的字符序列，且方法相同
- String使用注意说明：string s="a”;//创建了一个字符串s+="b";1/实际上原来的"a"字符串对象已经丢奔了，现在又产生了一个字符串S+"b”(也就是”ab")。如果多次执行这些改变串内容的操作，会导致大量副本字符串对象存留在内存中，降低效率。如果这样的操作放到循环中，会极大影响程序的性能
-
三类选择：
- 如果宇符串存在大量的修改操作，一般使用 StringBuffer 或StringBuilder
- 如果字符串存在大量的修改操作，并在单线程的情況，使用 StringBuilder
- 如果字符串存在大量的修改操作，并在多线程的情况，使用 String Buffer
- 如果我们字符串很少修改，被多个对象引用，使用String
Math
-
基本介绍：
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数，均为静态方法
-
常用方法：
- abs：绝对值
- pow：求幂
- ceil：向上取整
- floor：向下取整
- round：四舍五入
- sqrt：求开方
- random：求随机数
- max：求两个数的最大值
- min：求两个数的最小值
Date、Calenda、LocalDate
Date
-
常用方法：
-
Date：精确到毫秒，代表特定时间
-
Simple Date Format：格式和解析日期的类SimpleDateFormat 格式化和解析日期的具体类
它允许进行格式化（日期一＞文本）解析（文本-＞日期）和规范化
-
Calenda
-
基本介绍：
是一个抽象类，并且构造器是private，可以通过 getInstance()来获得实例，提供大量的方法和字段
-
常用方法：
- getInstance()：获取实例
- get.XXXX：获取字段
LocalDate
-
常用方法：
-
LocalDateTime ldt = LocalDateTime.now()：获取时间
-
get.Xxxx()：获取字段
-
DateTimeFormatter.format()：格式化
-
DateTimeFormatter.ofPattern()：定制格式化
-
Date date = Date.from(instant);：Instant转换Date
-
Instant instant = date.tolnstant();：Date转换Instant
//1. 使用now() 返回表示当前日期时间的 对象 LocalDateTime ldt = LocalDateTime.now(); //LocalDate.now();//LocalTime.now() System.out.println(ldt); //2. 使用DateTimeFormatter 对象来进行格式化 // 创建 DateTimeFormatter对象 DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); String format = dateTimeFormatter.format(ldt); System.out.println("格式化的日期=" + format); System.out.println("年=" + ldt.getYear()); System.out.println("月=" + ldt.getMonth()); System.out.println("月=" + ldt.getMonthValue()); System.out.println("日=" + ldt.getDayOfMonth()); System.out.println("时=" + ldt.getHour()); System.out.println("分=" + ldt.getMinute()); System.out.println("秒=" + ldt.getSecond()); LocalDate now = LocalDate.now(); //可以获取年月日 LocalTime now2 = LocalTime.now();//获取到时分秒 //提供 plus 和 minus方法可以对当前时间进行加或者减 //看看890天后，是什么时候 把 年月日-时分秒 LocalDateTime localDateTime = ldt.plusDays(890); System.out.println("890天后=" + dateTimeFormatter.format(localDateTime)); //看看在 3456分钟前是什么时候，把 年月日-时分秒输出 LocalDateTime localDateTime2 = ldt.minusMinutes(3456); System.out.println("3456分钟前 日期=" + dateTimeFormatter.format(localDateTime2));
-
System
-
常用方法：
- exit：退出当前程序
- arraycopy：复制数组元素，比较适合底层调用，一般使用Arrays.copyOf完成复制数组
int[] src={1,2.3}:
int[] dest = new int[3];
System.arraycopy (src, 0, dest, 0, 3); - currentTimeMillens：返回当前时间距离1970-1-1的毫秒数
- gc()：运行垃圾回收机制
Arrays
-
基本介绍：
Arrays里面包含了一系列静态方法，用于管理或操作数组(比如排序和搜索)
-
常用方法：
-
toString：返回数组的字符串形式：
Arrays.toString (arr)
-
sort：排序(自然排序和定制排序)：
Arrays.sout(arr)
-
binarySearch：通过二分搜索法进行查找，必须是有排序的数组：
int index = Arrays.binarySearch (arr, 需要查找的数)
-
copyOf：数组元素的复制：
Integer[] newArr = Arrays.copyOf(arr, arr.length)
-
fill：数组元素的填充
Integer[] num = new Integer[]{9,3,2}
Arrays.fill (num, 99); -
equals：比较两个数组元素内容是否完全一
boolean equals = Arrays.equals(arr. arr2) -
aslist：将一组值，转换成list
ListasList = Arrays.asList(2,3,4,5,6,1) Integer[] arr = {1, 2, 90, 123, 567}; // binarySearch 通过二分搜索法进行查找，要求必须排好 // //1. 使用 binarySearch 二叉查找 //2. 要求该数组是有序的. 如果该数组是无序的，不能使用binarySearch //3. 如果数组中不存在该元素，就返回 return -(low + 1); // key not found. int index = Arrays.binarySearch(arr, 567); System.out.println("index=" + index); //copyOf 数组元素的复制 // //1. 从 arr 数组中，拷贝 arr.length个元素到 newArr数组中 //2. 如果拷贝的长度 > arr.length 就在新数组的后面 增加 null //3. 如果拷贝长度 < 0 就抛出异常NegativeArraySizeException //4. 该方法的底层使用的是 System.arraycopy() Integer[] newArr = Arrays.copyOf(arr, arr.length); System.out.println("==拷贝执行完毕后=="); System.out.println(Arrays.toString(newArr)); //ill 数组元素的填充 Integer[] num = new Integer[]{9,3,2}; // //1. 使用 99 去填充 num数组，可以理解成是替换原理的元素 Arrays.fill(num, 99); System.out.println("==num数组填充后=="); System.out.println(Arrays.toString(num)); //equals 比较两个数组元素内容是否完全一致 Integer[] arr2 = {1, 2, 90, 123}; // //1. 如果arr 和 arr2 数组的元素一样，则方法true; //2. 如果不是完全一样，就返回 false boolean equals = Arrays.equals(arr, arr2); System.out.println("equals=" + equals); //asList 将一组值，转换成list // //1. asList方法，会将 (2,3,4,5,6,1)数据转成一个List集合 //2. 返回的 asList 编译类型 List(接口) //3. asList 运行类型 java.util.Arrays#ArrayList, 是Arrays类的 // 静态内部类 private static class ArrayList<E> extends AbstractList<E> // implements RandomAccess, java.io.Serializable List asList = Arrays.asList(2,3,4,5,6,1); System.out.println("asList=" + asList); System.out.println("asList的运行类型" + asList.getClass());
-
BigInteger BigDecimal
-
基本介绍：
-
Biglnteger适合保存比较大的整型
-
BigDecimal适合保存精度更高的浮点型（小数）
-
-
常用方法：
- add：加
- subtract：减
- multiply：乘
- divide：除