1.API

API(Application Programming Interface)，应⽤程序编程接⼝。Java API是⼀本程序员的”字 典”，是JDK提供给我们使⽤的类的说明⽂档。这些类将底层的代码实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使⽤即可。所以我们可以通过查询API的⽅式，来学习Java提供的类，并得知如何使⽤它们。

JDK包结构 为了便于使⽤和维护，JDK类库按照包结构划分，不同功能的类划分在不同的包中；

2.Object类

此类存在于java.lang包下，java.lang.Object类是java语言中的根类，也就是所有类的父类。

根据JDK源代码及Object类的API⽂档，Object类当中包含的⽅法有11个。

其中只有一个无参构造方法，并且没有静态常量，所有方法必须通过对象来调用。

1.Class<?> getClass()

//get class() 可以获得对应的类的对象的字节码文件public class GetClassDemo {public static void main(String[] args) {Student stu1 = new Student("小白",23);Student stu2 = new Student("小青",21);Class c1 = stu1.getClass();//获取对象的字节码文件Class c2 = stu2.getClass();//Class是用来接收字节码文件的类型System.out.println(stu1 == stu2);//false 因为是两块不一样的内存空间，所以地址值不会一样System.out.println(c1 == c2);//true 这对比的是字节码文件一不一样 因为是同一个类 那肯定是一样的}}public class Student {int age;String name;public Student(){}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

2. protected Object clone()

//clone()public class TestClone {public static void main(String[] args) throws CloneNotSupportedException {CloneDemo demo = new CloneDemo();demo.setA(2);demo.setB(5);//深克隆:复制对象CloneDemo cloneDemo = (CloneDemo)demo.clone();//克隆demo对象int a = cloneDemo.getA();System.out.println(a);//2System.out.println(demo == cloneDemo);//false 注意地址值还是不一样的//浅克隆:复制引用CloneDemo cloneDemo1 = demo;System.out.println(cloneDemo1.getB());//5}}//CloneNotSupportedException//当调用 Object 类中的 clone 方法复制对象，但该对象的类无法实现 Cloneable 接口时，抛出该异常。//方法必须重写//必须要实现Cloneable接口,否则会抛出CloneNotSupportedException - 不支持的克隆异常public class CloneDemo implements Cloneable{//Cloneable接口 - 是一个空接口,目的就是为了标记是可克隆的int a;int b;public CloneDemo(){}public CloneDemo(int a,int b){this.a = a;this.b = b;}public int getA() {return a;}public void setA(int a) {this.a = a;}public int getB() {return b;}public void setB(int b) {this.b = b;}@Overridepublic int hashCode() {return super.hashCode();}@Overridepublic boolean equals(Object obj) {return super.equals(obj);}@Overridepublic String toString() {return super.toString();}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}}

3.protected voidfinalize()

内存溢出：在内存中没有存储的地方内存泄漏：内存被没有用的对象占用。一个对象分配内存空间后，在使用结束时没有及时释放，导致一直都在占用内存，没有及时清除，使得实际的可使用内存在减少。java存在垃圾回收机制 - gc ：定时清理内存中的垃圾

注意：java原则上是不存在内存溢出和泄漏问题的。

//当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。// 子类重写 finalize 方法，以配置系统资源或执行其他清除。public class FinalizeDemo {public static void main(String[] args) throws Throwable {Student stu = new Student();//对于任何给定对象，Java 虚拟机最多只调用一次 finalize 方法。stu.setAge(2);stu.finalize();//调用方法 抛出异常System.gc();//垃圾回收:定时清理内存中的垃圾//1.垃圾: 没有引用的对象,被定成垃圾//2.可以手动调用 System.gcSystem.out.println(stu.getAge());}}public class Student {int age;String name;public Student(){}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Override//子类重写protected void finalize() throws Throwable {super.finalize();System.out.println("hhhhh");}}

4.String toString()

返回该对象的字符串表示。 Java语⾔中很多地⽅会默认调⽤对象的toString⽅法： 1、"" + 对象：⾃动调⽤对象的toString⽅法 2、System.out.print（对象）：直接调⽤toString⽅法 toString⽅法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。

public class toStringDemo {public static void main(String[] args) {Student stu = new Student("lulu",25);System.out.println(stu);//day13Api01.d_toString.Student@75412c2fSystem.out.println(stu.toString());//day13Api01.d_toString.Student@75412c2f//重写后：Studnet{name='lulu', age=25}int[] arr = {1,2,4};System.out.println(arr);//[I@282ba1e/** [ :表示数组* I :表示数据类型* @282ba1e : 16进制表示地址值* */}public class Student {int age;String name;public Student(){}public Student(String name, int age) {this.name = name;this.age = age;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}/*public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());} Object中的 toString方法*///如果不希望使⽤toString⽅法的默认⾏为，则可以对它进⾏覆盖重写。@Override //重写过后的//结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。public String toString() {return "Studnet{" +"name='" + name + '\'' +", age=" + age+'}';}}

5.boolean equals(Object obj)

指示其他某个对象是否与此对象“相等”。 调⽤成员⽅法equals并指定参数为另⼀个对象，则可以判断这两个对象是否是相同的。这⾥的“相 同”有默认和⾃定义两种⽅式。1、默认地址比较如果没有覆盖重写equals⽅法，那么Object类中默认进⾏ == 运算符的对象地址⽐较，只要不是 同⼀个对象，结果必然为false。2、对象内容比较如果希望进⾏对象的内容⽐较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以 覆盖重写equals⽅法。

public class EqualsDemo {public static void main(String[] args) {Student stu1 = new Student("lucy",18,001);Student stu2 = new Student("lucy",18,001);System.out.println(stu1.equals(stu2));//true 对象内容System.out.println(stu1 == stu2);//false 地址值}}import java.util.Objects;public class Student {int age;String name;int id;public Student(){}public Student(String name, int age,int id) {this.name = name;this.age = age;this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}@Override//重写后 就是对对象内容比较public boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student ) o;return id == student .id && Objects.equals(name, student.name);}}

ps：其他的方法看API了解

3.日期时间类

1、long

long time = System.currentTimeMillis();

2、Date类

java.util.Date 类表示特定的瞬间，精确到毫秒。 1、创建 a. new Date() -> 获取当前系统时间

b. new Date(long) -> 获得任意时间段的时间 2、常用API setTime() - 设置时间

getTime() - 获得时间 boolean after(Date when)测试此日期是否在指定日期之后。

boolean before(Date when)测试此日期是否在指定日期之前。

import java.util.Date;//当前时间进行推算public class DateDemo {public static void main(String[] args) {long time1 = System.currentTimeMillis();System.out.println(time1);//1627557698806Date date = new Date();System.out.println(date);//Wed Jul 28 19:21:38 CST Date dateNew = new Date((date.getTime()+1l*24*60*60*1000));date = dateNew;System.out.println(date);//Thu Jul 29 19:21:38 CST System.out.println(new Date());//Wed Jul 28 19:21:38 CST // 创建日期对象，把当前的时间System.out.println(new Date(0L));//Thu Jan 01 08:00:00 CST 1970// 创建日期对象，把当前的毫秒值转成日期对象（Date(0)格林威治时间）/** long 和 Date 之间的转换long -> Datea. new Date(long)b. date.setTime(long)Date -> longdate.getTime()* *//*public long getTime()返回自 1970 年 1 月 1 日 00:00:00 GMT以来此 Date 对象表示的毫秒数。 */System.out.println(date.getTime());//1627557698806/** public void setTime(long time)设置此 Date 对象，* 以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。* 参数：毫秒数。*/long time2 = date.getTime();time2 = time2 + 24l * 60 * 60 * 1000;//将推算好的时间设置回date中date.setTime(time2);System.out.println(date);//Fri Jul 30 19:21:38 CST /*boolean after(Date when)测试此日期是否在指定日期之后。boolean before(Date when)测试此日期是否在指定日期之前。 */Date date1 = new Date(time2);boolean before = date1.before(date);System.out.println(before);//falseboolean after = date1.after(date);System.out.println(after);//false}}

3、Calendar类

java.util.Calendar 是抽象类，在Date后出现，替换掉了许多Date的⽅法。该类将所有可能⽤到的时间信息封装为静态成员变量，⽅便获取。⽇历类就是⽅便获取各个时间属性的。

常用API

Calendar 和 Date的转换

Date getTime() -> Calendar 转换成 Date

void setTime(Date) -> Date 转换成 Calendar

calendar 和 long的转换

getTimeInMillis()

setTimeInMillis()

get() - 获取

set(字段,int value) - 设置,时间的跳转

add(字段,int amount) - 时间的推算

import java.util.Calendar;import java.util.Date;//用来做时间的跳转public class CalendarDemo {public static void main(String[] args) {/*get()set()add()根据日历的规则，为给定的日历字段添加或减去指定的时间量。Date getTime() -> Calendar 和 Date之间的转换Calendar 转换成 Datevoid setTime(Date) -> Calendar 和 Date之间的转换Date -> Calendar*/Calendar calendar = Calendar.getInstance();//里面存的都是静态常量System.out.println(calendar.get(Calendar.DAY_OF_MONTH));System.out.println(calendar.get(Calendar.DATE));//setTime(Date date)calendar.setTime(new Date(0));System.out.println(calendar.get(Calendar.YEAR));//1970//add()calendar.add(Calendar.DAY_OF_WEEK,-5);}}

4、long，Date，Calendar三个之间的转换

5、DateFormat类

java.text.DateFormat 是⽇期/时间格式化⼦类的抽象类，我们通过这个类可以帮我们完成⽇期 和⽂本之间的转换,也就是可以在Date对象与String对象之间进⾏来回转换。 格式化：按照指定的格式，从Date对象转换为String对象。 解析：按照指定的格式，从String对象转换为Date对象。 由于DateFormat为抽象类，不能直接使⽤，所以需要常⽤的⼦类 java.text.SimpleDateFormat 。 public SimpleDateFormat(String pattern) ：⽤给定的模式和默认语⾔环境的⽇期格式符号构造SimpleDateFormat。 参数pattern是⼀个字符串，代表⽇期时间的⾃定义格式。 自定义格式需参照

常用API：

public String format(Date date) ：将Date对象格式化为字符串。

public Date parse(String source) ：将字符串解析为Date对象。 parse() -> Date -> String

/*需求:计算某年、某月、某日和某年、某月、某日之间的天数间隔和周数。例如： 7月22日 和 10月1日相差了： xxx天 xx周Math.abs(long) - 计算两个时间之间的差值*/import java.text.ParseException;import java.text.SimpleDateFormat;import java.util.Date;import java.util.Scanner;public class DateFormatDemo {public static void main(String[] args) throws ParseException {Scanner sc = new Scanner(System.in);System.out.println("请输入第一个时间：");//获取到的时间是字符串类型String date1 = sc.nextLine();System.out.println("请输入第二个时间：");//获取到的时间是字符串类型String date2 = sc.nextLine();// 自定义日期格式，将输入的日期进行解析SimpleDateFormat sd = new SimpleDateFormat("yyyy年MM月dd日");//String -> Date输出Date date11 = sd.parse(date1);Date date22 = sd.parse(date2);// 将输入的日期转换成时间戳 -> date转换成longlong time1 =date11.getTime();long time2 = date22.getTime();// 计算两个时间之间的差值 -> long类型进行计算long c = Math.abs(time1 - time2);// 将时间差转换为两个时间相差的天数 1s = 1000mslong day = c/1000/60/60/24; // 将毫秒转化为天long week = day/7;System.out.println(date1+"到"+date2+"相差了："+day+"天"+week+"周");}}

4.String类

1、字符串

存在于java.lang包下String类代表字符串。

1.特点:

a.字符串就是字符序列，本质上就是一个字符数组。

b.String类是final修饰的，不可被继承的。

c.String一旦创建就不可修改，属于不可变的字符序列。

d.String重写了toString()

2.创建方式

a.直接创建

String str = ""；

b.构造方法创建

String()

String(byte[] bytes)

String(byte[] bytes, Charset charset)

String(char[] value)

String(String original)

3.常用API

public String trim() ：返回⼀个字符串，其值为此字符串，并删除任何前导和尾随空 格。 public boolean startsWith(String prefix) ：测试此字符串是否以指定的前缀开始。 public boolean endsWith(String suffix) ：测试此字符串是否以指定的后缀结束。 public String toLowerCase() ：使⽤默认语⾔环境的规则将此字符串中的所有字符都转 换为⼩写。 public String toUpperCase() ：使⽤默认语⾔环境的规则将此字符串中的所有字符都转 换为⼤写。 public static String valueOf(Object obj) ：返回 Object 参数的字符串表示形式。 4.常量池

a.常量池中放的都是常量。

b.只要直接赋值的字符串，都指向常量池。

import java.io.UnsupportedEncodingException;import java.util.Arrays;//字符串的创建public class StringDemo01 {public static void main(String[] args) throws UnsupportedEncodingException {//普通赋值方式String s = "hi";System.out.println(s);//hi//数组int[] i = {1,5,2,2};System.out.println(i);//[I@50cbc42f 地址值System.out.println(Arrays.toString(i));//[1, 5, 2, 2]char[] c = {'h','i'};System.out.println(c);//hi 这样直接输出，跟上面普通赋值输出一样，说明，字符串本质上跟字符数组（字符序列）一样System.out.println(Arrays.toString(c));//[h, i]//String构造方法String s1 = new String(s);//传入一个参数sSystem.out.println(s1);//hi//public String()String s2 = new String(c);System.out.println(s2);//hi//String(byte[] bytes)byte[] b = {97,98,99,100};String b1 = new String(b);System.out.println(b1);//abcd -->因为是以字符串类型输出的，而//String(byte[] bytes, Charset charset)byte[] b2 = {'o'};String b3 = new String(b2,"UTF-8");//throws UnsupportedEncodingException 会抛出不支持异常System.out.println(b3);}}

//编码，解码，乱码问题import java.io.UnsupportedEncodingException;import java.util.Arrays;/*编码问题解析:编码: 字符 -> 字节解码: 字节 -> 字符UTF-8 -> 1字符 = 3字节GBK -> 1字符 = 2字节*/public class StringDemo02 {public static void main(String[] args) throws UnsupportedEncodingException {String str = "哈哈哈";// 把看得懂的方式变成看不懂的方式 -> 编码//以默认方式进行解析byte[] bsUTF = str.getBytes();1字符 = 3字节 UTF-8//[-27, -109, -120, -27, -109, -120]System.out.println(Arrays.toString(bsUTF));//以指定方式进行解析byte[] bsGBK = str.getBytes("GBK");/*[-71, -2, -71, -2]1字符 = 2字节 -> GBK*/System.out.println(Arrays.toString(bsGBK));// 解码: 把看不懂的变成看得懂//乱码的产生String gbk = new String(bsUTF, "GBK");System.out.println(gbk);//鍝堝搱String utf = new String(bsGBK, "UTF-8");System.out.println(utf);//����//解决乱码://1.按照错误的方式进行编码:byte[] gbks = gbk.getBytes("GBK");//[-27, -109, -120, -27, -109, -120]System.out.println(Arrays.toString(gbks));//2.重新解码:String s = new String(gbks);System.out.println(s);}}

/*校验密码是否合法。必须至少9个字符。必须至少2个大写字符。必须包含小写字母和数字。例如: asd12345QWER条件: a - zA - Z0 - 9*/public class StringDemo03 {public static void main(String[] args) {String str = "asd12345QWER";int lowerCount = 0;//小写字母int numCount = 0;//数字int upCount = 0;//大写字母//将str转换成字符数组char[] chars = str.toCharArray();for (int i = 0; i < chars.length; i++) {if(chars[i] >= 'a' && chars[i] <= 'z'){//如果符合lowerCount++;}else if(chars[i] >= '0' && chars[i] <= '9'){//如果符合numCount++;}else if(chars[i] >= 'A' && chars[i] <= 'Z'){//如果符合upCount++;}}if(str.length() > 9 && upCount > 2&& numCount > 0 && lowerCount > 0){System.out.println("符合条件");}else{System.out.println("不符合条件");}}}

/*常用API*/public class StringDemo04 {public static void main(String[] args) {//int length()String str = "asdfc";int length = str.length();System.out.println(length);//和字符相关的方法://char charAt(int index)char c = str.charAt(1);System.out.println(c);//char[] toCharArray()char[] chars = str.toCharArray();System.out.println(chars);//java中大小写非常敏感String s1 = "gbk";String s2 = "GBK";String s3 = "gbK";System.out.println(s1.equals(s2));//转换成全大写String s = s1.toUpperCase();System.out.println(s.equals(s2));//转换成全小写String s4 = s2.toLowerCase();System.out.println(s4.equals(s1));System.out.println("--------------");//忽略大小写boolean b = s3.equalsIgnoreCase(s2);System.out.println(b);}}

2、可变长字符串

存在于java.lang包下的StringBuilder 和 StringBuffer类。

StringBuilder类属于一个没有加锁不安全的可变字符序列，StringBuffer类属于线程安全的可变字符序列。

区别:

a.版本:

StringBuilder -> JDK1.5

StringBuffer -> JDK1.0

b.线程安全

StringBuilder: 线程不安全，效率高。

StringBuffer: 线程安全，效率低。

c.使用环境:

操作少量的数据使用 String

单线程环境下大量数据使用 StringBuilder

多线程环境下大量数据使用 StringBuffer

/*字符串一旦创建就不可变字符串的频繁拼接会产生新的对象,所以String不建议做频繁的拼接*//*StringBuilder的初始化StringBuilder append(Object obj) - 追加StringBuilder delete(int start, int end) - 删除StringBuilder insert(int offset, boolean b) - 插入StringBuilder replace(int start, int end, String str) - 替换StringBuilder reverse() - 反转面试题:String 和 StringBuilder 和 StringBuffer的区别(效率)*/public class StringBuilderDemo {public static void main(String[] args) {//无参构造方法StringBuilder sb = new StringBuilder();//追加字符串sb.append("哈哈");sb.append("嘻嘻");//将StringBuilder 转换成 StringString str = sb.toString();System.out.println(str);String str1 = "大乔";//有参构造方法StringBuilder sb1 = new StringBuilder(str1);//在原有的字符串的基础上进行追加内容sb1.append("貂蝉");sb1.append("西施");sb1.append("妲己");sb1.append("杨玉环");System.out.println(sb1);//StringBuilder delete(int start, int end) - 删除子串//字符子串//前包含后不包含StringBuilder delete = sb1.delete(2,4);System.out.println(delete);//StringBuilder insert(int offset, Object obj) - 插入sb1.insert(2,22);System.out.println(sb1);//StringBuilder replace(int start, int end, String str) - 替换//前包含后不包含sb1.replace(0,2,"小乔");System.out.println(sb1);//StringBuilder reverse() - 反转(回文数)StringBuilder reverse = sb1.reverse();System.out.println(reverse);}}

/*效率对比String < StringBuffer < StringBuilder*/public class StringBufferDemo {public static void main(String[] args) {//String的效率String str = "a";long time1 = System.currentTimeMillis();for (int i = 0; i < 1000000; i++) {str += i;}long time2 = System.currentTimeMillis();System.out.println(time2 - time1);//StringBuilder的效率StringBuilder sb1 = new StringBuilder();for (int i = 0; i < 10000000; i++) {sb1.append(i);}long time3 = System.currentTimeMillis();System.out.println(time3 - time2);//StringBuffer的效率StringBuffer sb2 = new StringBuffer();for (int i = 0; i < 10000000; i++) {sb2.append(i);}long time4 = System.currentTimeMillis();System.out.println(time4 - time3);}}

3、正则表达式

实际开发中，经常需要对字符串数据进⾏⼀些复杂的匹配、查找、替换等操作。通过“正则表达 式”，可以⽅便的实现字符串的复杂操作。 正则表达式是⼀串特定字符，组成⼀个“规则字符串”，这个“规则字符串”是描述⽂本规则的⼯具。 正则表达式就是记录⽂本规则的代码。字符集合

数量词

正则表达式常用API:

String replaceAll(String regex, String replacement)

boolean matches(String regex)

String[] split(String regex)

import java.util.Arrays;/*2.电话号码 11位 第一位1 后10位随便的数字3.验证163邮箱 4.将所有的数字替换成*，连贯的数字只需要替换一个*将字符串按照字母切割(分离),提取出所有的数字，并且连续数字作为一个整体例如:s2 ="abc123der52ersdf45sdf34sewr76"正则表达式常用API:String replaceAll(String regex, String replacement)boolean matches(String regex)String[] split(String regex)*/public class RegularDemo {public static void main(String[] args) {//2.电话号码 11位 第一位1 后10位随便的数字String phone = "15356297421";//regex = [1]\d{10} / 1[0-9]{10}String regex = "[1]\\d{10}";boolean matches = phone.matches(regex);System.out.println(matches);//3.验证163邮箱 -> Qss_7733@String email = "Qss_7733@";// [a-zA-Z]\w{5,17}@163\.comString regex1 = "[a-zA-Z]\\w{5,17}@163\\.com";boolean matches1 = email.matches(regex1);System.out.println(matches1);//4.将所有的数字替换成*,连贯的数字只需要替换一个*String s1 = "我去你大爷,xxx,你个sb";String regex2 = "去你大爷|xxx|sb";String s = s1.replaceAll(regex2, "*");System.out.println(s);/*将字符串按照字母切割(分离),提取出所有的数字，并且连续数字作为一个整体例如:s2 ="abc123der52ersdf45sdf34sewr76"*/String s2 ="abc123der52ersdf45sdf34sewr76";//[a-zA-Z]+String regex3 = "[a-zA-Z]+";String[] split = s2.split(regex3);//[, 123, 52, 45, 34, 76]System.out.println(Arrays.toString(split));}}

5.包装类

Java提供了两个类型系统，基本类型与引⽤类型，使⽤基本类型在于效率，然⽽很多情况，会创 建对象使⽤，因为对象可以做更多的功能，如果想要我们的基本类型像对象⼀样操作，就可以使 ⽤基本类型对应的包装类，如下：

装箱与拆箱

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“： 装箱：从基本类型转换为对应的包装类对象。 拆箱：从包装类对象转换为对应的基本类型。 ⾃动装箱与⾃动拆箱 由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类 的装箱、拆箱动作可以⾃动完成。常用API基本类型转换为String

String -> Integer:

a. Integer.valueOf()

b. new Integer(str)

String -> int:

a. Integer.parseInt()

注意：如果字符串参数的内容⽆法正确转换为对应的基本类型，则会抛出 java.lang.NumberFormatException 异常。常量池:

a.所有的包装类中只有Integer有常量池

b.常量池有取值范围:-128 ~ 127

c.只要超过取值范围,全都是在new对象

public class IntegerDemo01 {public static void main(String[] args) {//直接赋值Integer i1 = 50;//构造方法创建Integer i2 = new Integer(20);//String 转换 成 IntegerInteger i3 = new Integer("30");//常量池Integer i4 = new Integer(40);Integer i5 = new Integer(40);System.out.println(i4 == i5);//falseSystem.out.println(i4.equals(i5));/*常量池的取值范围:byte字节的范围: -128 ~ 127*/Integer i6 = 128;Integer i7 = 128;System.out.println(i6 == i7);//true//falseSystem.out.println("---------");}}

public class IntegerDemo02 {public static void main(String[] args) {Integer i1 = 50;//int i2 = i1;//引用赋值int i2 = 50;//获取Integer的字节码对象Class c1 = i1.getClass();// 获取int类型的字节码对象Class c2 = int.class;System.out.println(c1 == c2);//false// Integer = int//i2 = i1.intValue(); --> 编译器自动实现// 自动拆箱i1 = i2;//自动装箱i2 = i1; // int = Integer//int - > Integer//i1 = Integer.valueOf(i2); --> 编译器默认执行//Integer/int 和 String 之间的转换//Integer -> String / String -> IntegerString str = "123";//方式一:Integer i3 = new Integer(str);//方式二:Integer i4 = Integer.valueOf(str);// int -> String (valueOf()) / String -> intint i5 = Integer.parseInt(str);int i = Integer.parseInt("f", 16);//以16进制方式解析System.out.println(i);//15}}

JAVA day13 14 API Object类 日期时间类（long Date Calendar DateFormat） String类（字符串 可变长字符串） 正则表达式 包装类