1 Object类
类是java语言中的根类,即所有类的父类。它描述的所有方法子类都可以使用。在对象实例化的时候,最终找的父类就是Object。
如果没有一个类没有特别指定父类,那么默认继承自Object类。
Object类中常用的两个类为:
public String toString():
返回该对象的字符串表示。
public boolean equals(Object obj):
指示其他某个对象是否与此对象“相等”。
1.1 toString方法
public String toString():
返回该对象的字符串表示。
toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。
由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。
覆盖重写
如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如自定义的Person类:
public class Person{
private String name;
private int age;
@Override
public String toString(){
return "Person{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
1.2 equals方法
public boolean equals(Object obj):
指示其他某个对象是否与此对象“相等”。
调用成员方法equals并指定参数为另一个对象,则可以判断这两个对象是否相同。这里的“相同”有默认和自定义两种方式。
默认地址比较
如果没有覆盖重写equals方法,那么Object类中默认进行==
运算符的对象地址比较,只要不是同一个对象,结果必然为false。
对象内容比较
如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。
@Override
public boolean equals(Object o) {
// 如果对象地址一样,则认为相同
if (this == o) return true;
// 如果参数为空,或者类型信息不一样,则认为不同
if (o == null || getClass() != o.getClass()) return false;
// 转换为当前类型
Person person = (Person) o;
// 要求基本类型相等,并且将引用类型交给java.util.Objects类的equals静态方法取用结果
return age == person.age &&
Objects.equals(name, person.name);
}
2 System类
java.lang.System
类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:
public static long currenTimeMills():
返回以毫秒为单位的当前时间。
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
将数组中指定的数据拷贝到另一个数组中。
2.1 currentTimeMills方法
实际上,currentTimeMills方法就是获取当前系统时间与1970年01月01日00:00点之间的毫秒值。
2.2 arraycopy方法
public static arraycopy(Object src, int srcPos, Object dest, int destPos, int length):
将数组中指定的数据拷贝到另一个数组中。
代码实现如下:
package Demo05;
import java.util.Arrays;
public class Demo01System {
public static void main(String[] args) {
demo01();
demo02();
}
public static void demo02(){
int[] src = {1,2,3,4,5};
int[] dest = {6,7,8,9,10};
System.out.println("复制前src数组:"+ Arrays.toString(src));
System.out.println("复制前dest数组:"+Arrays.toString(dest));
System.arraycopy(src,0,dest,0,3);
System.out.println("复制后src数组:"+Arrays.toString(src));
System.out.println("复制后dest数组:"+Arrays.toString(dest));
}
public static void demo01(){
long s = System.currentTimeMillis();
for (int i = 0; i < 999; i++) {
System.out.println(i);
}
long e = System.currentTimeMillis();
System.out.println("耗时:"+(e-s)+"毫秒");
}
}
运行结果如下:
3 StringBuilder类
3.1 字符串拼接问题
由于String类的对象内容不可改变,所有每当进行字符串拼接时,总是在内存中创建一个新的对象。例如:
public class StringDemo{
public static void main(String[] args){
String s = "Hello";
s += "World";
System.out.println(s);
}
}
在API中对String类有这样的描述:字符串是常量,它们的值在创建后不能被更改。
根据这句话分析我们的代码,其实总共产生了三个字符串,即“Hello”
、“world”
和HelloWorld
。引用变量s首先指向Hello
对象,最终指向拼接出来的新字符串对象,即Helloworld
。
由此可知,如果对字符串进行拼接操作,每次拼接,都会构建一个新的String对象,既耗时,又浪费空间。为解决这一问题,可以使用java.lang.StringBuilder
类。
3.2 StringBuilder概述
StringBuilder又称为可变字符序列,它是一个类似于String的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。
原来StringBuilder是个字符串的缓冲区,即是一个容器,容器中可以装很多字符串,并且能够对其中的字符串进行各种操作。
它的内部拥有一个数组用来存放字符串内容,进行字符串拼接时,直接在数组中加入新内容,StringBuilder会自动 维护数组的扩容。原理如下图所示:
构造方法
常用构造方法有两个:
public StringBuilder():
构造一个空的StringBuilder容器,其初始容量为 16 个字符。
public StringBuilder(String str):
构造一个StringBuilder容器,并将字符串添加进去。
常用方法
public StringBuilder append(...):
添加任意类型数据的子字符串形式,并返回当前对象自身。
public String toString():
将当前StringBuilder对象转换为String对象。
append方法具有多种重载形式,可以接受任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。
StringBuilder已经覆盖重写了Object当中的toString方法,通过toString方法,StringBuilder对象将会转换为不可变的String对象。
StringBuilder和String可以相互转换:
String->StringBuilder:可以使用StringBuilder的构造方法
StringBuilder(String str) 构造一个字符串生成器,并初始化为指定的字符串内容。
StringBuilder->String:可以使用StringBuilder中的toString方法
public String toString():将当前StringBuilder对象转换为String对象。
代码运行如下:
package Demo06;
/*
链式编程:方法返回值是一个对象,可以继续调用方法
*/
public class Demo02StringBuilder {
public static void main(String[] args) {
show01();
show02();
show03();
}
public static void show01(){
System.out.println("=====show01=====");
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1:"+bu1);
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2:"+bu2);
}
public static void show02(){
System.out.println("=====show02=======");
StringBuilder bu = new StringBuilder();
bu.append("abc".toUpperCase()).append("ABC").append(10086).append('Y');
System.out.println(bu);
}
public static void show03(){
System.out.println("========show03=========");
//String->StringBuilder
String str = "hello";
System.out.println("str:"+str);
StringBuilder bu = new StringBuilder(str);
bu.append("world");
System.out.println("bu:"+bu);
//StringBuilder->String
String s = bu.toString();
System.out.println("s:"+s);
}
}
运行结构如下:
4 包装类
Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能,如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:
4.1 装箱与拆箱
基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:
- 装箱:从基本类型转换为对应的包装类对象。
- 拆箱:从包装类对象转换为对应的基本类型。
装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
构造方法:
Integer(int value) 构造一个新分配的 Integer 对象,它表示指定的 int 值。
Integer(String s) 构造一个新分配的 Integer 对象,它表示 String 参数所指示的 int 值。
传递的字符串,必须是基本类型的字符串,否则会抛出异常 “100” 正确 “a” 抛异常
静态方法:
static Integer valueOf(int i) 返回一个表示指定的 int 值的 Integer 实例。
static Integer valueOf(String s) 返回保存指定的 String 的值的 Integer 对象。
拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
成员方法:
int intValue() 以 int 类型返回该 Integer 的值。
代码如下:
public class Demo01Integer {
public static void main(String[] args) {
//装箱:把基本类型的数据,包装到包装类中(基本类型的数据->包装类)
//构造方法
Integer in1 = new Integer(1);//方法上有横线,说明方法过时了
System.out.println(in1);//1 重写了toString方法
Integer in2 = new Integer("1");
System.out.println(in2);//1
//静态方法
Integer in3 = Integer.valueOf(1);
System.out.println(in3);
//Integer in4 = Integer.valueOf("a");//NumberFormatException数字格式化异常
Integer in4 = Integer.valueOf("1");
System.out.println(in4);
//拆箱:在包装类中取出基本类型的数据(包装类->基本类型的数据)
int i = in1.intValue();
System.out.println(i);
}
}
4.2 自动装箱与自动拆箱
/*
自动装箱与自动拆箱:基本类型的数据和包装类之间可以自动的相互转换
JDK1.5之后出现的新特性
*/
public class Demo02Ineger {
public static void main(String[] args) {
/*
自动装箱:直接把int类型的整数赋值包装类
Integer in = 1; 就相当于 Integer in = new Integer(1);
*/
Integer in = 1;
/*
自动拆箱:in是包装类,无法直接参与运算,可以自动转换为基本数据类型,在进行计算
in+2;就相当于 in.intVale() + 2 = 3
in = in.intVale() + 2 = 3 又是一个自动装箱
*/
in = in+2;
ArrayList<Integer> list = new ArrayList<>();
/*
ArrayList集合无法直接存储整数,可以存储Integer包装类
*/
list.add(1); //-->自动装箱 list.add(new Integer(1));
int a = list.get(0); //-->自动拆箱 list.get(0).intValue();
}
}
4.3 基本类型与字符串之间的转换
基本类型与字符串类型之间的相互转换
基本类型->字符串(String)
1.基本类型的值+"" 最简单的方法(工作中常用)
2.包装类的静态方法toString(参数),不是Object类的toString() 重载
static String toString(int i) 返回一个表示指定整数的 String 对象。
3.String类的静态方法valueOf(参数)
static String valueOf(int i) 返回 int 参数的字符串表示形式。
字符串(String)->基本类型
使用包装类的静态方法parseXXX(“字符串”);
Integer类: static int parseInt(String s)
Double类: static double parseDouble(String s)
public class Demo03Integer {
public static void main(String[] args) {
//基本类型->字符串(String)
int i1 = 100;
String s1 = i1+"";
System.out.println(s1+200);//100200
String s2 = Integer.toString(100);
System.out.println(s2+200);//100200
String s3 = String.valueOf(100);
System.out.println(s3+200);//100200
//字符串(String)->基本类型
int i = Integer.parseInt(s1);
System.out.println(i-10);
int a = Integer.parseInt("a");//NumberFormatException
System.out.println(a);
}
}