Java进阶_常用类
常用类
Object类
介绍object
-
JDK类库的根类: Object
-
这个老祖宗类中的方法我们需要先研究一下，因为这些方法都是所有子类通用的。任何一个类默认继承object。就算没有直接继承，最终也会间接继承。
-
object类当中有哪些常用的方法?
- 我们去哪里找这些方法呢?
- 第一种方法:去源代码当中。(但是这种方式比较麻烦，源代码也比较难)
- 第二种方法:去查阅java的类库的帮助文档。
- 我们去哪里找这些方法呢?
-
什么是API ?
- 应用程序编程接口。（Application Program Interface）
- 整个JDK的类库就是一个javaSE的API。
- 每一个API都会配置一套API帮助文档。
- SUN公司提前写好的这套类库就是API。(一般每一份API都对应一份API帮助文档。)
-
超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
-
任何类，如没有书写extends显示继承某个类，都默认直接继承0bject类,否则为间接继承。
-
Object类中所定义的方法，是所有对象都具备的方法。
-
0bject类型可以存储任何对象。
- 作为参数，可接受任何对象。
- 作为返回值，可返回任何对象。
Object常见的方法
getClass()方法
- public final Class<?> getClass() {}
- 返回引用中存储的实际对象类型。
- 应用:通常用于判断两个引用中实际存储对象类型是否一致。
package com.mike.test;
public class Student {
private String name;
private int age;
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 static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
//判断S1和S2是不是同一个类型
Class s1Class = s1.getClass();
Class s2Class = s2.getClass();
System.out.println(s1.equals(s2));//equals是用来比较内容的
if (s1Class==s2Class){
System.out.println("s1和s2属于同一个类型");
}else System.out.println("s1和s2不属于同一个类型");
}
}
//输出结果：
//false
//s1和s2属于同一个类型
hashCode()方法
- public int hashCode() {}
- 返回该对象的哈希码值。
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
- 一般情况下相同对象返回相同哈希码。
package com.mike.test;
public class Student {
private String name;
private int age;
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 static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
Student s3 =s1;
//判断S1和S2是不是同一个类型
Class s1Class = s1.getClass();
Class s2Class = s2.getClass();
System.out.println(s1.equals(s2));//equals是用来比较地址的
if (s1Class==s2Class){
System.out.println("s1和s2属于同一个类型");
}else System.out.println("s1和s2不属于同一个类型");
//hashCode()方法
System.out.println("s1的哈希码值："+s1.hashCode());
System.out.println("s2的哈希码值："+s2.hashCode());
System.out.println("s3的哈希码值："+s3.hashCode());
System.out.println(s3.getName());
System.out.println(s3.getAge());
}
}
/*输出结果：
false
s1和s2属于同一个类型
s1的哈希码值：460141958
s2的哈希码值：1163157884
s3的哈希码值：460141958
小明
21
*/
toString()方法
- public String toString() {}
- 返回该对象的字符串表示 (表现形式)
- 可以根据程序需求覆盖该方法，如:展示对象各个属性值。
没有重写toString()方法
package com.mike.test;
public class Student {
private String name;
private int age;
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 static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
Student s3 =s1;
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println(s3.toString());
}
}
/*输出结果：
com.mike.test.Student@1b6d3586
com.mike.test.Student@4554617c
com.mike.test.Student@1b6d3586
*/
重写toString()方法
package com.mike.test;
public class Student {
private String name;
private int age;
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;
}
//重写toString()方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
Student s3 =s1;
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println(s3.toString());
}
}
/*输出结果
Student{name='小明', age=21}
Student{name='小红', age=20}
Student{name='小明', age=21}
*/
equals()方法
- public boolean equals (0bject obj) {}
- 默认实现为(this==obj)，比较两个对象地址是否相同。
- 可进行覆盖，比较两个对象的内容是否相同。
package com.mike.test;
public class Student {
private String name;
private int age;
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
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
Student s3 =s1;
System.out.println(s1.equals(s2));
System.out.println(s2.equals(s3));
System.out.println(s3.equals(s1));
}
}
/*输出结果（比较的是地址）
false
false
true
*/
- equals()方法覆盖步骤
- 比较两个引用是否指向同一个对象。
- 判断obj是否为null。
- 判断两个引用指向的实际对象类型是否一致。
- 强制类型转换。
- 依次比较各个属性值是否相同。
如果要比较对象的内容，就要重写equals()方法
package com.mike.test;
public class Student {
private String name;
private int age;
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
public boolean equals(Object obj) {
//1.判断两个对象是否是同一个引用
if (this==obj){
return true;
}
//2.判断obj是否为null
if (obj==null){
return false;
}
//3.判断是否是同一个类型
/* if (this.getClass()==obj.getClass()){
}
换下面一种写法更好
*/
//instanceof 判断对象是否是某种类型
if (obj instanceof Student){
//4.强制转换
Student s = (Student) obj;
//5.比较属性
if (this.name.equals(s.getName())&&this.age==s.getAge()){
return true;
}
}
return false;
}
public static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
Student s3 =s1;
Student s4 = new Student("小红",20);
System.out.println(s1.equals(s3));
System.out.println(s2.equals(s4));
}
}
/*输出结果（比较的是内容）
true
true
*/
finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象,进入回收队列。
- 垃圾对象:没有有效引用指向此对象时，为垃圾对象。
- 垃圾回收: 由GC销毁垃圾对象，释放数据存储空间。
- 自动回收机制: JVM的内存耗尽，一次性回收所有垃圾对象。
- 手动回收机制:使用System.gc();通知 JVM执行垃圾回收。
重写finalize()方法
package com.mike.test;
public class Student {
private String name;
private int age;
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
public boolean equals(Object obj) {
//1.判断两个对象是否是同一个引用
if (this==obj){
return true;
}
//2.判断obj是否为null
if (obj==null){
return false;
}
//3.判断是否是同一个类型
/* if (this.getClass()==obj.getClass()){
}
换下面一种写法更好
*/
//instanceof 判断对象是否是某种类型
if (obj instanceof Student){
//4.强制转换
Student s = (Student) obj;
//5.比较属性
if (this.name.equals(s.getName())&&this.age==s.getAge()){
return true;
}
}
return false;
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了");
}
public static void main(String[] args) {
Student s1 = new Student("小明",21);
Student s2 = new Student("小红",20);
Student s3 = new Student("小王",22);
Student s4 = new Student("小刘",18);
Student s5 = new Student("小刚",20);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
}
}
/*输出结果
回收垃圾
*/
//发现s1~s5没有垃圾被回收
//说明没有垃圾回收
当我们new对象，然后不给对象引用变量时（也就是匿名内部类）
package com.mike.test;
public class Student {
private String name;
private int age;
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
public boolean equals(Object obj) {
//1.判断两个对象是否是同一个引用
if (this==obj){
return true;
}
//2.判断obj是否为null
if (obj==null){
return false;
}
//3.判断是否是同一个类型
/* if (this.getClass()==obj.getClass()){
}
换下面一种写法更好
*/
//instanceof 判断对象是否是某种类型
if (obj instanceof Student){
//4.强制转换
Student s = (Student) obj;
//5.比较属性
if (this.name.equals(s.getName())&&this.age==s.getAge()){
return true;
}
}
return false;
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name+"对象被回收了");
}
public static void main(String[] args) {
new Student("小明",21);
new Student("小红",20);
new Student("小王",22);
new Student("小刘",18);
new Student("小刚",20);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
}
}
/*输出结果
回收垃圾
小刚对象被回收了
小刘对象被回收了
小王对象被回收了
小红对象被回收了
小明对象被回收了
*/
Integer类（包装类）
什么是包装类
- 基本数据类型所对应的引用数据类型。
- 0bject可统一所有数据，包装类的默认值是null。
包装类对应
类型转换与装箱、拆箱
- 8种包装类提供不同类型间的转换方式:
- Number父类中提供的6个共性方法。
- parseXXX()静态方法。
基本类型和字符串之间转换
package com.mike.test;
public class Test {
public static void main(String[] args) {
//基本类型和字符串之间转换
//1基本类型转成字符串
int n1 = 255;
//1.1使用+号
String s1 = n1+"";
//1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1);
//这里的radix表示进制的意思，16表示转换成16进制的数
String s3 = Integer.toString(n1,16);
//toBinaryString()转换成二进制的意思
//toHexString()转换成十六进制的意思
//toOctalString()转换成八进制的意思
//总的来说toString(int i,int radix)就可以转换想要的进制了
System.out.println("基本类型转成字符串");
System.out.println(s1);
System.out.println(s2);
System.out.println(n1+"转换成16进制:"+s3);
System.out.println("========================");
//2字符串转成基本类型
String s4 = "150";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(s4);
System.out.println("字符串转成基本类型");
System.out.println(n2);
System.out.println("========================");
//boolean字符串形式转成基本类型，"true"--->true 非"true"---->false
String s5 = "true";
boolean b1= Boolean.parseBoolean(s5);
String s6 = "tree";
String s7 = "false";
boolean b2= Boolean.parseBoolean(s6);
boolean b3= Boolean.parseBoolean(s7);
System.out.println("boolean字符串形式转成基本类型");
System.out.println(b1);
System.out.println(b2);
System.out.println(b3);
}
}
/*输出结果
基本类型转成字符串
255
255
255转换成16进制:ff
========================
字符串转成基本类型
150
========================
boolean字符串形式转成基本类型
true
false
false
*/
装箱和拆箱
package com.mike.test;
public class Test {
public static void main(String[] args) {
//类型转换:装箱,基本类型转成引用类型的过程
//基本类型
int num1 = 18;
//1.使用Integer类创建对象,用构造方法来转换
Integer integer1 = new Integer(num1);
//2.使用Integer类的valueOf()方法来转换
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer1);
System.out.println(integer2);
System.out.println("===========================");
//类型转型:拆箱,引用类型转成基本类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
System.out.println("===========================");
//JDK1.5之后,提供自动装箱和拆箱
int age1 = 30;
//自动装箱
Integer integer4 = age1;
System.out.println("自动装箱");
System.out.println(integer4);
System.out.println("===========================");
//自动拆箱
int age2=integer4;
System.out.println("自动拆箱");
System.out.println(age2);
}
}
/*输出结果
装箱
18
18
===========================
拆箱
100
===========================
自动装箱
30
===========================
自动拆箱
30
*/
Integer缓冲区
整数缓冲区
整数缓冲区：-128~127=======>256个常用的整数包装类型对象
- Java预先创建了256个常用的整数包装类型对象。
- 在实际应用当中，对已创建的对象进行复用。
注意：如果Integer的数值的地址不在-128~127之间，则new Integer(i)
面试题
package com.mike.test;
public class Test {
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1==integer2);//比较的是地址
System.out.println(integer1.equals(integer2));//比较数值
System.out.println("================================");
//============================================================================
//这里的自动装箱调用的是Integer.valueOf
//即：Integer integer3 = Integer.valueOf(100);
//Integer integer4 = Integer.valueOf(100);
Integer integer3 = 100;//jdk1.5之后，支持自动装箱，自动转换为int类型
Integer integer4 = 100;
System.out.println(integer3==integer4);//比较的是Integer缓冲区100的地址，所以为true
System.out.println(integer3.equals(integer4));//比较数值
System.out.println("================================");
//===========================================================================
//这里的自动装箱调用的是Integer.valueOf
//即：Integer integer5 = Integer.valueOf(200);
//Integer integer6 = Integer.valueOf(200);
Integer integer5 = 200;//由于200不在-128~127之间，则开辟一个新的地址存放
Integer integer6 = 200;
System.out.println(integer5==integer6);//这里就是比较新的两个不一样的地址，所以为false
System.out.println(integer5.equals(integer6));//比较数值
}
}
/*输出结果
false
true
================================
true
true
================================
false
true
*/
String类
String
科普小知识：equals在Object类中比的是地址，但是Sun公司在String要中重写了equals，重写为比较值，基本Sun公司在每个类中都重写了equals方法。所以有时候我们看到equals比较的是地址的时候，说明这是自己创建的一个类，然后这个类并没有重写equals方法，自己创建的类默认继承Object类，Object里的equals是没有重写的哦。
- 字符串是常量，创建之后不可改变。
- 字符串字面值存储在字符串池中（也就是方法区中），可以共享。
- String s = "Hello" ;产生一个对象，字符串池中存储。
- String s = new String(“Hello”); //产生两个对象，堆、池各存储一个。
package com.mike.test;
public class Test {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池中。
name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
String name2 = "zhangsan";
}
}
给字符串重新赋值的状态
给不同的string变量赋相同值时（对比上面的图）
- hello值变成垃圾被回收，开辟新的空间，name和name2指向同一个方法区的地址，并不是修改原来的空间里的值
字符串的另一种创建方式，new String();
package com.mike.test;
public class Test {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池中。
name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
String name2 = "zhangsan";
//演示字符串的另一种创建方式，new String();
String str = new String("Java");
}
}
//注意：虽然说有堆和池各有一个字符串，但是程序运行的时候，堆里的字符串还是指向池里的字符串
当我们又new了一个新的相同的string值时
package com.mike.test;
public class Test {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池中。
name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
String name2 = "zhangsan";
//演示字符串的另一种创建方式，new String();
String str = new String("Java");
String str2=new String("java");
System. out . println( str==str2);
}
}
/*输出结果
false
*/
//从下面的图中我们可以看到，虽然都是指向了池中同一个java，但是new的时候，在堆中开辟了新的空间
//所以栈中的地址是先从堆指向池，new String();是比较堆中的地址，直接赋值不new对象，是比较池的地址
//用equals比较String的变量
package com.mike.test;
public class Test {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池中。
name = "zhangsan";//"张三"赋值给name变量,给字符串赋值时，并没有修改数据。而是重新开辟一个空间
String name2 = "zhangsan";
//演示字符串的另一种创建方式，new String();
String str = new String("java");
String str2=new String("java");
System.out.println(name==name2);//比较池地址
System.out.println(name.equals(name2));//比较池内容
System.out.println(str==str2);//比较堆地址
System.out.println(str.equals(str2));//比较堆内容
}
}
/*输出结果
true
true
false
true
*/
看图理解
String常用方法
- 1、public int length() :返回字符串的长度。
- 2、public char charAt(int index) :根据下标获取字符。
- 3、public boolean contains (String str) :判断当前字符串中是否包含str。
- 4、public char[] toCharArray() :将字符串转换成数组。
- 5、public int indexOf (String str) :查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
- 6、public int lastIndexOf (String str) :查找字符串在当前字符串中最后一次出现的下标索引。
- 7、public String trim() :去掉字符串前后的空格。
- 8、public String toUpperCase () :将小写转成大写。
- 9、public String toLowerCase () :将大写转成小写。
- 10、public boolean endWith(String str) :判断字符串是否以str结尾。(区分大小写)
- 11、public boolean startWith(String str) :判断字符串是否以str开头。(区分大小写)
- 12、public String replace (char oldChar, char newChar): 将旧字符串替换成新字符串
- 13、public String[] split(String str) :根据str做拆分。
1、字符串的使用length()，charAt(int index)，contains (String str)
package com.mike.test;
public class Test {
public static void main(String[] args) {
//字符串方法的使用
//1、public int length():返回字符串的长度。
//2、public char charAt(int index):根据下标获取字符。
//3、public boolean contains (String str):判断当前字符串中是否包含str。
String content="java是世界上最好的编程语言";
System.out.println(content.length());//如果字符串有空格，也算一个字符
System.out.println(content.charAt(3));
System.out.println(content.contains("语言"));
System.out.println(content.contains("PHP"));
}
}
/*输出结果
15
a
true
false
*/
2、字符串的使用toCharArray()，indexOf(String str)，lastIndexOf(String str)
package com.mike.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
String content="java是世界上最好的java编程语言，java真香";
//4、public char[] toCharArray():将字符串转换成数组。
//5、public int indexOf(String str):查找str首次出现的下标，存在，则返回该下标;不存在，则返回-1。
//6、public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引。
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java"));
System.out.println(content.indexOf("java",4));
System.out.println(content.lastIndexOf("java"));
}
}
/*输出结果
[j, a, v, a, 是, 世, 界, 上, 最, 好, 的, j, a, v, a, 编, 程, 语, 言, ，, j, a, v, a, 真, 香]
0
11
20
*/
3、字符串的使用trim()，toUpperCase()，endWith(String str)
package com.mike.test;
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
String content = " Hello！Word！ ";
//7、public String trim():去掉字符串前后的空格。
//8、public String toUpperCase():将小写转成大写。
//9、public boolean endWith(String str):判断字符串是否以str结尾。
System.out.println(content.trim());
System.out.println(content.toUpperCase());
System.out.println(content.toLowerCase());
String str = "Hellow.java";
System.out.println(str.endsWith("va"));
System.out.println(str.startsWith("hello"));
}
}
/*输出结果
Hello！Word！
HELLO！WORD！ (前后还是存在空格的，没有改变字符串的值，空格也是字符串)
hello！word！
true
false
*/
4、字符串的使用replace(char oldChar,char newChar)，split(String str)
package com.mike.test;
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
String content = "Hello！Word！";
//10、public String replace(char oldChar,char newChar):将旧字符串替换成新字符串
//11、public String[] split(String str):根据str做拆分。
System.out.println(content.replace("Word", "Earth"));
System.out.println(content.replace('H', 'h'));
String say = "java is the best programing language,java xiang";
// String[] s = say.split(" ");
String[] s = say.split("[ ,]");//需要空格和逗号作为分格符号时，可以用中括号，里面空格+逗号
// String[] s = say.split("[ ,]+");//如果一个字符串连续出现多个空格，可以在后面加个+
System.out.println(s.length);
for (String s1 : s) {
System.out.println(s1);
}
}
}
/*输出结果
Hello！Earth！
hello！Word！
8
java
is
the
best
programing
language
java
xiang
*/
5、补充String类的两个方法：equals()和compareTo();
- equals()是用来比较数据是否相同
- compareTo()是用来比较大小/长度（就是比较字典表（编码表）里的顺序（位置））
package com.mike.test;
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));//考虑大小写的比较
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小写的比较
//==========================================================================
String s3 = "abc";//a=97,b=98,c=99
String s4 = "xyz";//x=120,y=121,z=122
String s5 = "ayzawe";//s5和s3第一个字母相同，直接从第二个字母开始比较
System.out.println(s3.compareTo(s4));//97-120= -23
System.out.println(s3.compareTo(s5));//98-121= -23
//==========================================================================
String s6 = "abc";
String s7 = "abcdef";
System.out.println(s6.compareTo(s7));//观察s6和s7,这时候不比大小，比他们的长度，0-3=-3
}
}
/*输出结果
false
true
-23
-23
-3
*/
6、可变字符串
- StringBuffer: 可变长字符串，JDK1. 0提供，运行效率慢、线程安全。
- StringBuilder:可变长字符串，JDK5. 0提供，运行效率快、线程不安全。
- StringBuffer和StringBuilder比String效率高，更节省内存
package com.mike.test;
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
// StringBuffer string = new StringBuffer();//推荐使用StringBuffer，线程安全性
StringBuilder string = new StringBuilder();//想用StringBuilder直接替换就行了，用法一样
//1、append();追加
string.append("Java世界第一");
System.out.println(string.toString());
string.append("Java真香");
System.out.println(string.toString());
string.append("Java真不错");
System.out.println(string.toString());
//2、insert();添加,插入
string.insert(0,"我在最前面");
System.out.println(string.toString());
//3、replace();替换
string.replace(13,19,"Java好就业");//含头不含尾
System.out.println(string.toString());
//4、delete();删除
string.delete(0,5);
System.out.println(string.toString());
//清空
string.delete(0,string.length());
System.out.println(string.length());
}
}
/*输出结果
Java世界第一
Java世界第一Java真香
Java世界第一Java真香Java真不错
我在最前面Java世界第一Java真香Java真不错
我在最前面Java世界第一Java好就业Java真不错
Java世界第一Java好就业Java真不错
0
*/
测试String和StringBuilder的效率
1、测试String
package com.mike.test;
import com.sun.xml.internal.bind.v2.runtime.reflect.Accessor;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
//开始时间
long start = System.currentTimeMillis();
String string = "";//空字符串
for (int i = 0; i < 9999; i++) {
string+=i;
}
// System.out.println(string);
//结束时间
long end = System.currentTimeMillis();
System.out.println("String用时："+(end-start));
}
}
/*输出结果
String用时：399
*/
2、测试StringBuilder
package com.mike.test;
public class Test {
public static void main(String[] args) {
//开始时间
long start = System.currentTimeMillis();
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < 9999; i++) {
stringBuilder.append(i);
}
// System.out.println(stringBuilder.toString());
//结束时间
long end = System.currentTimeMillis();
System.out.println("stringBuilder用时："+(end-start));
}
}
/*输出结果
StringBuilder用时：2
*/
综上所知：在运行效率中：（快）StringBuilder > StringBuffer > String（慢）
BigDecimal类
引入问题
思考:以下程序输出结果是多少?
上机运行
package com.mike.test;
public class Test {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);
double result = (1.4-0.5)/0.9;
System.out.println(result);
}
}
/*输出结果
0.09999999999999998
0.9999999999999999
*/
因为double类型存储的是近似值，在一系列复杂的运算情况后，会产生一定的误差
显然，这种情况在某些领域是绝对不允许出现的，比如银行账户的余额
所以，就出现了一种专门解决这类问题的类——BigDecimal类
BigDecimal类
位置: java.smath包中。
作用:精确计算浮点数。
创建方式: BigDecimal bd = new BigDecimal( “1.0”);
方法：
- 加法：add();
- 减法：subtract();
- 乘法：multiply();
- 除法：divide();
package com.mike.test;
import java.math.BigDecimal;
public class Test {
public static void main(String[] args) {
//BigDecimal,大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//subtract();减法
System.out.println(bd1.subtract(bd2));
//加法
System.out.println(bd1.add(bd2));
//乘法
System.out.println(bd1.multiply(bd2));
//除法
System.out.println(new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9")));
BigDecimal b1 = new BigDecimal("10");
BigDecimal b2 = new BigDecimal("3");
//对于除不尽的结果，必须保留两位小数，否则会报错
BigDecimal result2 = b1.divide(b2, 2, BigDecimal.ROUND_HALF_UP);//保留两位小数，BigDecimal.ROUND_HALF_UP采用四舍五入
System.out.println(result2);
}
}
/*输出结果
0.1
1.9
0.90
1
3.33
*/
Date类
介绍Date
-
Date表示特定的瞬间，精确到毫秒。Date类中 的大部分方法都已经被Calendar类中的方法所取代。
-
时间单位
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒
1、创建时间
package com.mike.test;
import java.util.Date;
public class Test {
public static void main(String[] args) {
//1、创建Date对象
//今天的时间（此时此刻）
Date date1 = new Date();
System.out.println(date1.toString());
System.out.println("今天的时间（此时此刻）");
System.out.println(date1.toLocaleString());//虽然过时了，但是还是可以使用的
//昨天的时间(今天的时间减去一天的毫秒数就是昨天此时此刻的时间)
System.out.println("昨天此时此刻的时间");
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
System.out.println(date2.toLocaleString());
}
}
/*输出结果(时间是变化的，每次运行都不一样)
Sun Mar 06 16:15:57 CST 2022
今天的时间（此时此刻）
2022-3-6 16:15:57
昨天此时此刻的时间
2022-3-5 16:15:57
*/
2、Date类的方法
- after
- before
package com.mike.test;
import java.util.Date;
public class Test {
public static void main(String[] args) {
//1、创建Date对象
//今天的时间（此时此刻）
Date date1 = new Date();
Date date2 = new Date(date1.getTime()-(60*60*24*1000));
//2、方法
boolean b1 = date1.after(date2);
System.out.println(b1);
boolean b2 = date1.before(date2);
System.out.println(b2);
//比较compareTo();
System.out.println(date1.compareTo(date2));
System.out.println(date2.compareTo(date1));
System.out.println(date2.compareTo(date2));
//比较是否相等equals()
System.out.println(date1.equals(date2));
}
}
/*输出结果
true
false
1
-1
0
false
*/
Calendar类
介绍Calendar类
-
Calendar提供了获取或设置各种日历字段的方法。
-
构造方法
- protected Calendar() :由于修饰符是protected， 所以无法直接创建该对象。
-
其他方法
获取年月日，时分秒
package com.mike.test;
import java.util.Calendar;
import java.util.Date;
public class Test {
public static void main(String[] args) {
//1、创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis());
//2、获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR);
System.out.println(year);
//获取月
int month = calendar.get(Calendar.MONTH);
System.out.println(month+1);
//获取日
int day = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(day);
//获取时
int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR 12小时，HOUR_OF_DAY 24小时
System.out.println(hour);
//获取分
int minute = calendar.get(Calendar.MINUTE);
System.out.println(minute);
//获取秒
int second = calendar.get(Calendar.SECOND);
System.out.println(second);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);
}
}
/*输出结果
2022-3-6 22:56:53
1646578613678
2022
3
6
22
56
53
2022年3月6日22:56:53
*/
修改时间
package com.mike.test;
import com.sun.org.apache.bcel.internal.util.Class2HTML;
import java.util.Calendar;
import java.util.Date;
public class Test {
public static void main(String[] args) {
//3、修改时间
//下面这个是把时间修改为昨天的此时此刻
Calendar calendar2 =Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,5);//写这行代码的时候是2022.3.6，这里的5表示2022.3.5
System.out.println(calendar2.getTime().toLocaleString());
//4、add方法修改时间
calendar2.add(Calendar.HOUR,1);//增加一小时
System.out.println(calendar2.getTime().toLocaleString());
calendar2.add(Calendar.HOUR,-1);//减少一小时
System.out.println(calendar2.getTime().toLocaleString());
//5、补充方法
int maxDay = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int minDay = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(maxDay);
System.out.println(minDay);
}
}
/*输出结果
2022-3-5 22:56:53
2022-3-5 23:56:53
2022-3-5 22:56:53
31
1
*/
SimpleDateFormat类
介绍SimpleDateFormat
- Simpl eDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
- 进行格式化(日期—>文本)、解析(文本—>日期)。
- 常用的时间模式字母
Date日期转换为SimpleDateFormat
package com.mike.test;
import com.sun.org.apache.bcel.internal.util.Class2HTML;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Test {
public static void main(String[] args) throws ParseException {
//1、创建SimpleDateFormat对象
// y 年 M 月 d 日 H 时 m 分 s 秒
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
// SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH-mm-ss");
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
//2、创建Date
Date date = new Date();
//3、格式化Date（把日期转换成字符串）
String str = sdf.format(date);
String str2 = sdf2.format(date);
System.out.println(str);
System.out.println(str2);
//4、解析（把字符串转换成日期）
Date date2 = sdf2.parse("1999-09-09");//必须按照sdf2的样子写，还要抛出异常
System.out.println(date2.toString());
System.out.println(date2.toLocaleString());
}
}
/*输出结果
2022年03月06日 23:17:17
2022-03-06
Thu Sep 09 00:00:00 CST 1999
1999-9-9 0:00:00
*/
System类
1、介绍System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
2、练习代码
package com.mike.test;
import java.util.Arrays;
public class Test {
public static void main(String[] args){
//arrayCopy();数组的复制
//src:源数组
//srcPos:从哪个位置开始复制0~
//dest: 目标数组
//destPos:目标数组的位置
//length: 复制的长度
int[] arr = {20,18,15,8,35,26,45,90};//原数组
int[] dest = new int[8];
System.arraycopy(arr,0,dest,0,arr.length);
for (int i = 0; i < dest.length; i++) {
System.out.print(dest[i]+"\t");
}
System.out.println("复制完成");
//Arrays. copy0f(original, newLength)就是用System.arraycopy()实现的
//System.currentTimeMillis()方法可以用来计时，获取当前时间的毫秒数
System.out.println(System.currentTimeMillis());
long start = System.currentTimeMillis();
for (int i = 0; i < 99999; i++) {
for (int j = 0; j < 9999; j++) {
int result=i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("这个过程执行了"+(end-start)+"毫秒");
//System.gc();告诉垃圾回收器回收垃圾
}
}
/*输出结果
20 18 15 8 35 26 45 90 复制完成
1646581538650
这个过程执行了8毫秒
*/
