第一章 Object类
1.1 概述
- java.lang.Object类是Java语言中的根类,即所有类的父类。
- API中叙述:
- 类 Object 是类层次结构的根(最顶层)类。每个类都使用 Object 作为超类(父类)。所有对象(包括数组)都实现这个类的方法。
- 如果一个类没有特别指定父类,那么默认则继承自Object类。
- 如果一个类继承了其他的类,那么被继承的类默认也是Object类
public class MyClass /* extends Object */ { //... }
1.2 Object类的toString方法
- API:++String++ toString();
- 返回该对象的字符串表示
- 直接打印对象的名字,其实就是调用对象的toString方法(p = p.toString)
//主方法中 Person p = new Person("张三", 20); String s = p.toString(); System.out.println(s); //cn.javaadvance.day01.demo01.Person@1b6d3586 System.out.println(p); //cn.javaadvance.day01.demo01.Person@1b6d3586
- 所以直接使用toString打印的是地址值(没意义),需要重写Object类中的toString方法,来打印对象的属性
- 格式:(alt + Ins即可)
//定义一个Person类 @Override public String toString() { return "Person{" + "name='" + name + '\'' + ", age=" + age + '}'; }
- 看一个类是否重写的toString方法,直接打印这个类对应对象的名字即可。
- 如果没有重写toString方法,那么打印的就是对象的地址值(默认)
- 如果重写toString方法,那么就按照重写的方式打印
//定义一个Person类:Person.java
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//所以直接使用toString打印的是==地址值==(没意义),需要==重写Object类中的toString方法==,==来打印对象的属性==
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", 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;
}
}
//主方法:Demo01ToString.java
public static void main(String[] args) {
Person p = new Person("张三", 20);
String s = p.toString();
System.out.println(s); //cn.javaadvance.day01.demo01.Person@1b6d3586
System.out.println(p); //cn.javaadvance.day01.demo01.Person@1b6d3586
//测试一些类是否重写了toString方法
Random r = new Random();
System.out.println(r); //没有重写
Scanner sc = new Scanner(System.in);
System.out.println(sc); //重写了toString方法
ArrayList<Integer> listA = new ArrayList<>();
listA.add(1);
listA.add(2);
System.out.println(listA); //重写了toString方法
}
1.3 Object类的equals方法
- API:++boolean++ equals(Object obj)
- 指示其他某个对象是否与此对象“相等”。
- Object类equals方法的源码:
public boolean equals(Object obj) { return (this == obj); }
- 参数:
- Object obj:可以传递任意的对象
- 方法体:
- ==:比较运算符,返回的就是一个布尔值true,false
- 基本数据类型:比较的是值
- 引用数据类型:比较的是两个对象的地址
- this是谁?:那个对象调用的方法,方法中的this就是那个对象
- obj是谁?:传递过来的参数
- 参数:
//定义的Person类和1.2一样
//主方法:Demo02Equals.java
public static void main(String[] args) {
Person p1 = new Person("迪丽热巴", 18);
Person p2 = new Person("古力娜扎", 18);
boolean equals = p1.equals(p2);
System.out.println(equals); //false
//如果想一样就把p2地址赋给p1
p1 = p2;
boolean equals1 = p1.equals(p2);
System.out.println(equals1); //true
}
1.4 重写Object类的equals方法
- Object类的equals方法默认比较的是两个对象的地址值,没有意义
- 所以我们需要重写equals方法,比较两个对象的属性值
- 问题:隐含着一个多态
- Object obj = p2 = new Person(“古力娜扎”, 18);
- 多态的弊端:无法使用子类特有的内容(属性,方法)
- 解决:可以使用向下转型(强转)把Object类型转换为Person
- 需要加一个判断instanceof(左侧对象是否是右侧类的一个实例),是Person类型在转换,防止类型转换异常(ClassCastException)
- 不然创建一个Random类对象比较后,向下转型就会出错
- 需要加一个判断instanceof(左侧对象是否是右侧类的一个实例),是Person类型在转换,防止类型转换异常(ClassCastException)
- 补充:
- 可以增加一个判断,如果传递的参数obj是null(引用数据类型的默认),直接返回false——>提高程序效率
- 可以增加一个判断,传递的参数obj是this本身,直接返回true,提高程序效率
- (自己写的)重写equals
//定义的一个Person类
//(自己写的)重写equals
@Override
public boolean equals(Object obj) {
//可以增加一个判断,传递的参数obj是this本身,直接返回true,提高程序效率
if(obj == this){
return true;
}
//如果传递的参数obj是null(引用数据类型的默认),直接返回false
if(obj == null){
return false;
}
//需要加一个判断,是Person类型在转换,防止类型转换异常(ClassCastException)
if(obj instanceof Person){
//使用向下转型(强转)把Object类型转换为Person
Person p = (Person) obj;
//比较两个对象的属性;一个是调用方法的this(p1),一个就是p(obj = p2)
boolean b = this.name.equals(p.name) && (this.age == p.age); //这里的equals是字符串重写的方法比较两个字符串内容是否相同
return b;
}
//不是Person类型直接返回false
return false;
}
- 注:上面讲原理,实际使用看下面
- 以后使用(alt+Ins)快捷添加——这里直接添加equals()和hashCode()
- 默认equals版本
//快捷键生成的默认版本equals @Override public boolean equals(Object o) { if (this == o) return true; //判断是否是本身 if (!(o instanceof Person)) return false; //判断o如果不是Person的实例返回false Person person = (Person) o; //向下转型 if (getAge() != person.getAge()) return false; //比较年龄,如果不相等就返回false return getName() != null ? getName().equals(person.getName()) : person.getName() == null; //如果不为空执行前面来判断名字,否则和null比较 }
- Java7 +版本——建议使用这个版本【重点】
- 其中调用了Objects(注:多s)工具类里面的equals方法
- Objects传递的是两个对象
- import java.util.Objects;需要导包
@Override public boolean equals(Object o) { if (this == o) return true; //判断是否是本身 if (!(o instanceof Person)) return false; //判断o如果不是Person的实例返回false Person person = (Person) o; //向下转型 return getAge() == person.getAge() && Objects.equals(getName(), person.getName()); //调用了Objects(注:多s)工具类里面的equals方法 }
- 默认equals版本
- 注:今后学习:getClass() != o.getClass()——反射技术,判断o是不是Person类型,等同于:!(o instanceof Person)
1.5 Objects类的equals方法
- 概述Object工具类(因为是静态的所以直接通过类名.来使用)
- 在++JDK7++添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态(static)的实用方法组成,这些方法是:
- null-save(空指针安全的)或null-tolerant(容忍空指针的)
- 字符串和null的字符串比较不会抛异常
- 用于计算对象的hashcode
- 返回对象的字符串表示形式
- 比较两个对象
- null-save(空指针安全的)或null-tolerant(容忍空指针的)
- 在++JDK7++添加了一个Objects工具类,它提供了一些方法来操作对象,它由一些静态(static)的实用方法组成,这些方法是:
- 在比较两个对象的时候(Object类和Objects工具类区别)
- Object类的equals方法容易抛出空指针异常
- Objects工具类的equals方法就优化了这个问题
- Objects工具类equals方法的源码:
public static boolean equals(Object a, Object b) { return (a == b) || (a != null && a.equals(b)); }
- 默认比较的是两个对象的地址,但是如果类重写了(Object类的)equals方法,比较的就是内容【重点】
Person p1 = new Person("人", 18); Person p2 = new Person("人", 18); boolean equals = Objects.equals(p1, p2); System.out.println(equals); //如果Person类重写了Object类的equals方法返回true(比较的是内容) //如果Person类没有重写Object类的equals方法返回false(比较的是地址)
- 对两个对象比较,防止空指针异常
- 默认比较的是两个对象的地址,但是如果类重写了(Object类的)equals方法,比较的就是内容【重点】
- 注:null是不能调用方法的,会抛出空指针异常。【重点】
- 但是String str = “”; //""可以调用方法,虽然为空也是字符串
String s1 = null; //不可以调用方法
String s2 = "aaa";
//boolean b = s1.equals(s2);//这里的equals是字符串重写的方法,比较的是内容
//System.out.println(b); //NullPointerException
boolean b1 = Objects.equals(s1, s2);
System.out.println(b1); //false
1.6 Object类&Objects类总结
- 总结图:
- 同用的类:Student.java
public class Student {
private String name;
private int age;
;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Student)) return false;
Student student = (Student) o;
return getAge() == student.getAge() &&
Objects.equals(getName(), student.getName());
}
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;
}
}
- Objact类中的toString()方法演示
//定义一个Test01.java
public static void main(String[] args) {
String str = "abc";
System.out.println(str); //abc——String类已经重写的toString
Student s = new Student("张三", 20);
//System.out.println(s); //对象地址
//System.out.println(s.toString()); //效果一样
//重写toString后
System.out.println(s); //Student{name='张三', age=20}
}
- Objact类中的equals()方法演示
//定义一个Test02.java
public static void main(String[] args) {
//String类当中重写的equals方法
String s1 = "abc";
String s2 = "abc";
System.out.println(s1.equals(s2)); //true:字符串重写的equals方法,比较内容
Student stu1 = new Student("张三", 20);
Student stu2 = new Student("张三", 20);
//重写方法前
//System.out.println(stu1.equals(stu2)); //false:没有重写类中equals方法,所以比较的地址
//想比较对象中的属性(重写equals方法后)
System.out.println(stu1.equals(stu2)); //true:比较的内容
}
- Objacts工具类中的equals()方法演示
public static void main(String[] args) {
//String类当中重写的equals方法
/* String s1 = "abc";
String s2 = "abc";
System.out.println(s1.equals(s2)); //true:字符串重写的equals方法,比较内容*/
//s1若为null
/*String s1 = null;
String s2 = "abc";
System.out.println(s1.equals(s2)); //NullPointerException空指针异常*/
//避免空指针问题——Objects工具类的equals方法
String s1 = null;
String s2 = "abc";
System.out.println(Objects.equals(s1, s2)); //false
}
第二章 日期时间类——API
2.1 Date类概述(需要util导包)
- java.util.Date 类表示特定的瞬间,精确到毫秒
- 毫秒:千分之一秒 (1000毫秒 = 1秒)
- 特定的瞬间:一个时间点,一刹那时间 (2020-1-2 10:40:43:333)
- 毫秒值得作用:可以对时间和日期进行计算
- 可以把日期转换为毫秒进行计算,计算完毕,再把毫秒转换为日期
- 把日期转化为毫秒
- 当前的日期:2020-1-2
- 时间原点(0毫秒):1970 年 1 月 1 日 00:00:00(++英国格林威治++)——API中称为(历元)
- 就是计算当前日期到时间原点之间一共经历了多少毫秒
- 注:中国属于东八区:会把时间增加8个小时
- 所以在我们这里时间原点是:1970 年 1 月 1 日 08:00:00
- 注:System.currentTimeMillis() //获取当前系统时间一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒(1581389766050L)
public static void main(String[] args) { System.out.println(System.currentTimeMillis()); //获取当前系统时间一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒 }
- 把毫秒转换为日期
- 1 天 = 24 × 60 × 60 = 86400 秒 = 86400 x 1000 = 86400000毫秒
2.2 Date类的构造方法和成员方法
- Date类的空参数构造方法:
- Date():获取的就是当前系统的日期和时间
public static void main(String[] args) { demo01(); } private static void demo01() { Date date = new Date(); System.out.println(date); //Tue Feb 11 11:09:49 CST 2020 }
- CST:中国标准时间
- Date类的有参数构造方法:
- Date(long date):传递毫秒值,把毫秒值转换为Date日期
- 参数要加L
public static void main(String[] args) { demo02(); } private static void demo02() { Date date = new Date(0L); System.out.println(date); //Thu Jan 01 08:00:00 CST 1970 Date d3 = new Date(System.currentTimeMillis()); System.out.println(d3); //Tue Feb 11 11:25:05 CST 2020 }
- 0L:传入的0毫秒就是时间原点(中国的)
- Date类的成员方法
- ++long++ getTime() :把日期转换为毫秒
- API:返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
- 相当于System.currentTimeMillis(),但是getTime()可以是不同对象,不是固定指:当前系统时间一共到1970 年 1 月 1 日 00:00:00经历了多少毫秒
public static void main(String[] args) { demo03(); } private static void demo03() { Date da = new Date(); //获取当前日期 System.out.println(da.getTime()); //1581392267620 }
- ++long++ getTime() :把日期转换为毫秒
2.3 DateFormat类&SimpleDateFormat类介绍
- java.text.DateFormat:是日期/时间格式化子类的抽象类,它以与语言无关的方式格式化并解析日期或时间。
- 子类:Format类的子类
- 抽象类:无法直接创建对象使用
- 作用
- 格式化(日期->文本):将默认英文日期转换为我们看的日期形式,所以转换后为String类型
- 解析(文本->日期):
- 怎么变的->成员方法【重点】
- ++String++ format(Date date)
- 按照指定的模式,把Date日期,格式化为符合模式的字符串
- ++Date++ parse(String source)
- 把符合模式的字符串,解析为Date日期
- ++String++ format(Date date)
- 抽象类:无法直接创建对象使用,所以使用时需要SimpleDateFormat子类【重点】。(java.text.SimpleDateFormat extends DateFormat)
- ++SimpleDateFormat中构造方法++:
- SimpleDateFormat(String pattern)
- 用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
- 参数:
- String pattern:传递指定的模式
- 模式:API中有解释
- 常用模式如下(区分大小写)
* y 年 * M 月 * d 日 * H 时 * m 分 * s 秒
- 写对应的模式,会把模式替换成对应的日期和时间
- “yyyy-MM-dd HH:mm:ss”
- “yyyy年MM月dd日 HH时mm分ss秒”
- 模式中的字母不能更改,连接模式的符号可以更改
- SimpleDateFormat(String pattern)
//主方法:Demo03DateFormat.java
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public static void main(String[] args) throws ParseException { //throws ParseException——>parse()方法用到
//因为DateFormat是抽象类,所以创建对象用SimpleDateFormat子类
//参数就是自己指定的模式
SimpleDateFormat sD = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//获取当前日期:
Date date = new Date();
//使用SimpleDateFormat子类覆盖重写的抽象父类(DateFormat)的方法
//format():按照指定的模式,把Date日期,格式化为符合模式的字符串
String format1 = sD.format(date);
System.out.println(format1); //2020-02-11 12:28:12
//parse():把符合模式的字符串,解析为Date日期
Date parse = sD.parse(format1);
System.out.println(parse);
System.out.println("===================");
//======================格式二
//因为DateFormat是抽象类,所以创建对象用SimpleDateFormat子类
//参数就是自己指定的模式
SimpleDateFormat sD1 = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
//获取当前日期:
Date date1 = new Date();
//使用SimpleDateFormat子类覆盖重写的抽象父类(DateFormat):format方法
//format():按照指定的模式,把Date日期,格式化为符合模式的字符串
System.out.println(sD1.format(date1)); //2020-02-11 12:28:12
}
//结果:
2020-02-11 12:35:38
Tue Feb 11 12:35:38 CST 2020
===================
2020年02月11日 12时35分38秒
2.4 时间日期相关类总结
- Date类
- ++String++ toLocaleString(); //根据本地格式转换日期对象
public static void main(String[] args) {
//空参构造方法
Date d = new Date();
System.out.println(d); //Tue Feb 11 14:46:39 CST 2020
//引用本地日期格式
System.out.println(d.toLocaleString()); //2020-2-11 14:47:42
//有参构造方法
Date d1 = new Date(3000L);
System.out.println(d1.toLocaleString()); //1970-1-1 8:00:03
}
- DateFormat类&SimpleDateFormat类
- 注:adf.format(d) + .var(快捷方式)->String format = adf.format(d);
- parse()方法会涉及到异常,先阶段把它抛出去(throws ParseException)
public static void main(String[] args) {
//空参构造方法
Date d = new Date();
System.out.println(d); //Tue Feb 11 14:46:39 CST 2020
//创建日期格式化对象
SimpleDateFormat adf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String format = adf.format(d);
System.out.println(format); //2020年02月11日 15:03:21
String str = "2021年05月17日 15:03:21";
Date parse = adf.parse(str);
System.out.println(parse); //Mon May 17 15:03:21 CST 2021
}
3. Calendar类(日历类)——>抽象类
* 创建对象不能new,提供了静态方法
1. 创建对象方式:
* Calendar c = Calendar.getInstance();
* 获取日历类对象
2. 成员方法:
* ++int++ get(int n);
* 获取指定日历字段信息
* ++void++ set(int n, int value);(无返回值)
* 将指定日历字段设置为指定的值
* ++void++ add(int n, int value);(无返回值)
* 将指定日历字段增加或减少指定的值
* 注:get方法获取月的时候从0开始,所以要加1
public static void main(String[] args) {
//获取日历类对象
Calendar c = Calendar.getInstance();
//get方法
int year = c.get(Calendar.YEAR);
System.out.println(year); //2020
int month = c.get(Calendar.MONTH) + 1;
System.out.println(month); //2
System.out.println("=============");
//set方法
c.set(Calendar.YEAR, 2088);
year = c.get(Calendar.YEAR);
System.out.println(year); //2088
//add方法
c.add(Calendar.YEAR, 2);
year = c.get(Calendar.YEAR);
System.out.println(year); //2090
c.add(Calendar.YEAR, -2);
year = c.get(Calendar.YEAR);
System.out.println(year); //2086
}
第三章 System类——API
3.1 System类的常用方法
- java.lang.System 类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作
- 常用的方法:
- ++public static long++ currentTimeMillis();
- 返回以毫秒为单位的当前时间。
- ++public static void++ arraycopy(Object src, int srcPos, Object dest, int destPos, int length) ;(无返回值)
- 从指定源数组中复制一个数组,复制从指定的位置开始,到目标数组的指定位置结束。
- ++public static long++ currentTimeMillis();
- currentTimeMillis方法:返回以毫秒为单位的当前时间
- 作用:用来测试程序的效率(看一看运行一个程序需要多长时间)
- 练习:验证for循环打印1-9999所需要使用的时间(毫秒)
- 程序执行之前,先获取一次毫秒值
- 执行for循环
- 程序执行之后,再获取一次毫秒值
- end-start
public class Demo01System {
public static void main(String[] args) {
demo01();
}
private static void demo01() { //验证for循环打印1-9999所需要使用的时间(毫秒)
//程序执行之前,先获取一次毫秒值
long s = System.currentTimeMillis();
//执行for循环
for(int i = 1; i <= 9999; i++){
System.out.println(i);
}
//程序执行之后,再获取一次毫秒值
long e = System.currentTimeMillis();
//end-start
System.out.println("程序共耗时:" + (e - s) + "毫秒"); //程序共耗时:117毫秒
}
}
- arraycopy方法:数组复制的方法
- 参数:(API)
- src - 源数组。
- srcPos - 源数组中的起始位置。
- dest - 目标数组。
- destPos - 目标数据中的起始位置。
- length - 要复制的数组元素的数量。
- 练习:
- 将src数组中前3个元素,复制到dest数组的前3个位置上
- 复制元素前:src数组元素[1,2,3,4,5],dest数组元素[6,7,8,9,10]
- 复制元素后:src数组元素[1,2,3,4,5],dest数组元素[1,2,3,9,10]
- 参数:(API)
public class Demo01System {
public static void main(String[] args) {
demo02();
}
private static void demo02() { //数组复制的方法
//定义源数组
int[] src = {1, 2, 3, 4, 5};
//定义目标数组
int[] dest = {6, 7, 8, 9, 10};
System.out.println("复制前的目标数组:" + Arrays.toString(dest));
//使用System类中arraycopy方法
System.arraycopy(src, 0, dest, 0, 3);
System.out.println("复制后的目标数组:" + Arrays.toString(dest));
/* //for循环
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i] + " ");
}
System.out.println();
//foreach循环
for(int d : dest){
System.out.print(d + " ");
}
System.out.println();*/
//利用Arrays类中的toString方法
}
}
//结果:
复制前的目标数组:[6, 7, 8, 9, 10]
复制后的目标数组:[1, 2, 3, 9, 10]
第四章 StringBuilder类——API
4.1 StringBuilder的原理
- java.lang.StringBuilder(不用导包)
- 也称为:字符串缓存区——支持可变的字符串(提高字符串效率)
- 注:一旦超过16就自动扩容一倍->32
4.2 StringBuilder的构造方法和常用方法
-
构造方法:
- public StringBuilder()
- 构造一个空的StringBuilder容器
- public StringBuilder(String str)
- 构造一个StringBuilder容器,并将字符串添加进去
public static void main(String[] args) { //StringBuilder无参构造 StringBuilder bu1 = new StringBuilder(); System.out.println("bu1:" + bu1); //bu1: //StringBuilder有参构造 StringBuilder bu2 = new StringBuilder("abc"); System.out.println("bu2:" + bu2); //bu2:abc }
- public StringBuilder()
-
常用方法:
- ++public StringBuilder++ append(…)——返回值也是StringBuilder
- 添加任意类型数据的字符串形式,并返回当前对象自身
- append方法返回的是this,调用方法的对象本身
- 所以使用append方法无需接收返回值【重点】
- ++public String++ toString()
- 将当前StringBuilder对象转换为String对象
- ++public StringBuilder++ append(…)——返回值也是StringBuilder
-
StringBuilder类的append方法
- 接收返回值-使用apped方法
public static void main(String[] args) { //创建StringBuilder对象 StringBuilder bu1 = new StringBuilder(); //接收返回值-使用apped方法 StringBuilder bu2 = bu1.append("abc"); System.out.println(bu1); //abc System.out.println(bu2); //abc //引用数据类型比较的是地址 System.out.println(bu1 == bu2); //true,他本身所以无需接收返回值 }
- 基本-使用apped方法【重点】
public static void main(String[] args) { //创建StringBuilder对象 StringBuilder bu1 = new StringBuilder(); bu1.append("abc"); bu1.append(1); bu1.append(true); bu1.append(2.8); System.out.println(bu1); }
3.便捷-链式编程:方法的返回值是一个对象,可以根据对象继续调用方法【重点】
public static void main(String[] args) { //创建StringBuilder对象 StringBuilder bu1 = new StringBuilder(); bu1.append("abc").append(1).append(true).append(2.8); System.out.println(bu1); //abc1true2.8 }
-
StringBuilder类的toString方法
- StringBuilder和String可以相互转换
- String->StringBuilder:可以使用StringBuilder的构造方法
- StringBuilder->String:使用StringBuilder中的toString方法
- StringBuilder和String可以相互转换
public static void main(String[] args) {
///先String->StringBuilder
String str = "Hello";
System.out.println("str:" + str);
StringBuilder bu = new StringBuilder(str);
//StringBuilder添加数据
bu.append(" World");
System.out.println("bu:" + bu);
///StringBuilder->String
String s = bu.toString();
System.out.println("s:" + s);
}
//结果:
str:Hello
bu:Hello World
s:Hello World
4.3 System类&StringBuilder类总结
- System类
public static void main(String[] args) {
//获取一下当前系统毫秒值时间
long time = System.currentTimeMillis();
System.out.println(time);
//arraycopy(int[] src, int srcIndex, int[] dest, int dextIndex, int count)复制数组
int[] src = {1, 2, 3, 4, 5};
int[] dest = {9, 8, 7, 6, 5};
System.out.println("复制前:" + Arrays.toString(dest));
//将src数组中前四个数字复制到dest数组中
System.arraycopy(src, 0, dest, 0, 4);
System.out.println("复制后:" + Arrays.toString(dest));
}
//结果:
1581422894426
复制前:[9, 8, 7, 6, 5]
复制后:[1, 2, 3, 4, 5]
- StringBuilder类
- StringBuilder reverse(); //反转内容
public static void main(String[] args) {
StringBuilder sb = new StringBuilder();
//append方法——链式编程
sb.append(6).append("avd").append(4.9).append(true);
System.out.println(sb);
//reverse方法——反转
sb.reverse();
System.out.println("反转后:" + sb);
//toString方法——StringBuilder转换为String
String s = sb.toString();
System.out.println("转为String后:" + s);
}
//结果:
6avd4.9true
反转后:eurt9.4dva6
转为String后:eurt9.4dva6
第五章 包装类
5.1 包装类的概述
- 包装类:(位于java.lang包中)
- 基本数据类型的数据,使用起来非常的方便,但是没有对应的方法来操作这些数据
- 所以我们可以使用一个类,把基本数据类型的数据包装起来,这个类叫做包装类
- 在包装类中可以定义一些方法,用来操作基本数据类型的数据
- 包装类和基本数据类型的缺点:
- 包装类:无法直接参与运算
- 基本数据类型:没有对应的方法操作数据
5.2 包装类的装箱与拆箱
- 基本数据类型与对应的包装类对象之间,来回转换的过程称为“装箱”与“拆箱”
- 装箱:从++基本数据类型++转换为对应的++包装类对象++
- 拆箱:从++包装类对象++转换为对应的++基本数据类型++
- 装箱
- 构造方法
- Integer(int value) 构造一个新分配的 Integer 对象,它表示指定的 int 值。
- Integer(String s) 构造一个新分配的 Integer 对象,它表示 String 参数所指示的 int 值。
- 注:传递的字符串,必须是基本数据类型的字符串,否则会抛出异常;"100"正确,"a"错误【重点】
Integer int1 = new Integer(1);
- 静态方法
- static ++Integer++ valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
- static ++Integer++ valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
- 注:传递的字符串,必须是基本数据类型的字符串,否则会抛出异常;"100"正确,"a"错误【重点】
Integer int3 = Integer.valueOf(3);
- 构造方法
- 拆箱
- int intValue() 以 int 类型返回该 Integer 的值。
int i = int4.intValue();
public static void main(String[] args) {
//装箱-构造方法
Integer int1 = new Integer(1);
System.out.println(int1); //1,重写了toString方法
Integer int2 = new Integer("2");
System.out.println(int2);
//装箱-静态方法
Integer int3 = Integer.valueOf(3);
System.out.println(int3);
Integer int4 = Integer.valueOf("4");
System.out.println(int4);
//拆箱-intValue方法
int i = int4.intValue(); //将包装类int4拆箱成基本数据类型
System.out.println(i);
}
//结果:
1
2
3
4
4
5.3 包装类的自动装箱与自动拆箱
- JDK1.5之后出现的新特性
- 自动装箱:
- 直接把int类型的整数赋值给包装类
Integer in = 1; //相当于Integer in = new Integer(1);
- 自动拆箱:
- in是包装类,无法直接参与运算,可以自动转换为基本数据类型,再参与计算
in = in + 2;
- 注:in + 2;就相当于in.intValue() + 2 = 3;
- 注:in = in + 2;相当于in = new Integer(3); //自动装箱
- 装箱拆箱例子:
//ArrayList集合无法直接存储整数,可以存储Integer包装类 ArrayList<Integer> listA = new ArrayList<>(); listA.add(1); //自动装箱-->listA.add(new Integer(1)); int i = listA.get(0); //自动拆箱-->listA.get(0).intValue();
5.4 基本类型与字符串类型之间的相互转换【重点】
- 基本数据类型–>String总共有三种方式:
- 基本数据类型直接与“”相连接即可【重点】。
- 如:32 + “”;
String s1 = 100 + ""; //没有转换成功就是300 System.out.println(s1 + 200); //100200
- 使用包装类中的静态方法(++和Object类中的toString不一样++)
- static ++String++ toString(int i)——>返回一个表示指定整数的 String 对象。
String s2 = Integer.toString(123); //没有转换成功就是323 System.out.println(s2 + 200); //123200
- 使用String类中的静态方法
- static ++String++ valueOf(int i)——>返回 int 参数的字符串表示形式。
String s3 = String.valueOf(456); //没有转换成功就是656 System.out.println(s3 + 200); //456200
- 基本数据类型直接与“”相连接即可【重点】。
- String–>对应的基本类型:
- 使用包装类中的静态方法
- 除了Character类之外,都具有parseXxx()静态方法【重点】
- 格式:parseXxx(“字符串”);
int in1 = Integer.parseInt("100"); //没有转换成功就是100200 System.out.println(in1 + 200); //300
- 注:参数字符串有限定(不然会有数组格式化异常)
- 使用包装类中的静态方法
5.5 包装类总结
- 基本数据类型对应的包装类
- 数字转换为字符串(三种方式)
- 基本数据类型直接与“”相连接即可【重点】。
- 如:32 + “”;
String s1 = 100 + ""; //没有转换成功就是300 System.out.println(s1 + 200); //100200
- 使用包装类中的静态方法(++和Object类中的toString不一样++)
- static ++String++ toString(int i)——>返回一个表示指定整数的 String 对象。
String s2 = Integer.toString(123); //没有转换成功就是323 System.out.println(s2 + 200); //123200
- 使用String类中的静态方法
- static ++String++ valueOf(int i)——>返回 int 参数的字符串表示形式。
String s3 = String.valueOf(456); //没有转换成功就是656 System.out.println(s3 + 200); //456200
- 基本数据类型直接与“”相连接即可【重点】。
- 字符串转换为数字
- 使用包装类中的静态方法
- 除了Character类之外,都具有parseXxx()静态方法【重点】
- 格式:parseXxx(“字符串”);
int in1 = Integer.parseInt("100"); //没有转换成功就是100200 System.out.println(in1 + 200); //300
- 使用包装类中的静态方法
- 自动拆装箱
- 自动装箱:
- 直接把int类型的整数赋值给包装类
Integer in = 1; //相当于Integer in = new Integer(1);
- 自动拆箱:
- in是包装类,无法直接参与运算,可以自动转换为基本数据类型,再参与计算
in = in + 2;
- 自动装箱: