1.内部类
Java中内部类的分类：
- 成员内部类：在另一个类中定义类，作为另一个类的成员
- 静态内部类：static
- 局部内部类：在一个方法内部定义类
- 匿名内部类：
内部类的概念：在一个类的内部再定义一个完整的类
(一个类会生成自己的class文件，一个内部类也会)
特点：
- 编译之后可以生成独立的字节码文件
- 内部类可以直接访问外部类的私有成员，而不破坏封装性
- 可以为外部类提供必要的内部功能组件
1.1 成员内部类
(1)在类的内部定义，与实例变量、实例方法同级别的类
(2)内部类是外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。
- Outer out = new Outer();
- Inner in = out.new Inner();
成员内部类的简单使用：
package com.song.demo01;
//外部类
public class Outer {
//实例变量
private String name="zhangsan";
private int age=20;
//内部类
class Inner{
private String address="Beijing";
private String phone="110";
//方法
public void show(){
//打印外部类的属性
System.out.println(name);
System.out.println(age);
//打印内部类的属性
System.out.println(address);
System.out.println(phone);
}
}
}
package com.song.demo01;
import com.song.demo01.Outer.Inner;
public class TestOuter {
public static void main(String[] args) {
//1.创建外部类对象
Outer outer = new Outer();
//2.创建内部类对象
Inner inner = outer.new Inner();
//Outer.Inner inner = outer.new Inner();
inner.show();
//1与2合并成一步，一步到位
Inner inner1=new Outer().new Inner();
inner1.show();
}
}
(3)当内部类、外部类存在同名属性时，会优先访问内部类的属性。
- 若想访问外部类属性，添加外部类名.this.属性名
- 内部类属性，默认是this.属性名
package com.song.demo01;
//外部类
public class Outer {
//实例变量
private String name = "zhangsan";
private int age = 20;
//内部类
class Inner {
private String address = "Beijing";
private String phone = "110";
//若内部类属性名字与外部类名字完全相同，若想访问外部类属性，需要加上外部类名.this
private String name = "lisi";
//方法
public void show() {
//打印外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//打印内部类的属性,this指代的是内部类本身
System.out.println(this.name);
System.out.println(this.address);
System.out.println(this.phone);
}
}
}
(4)成员内部类不能定义静态成员
package com.song.demo01;
//外部类
public class Outer {
//实例变量
private String name = "zhangsan";
private int age = 20;
//内部类
class Inner {
private String address = "Beijing";
private String phone = "110";
//若内部类属性名字与外部类名字完全相同，若想访问外部类属性，需要加上外部类名.this
private String name = "lisi";
//private static String country = "china";//内部类中不可以包含静态成员
private static final String country = "china";//但是可以包含静态常量
//方法
public void show() {
//打印外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//打印内部类的属性,this指代的是内部类本身
System.out.println(this.name);
System.out.println(this.address);
System.out.println(this.phone);
}
}
}
1.2静态内部类
静态的关键字：static
提示：只有静态内部类可以用static修饰，正常的类是不可以用static修饰的！
- 静态内部类不依赖外部类对象，可以直接创建或通过类名来访问，可以声明静态成员
package com.song.demo02;
//外部类
public class Outer {
private String name = "songsong";
private int age = 18;
//静态内部类,级别和外部类相同；不同于成员内部类与成员变量级别相同
static class Inner {
private String address = "shanghai";
private String phone = "111";
private static int count = 100;
public void show() {
//调用外部类的属性？(考虑放到外面的类如何使用另一个类）
//1.先创建外部类对象
Outer outer = new Outer();
//2.调用外部类对象的属性
System.out.println(outer.name);
System.out.println(outer.age);
//调用静态内部类属性
System.out.println(address);
System.out.println(phone);
//调用静态内部类静态属性(静态属性通过类名访问）
System.out.println(Inner.count);
}
}
}
package com.song.demo02;
public class TestOuter {
public static void main(String[] args) {
//1.直接创建静态内部类对象
//前面的Outer.表示的是一种包含关系，并没有new Outer(),没有括号，没有创建Outer对象
Outer.Inner inner = new Outer.Inner();
//2.调用方法
inner.show();
}
}
3.局部内部类
局部：指在方法中
- 局部内部类定义在外部类方法中，作用范围和创建对象仅限于当前方法。
- 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰final，变成常量。
- 局部内部类的使用范围有限制，只能在当前的方法中使用。
静态方法不能直接访问非静态属性（静态方法–>类的方法；非静态属性–>对象的属性）
package com.song.demo03;
public class Outer {
private String name = "Lisa";
private int age = 20;
public void show() {
//定义局部变量（默认final）
//为什么一定要是final？局部变量执行完会消失，但是inner对象并不会马上消失，Inner类也不会消失，类中方法不能引用消失的变量，故需要加上final，让其变成常量（不消失）
String address = "Shandong";
//final String address = "Shandong";
//定义局部内部类，和局部变量级别相同。(注意不能加任何访问修饰符)
class Inner {
//局部内部类属性
private String phone = "1230";
private String email = "lisa@163.com";
//private static int count=100;//局部内部类不能定义静态成员
private static final int count = 100;//但是可以定义静态常量
public void show2() {
//访问外部类的属性，和局部变量级别相同.针对非静态方法而言，可以直接访问（也相当于省略了Outer.this.
System.out.println(name);
//System.out.println(Outer.this.name);
System.out.println(age);
//访问内部类的属性(相当于省略this.)
System.out.println(phone);
System.out.println(email);
//访问局部变量,jdk1.7要求变量必须是常量final;jdk1.8会默认自动添加final
//常量final意味着后面不能对他做修改
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
package com.song.demo03;
public class TestOuter {
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();//外部类的方法
}
}
4.匿名内部类
- 没有类名的局部内部类（一切特征都与局部内部类相同）。
- 必须继承一个父类(可以是抽象类)或者实现一个接口
- 匿名内部类实际上是定义类、实现类、创建对象的语法合并，只能创建一个该类的对象，适合只使用一次的类。
- 优点：减少代码量
- 缺点：可读性较差
- 匿名内部类实际也是有名字的，只不过不是人为起名，是程序分配的。
package com.song.demo06;
//接口
public interface Usb {
//方法
void service();
}
package com.song.demo06;
//接口的实现类
public class Mouse implements Usb {
@Override
public void service() {
System.out.println("连接电脑成功，鼠标开始工作了");
}
}
package com.song.demo06;
public class TestUsb {
public static void main(String[] args) {
//创建接口类型的变量
/*Usb usb = new Mouse();//用接口创建一个变量--->多态
usb.service();*/
//局部内部类
class Fan implements Usb {
@Override
public void service() {
System.out.println("连接电脑成功，风扇开始工作");
}
}
//使用局部内部类创建对象
Usb usb = new Fan();
usb.service();
//对于只使用了一次的类，用匿名内部类（相当于创建了一个局部内部类）
Usb usb2 = new Usb() {
@Override
public void service() {
System.out.println("连接电脑成功，风扇2开始工作");
}
};
usb2.service();
}
}
2.Object类
- 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
- 任何类，如果没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
- Object类中所定义的方法，是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数，可以接受任何对象
- 作为返回值，可以返回任何对象
2.1 getClass方法
- public final Class<?> getClass() {}
- 返回引用中存储的实际对象类型
- 应用：通常用于判断两个引用中实际存储对象类型是否一致。
package com.song.demo07;
public class Student {
private String name;
private int age;
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;
}
}
package com.song.demo07;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("zhangsan", 18);
Student s2 = new Student("songsong", 20);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一类型");
} else {
System.out.println("s1和s2不属于同一类型");
}
}
}
2.2 hasCode()方法
- public int hasCode() {}
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
- 一般情况下相同对象返回相同哈希码。—可以用于判断是否是同一对象
package com.song.demo07;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("zhangsan", 18);
Student s2 = new Student("songsong", 20);
//getClass()方法
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一类型");
} else {
System.out.println("s1和s2不属于同一类型");
}
//hasCode()方法
//s1，s2是两个不同的对象，在内存的堆中开辟了不同的空间
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());
}
}
2.3 toString()方法
- public String toString() {}
- 返回该对象的字符串表示（表现形式）
- 可以根据程序需求覆盖(重写)该方法，如：展示对象的各个属性值。–父类继承过来的方法满足不了需求，可以重写。
package com.song.demo07;
public class Student {
private String name;
private int age;
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 + "]";
}
}
package com.song.demo07;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("zhangsan", 18);
Student s2 = new Student("songsong", 20);
//getClass()方法
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一类型");
} else {
System.out.println("s1和s2不属于同一类型");
}
//hasCode()方法
//s1，s2是两个不同的对象，在内存的堆中开辟了不同的空间
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());
//toString()方法
System.out.println(s1.toString());//重写前：com.song.demo07.Student@74a14482（@后也是哈希值，与上面相同
System.out.println(s2.toString());//重写前：com.song.demo07.Student@1540e19d
//toString()方法
System.out.println(s1.toString());//重写后：Student--[name=zhangsan, age=18]
System.out.println(s2.toString());//重写后：Student--[name=songsong, age=20]
}
}
2.4 equals()方法
- public boolean equals(Object obj) {}
- 默认实现为（this==obj)，比较两个对象地址是否相同。
- 可以进行覆盖（重写），比较两个对象的内容是否相同。
package com.song.demo07;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("zhangsan", 18);
Student s2 = new Student("songsong", 20);
//getClass()方法
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一类型");
} else {
System.out.println("s1和s2不属于同一类型");
}
//hasCode()方法
//s1，s2是两个不同的对象，在内存的堆中开辟了不同的空间
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());
//toString()方法
System.out.println(s1.toString());
System.out.println(s2.toString());
//equals()方法--重写前，比较对象地址
System.out.println(s1.equals(s2));//重写前，比较地址--false
System.out.println(s1.equals(s3));//true
Student s4 = new Student("lisa", 24);
Student s5 = new Student("lisa", 24);
System.out.println(s4.equals(s5));//fasle--s4和s5分别是堆中的两个对象
}
}
equals()方法覆盖步骤：
- 比较两个引用是否指向同一对象
- 判断obj是否为null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 依次比较各个属性值是否相同
package com.song.demo07;
public class Student {
private String name;
private int age;
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 + "]";
}
@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;
//字符串的比较用equals
if (this.name.equals(s.getName()) && this.age == s.getAge())
return true;
}
return false;
}
}
package com.song.demo07;
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("zhangsan", 18);
Student s2 = new Student("songsong", 20);
//getClass()方法
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一类型");
} else {
System.out.println("s1和s2不属于同一类型");
}
//hasCode()方法
//s1，s2是两个不同的对象，在内存的堆中开辟了不同的空间
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
Student s3 = s1;
System.out.println(s3.hashCode());
//toString()方法
System.out.println(s1.toString());
System.out.println(s2.toString());
//equals()方法--重写前，比较对象地址
System.out.println(s1.equals(s2));//重写前，比较地址--false
System.out.println(s1.equals(s3));//true
Student s4 = new Student("lisa", 24);
Student s5 = new Student("lisa", 24);
System.out.println(s4.equals(s5));//fasle--s4和s5分别是堆中的两个对象
//equals()方法--重写后，比较对象地址，对象值等
System.out.println(s1.equals(s2));//false
System.out.println(s1.equals(s3));//true
System.out.println(s4.equals(s5));//true
}
}
2.5 finalize()方法
- 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
- 垃圾对象：没有有效引用指向此对象时，为垃圾对象
- 垃圾回收：由GC销毁垃圾对象，释放数据存储空间
- 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
- 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。–具体是否执行回收，还是要看程序自己判断，并不一定通知了就回收
package com.song.demo07;
public class Student {
private String name;
private int age;
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 + "]";
}
@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;
//字符串的比较用equals
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+"对象被回收了");
}
}
package com.song.demo08;
import com.song.demo07.Student;
public class TestStudent2 {
public static void main(String[] args) {
// Student s1 = new Student("aaa",12);
// Student s2 = new Student("bbb",14);
// Student s3 = new Student("ccc",16);
// Student s4 = new Student("ddd",18);
// Student s5 = new Student("eee",20);
new Student("aaa", 12);
new Student("bbb", 14);
new Student("ccc", 16);
new Student("ddd", 18);
new Student("eee", 20);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
}
}
3.包装类
-
Java中的八大基本类型：byte、short、int、long、float、double、char、boolean
-
基本数据类型存储在栈中；其他对象存储在堆中，栈中只存储地址。
-
基本数据类型本身没有任何方法，分别为八大数据类型设计了对应的引用类型（对象放在堆中），提供方法使用
-
-
基本数据类型所对应的引用数据类型。
-
Object可统一所有数据，包装类的默认值是null
-
包装类对应–在java的核心包java.lang中
3.1类型转换与装箱、拆箱
装箱：把栈里的对象放到堆中（基本类型转成引用类型）
拆箱：把堆中的对象放到栈中（引用类型转成基本类型）
8种包装类提供不同类型间的转换方式：
- Number父类的6个方法用于拆箱（引用类型转成基本类型）–其是byte、int、short、long、float、double的父类，可以直接用其方法转换引用类型为基本类型
- parseXXX()提供静态方法–可以实现字符串和基本类型间的转换
- valueOf()静态方法
注意：需要保证类型兼容，否则抛出NumberFormatException异常。
package com.song.demo09;
public class Demo01 {
public static void main(String[] args) {
//jdk1.5之前的装箱拆箱方式
//类型转换：装箱操作，基本类型转成引用类型
//基本类型
int num1 = 18;//基本类型，存储在栈中
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
//类型转换：拆箱操作，引用类型转成基本类型
Integer integer3 = new Integer(100);//对象在堆中
int num = integer3.intValue();
//jdk1.5之后的装箱拆箱方式，java提供了自动的装箱拆箱功能--编译器自动调用方法转换
int age = 24;
//自动装箱
Integer integer4 = age;
//自动拆箱
int age2 = integer4;
}
}
- parseXXX()提供静态方法–可以实现字符串和基本类型间的转换
package com.song.demo09;
public class Demo02 {
public static void main(String[] args) {
//基本类型和字符串之间的转换
//1.基本类型转成字符串
int n1 = 15;
//方式1：使用+号
String s1 = n1 + "";
//方式2：使用Integer中的toString()方法
String s2 = Integer.toString(n1);
String s3 = Integer.toString(n1, 16);//重载，转成16进制
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
//2.字符串转成基本类型
String str = "150";
//使用Integer.parseXXX()
int n2 = Integer.parseInt(str);
//boolean字符串转换成基本类型，“true"-->true;非"true"-->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
}
}
3.2整数缓冲区
- Java预先创建了256个常用的整数包装类型对象(范围：-128~127)
- 在实际应用当中，对已创建的对象进行复用。
low=-128; high=127
package com.song.demo09;
public class Demo03 {
public static void main(String[] args) {
//面试题
Integer integer1 = new Integer(100);//引用类型
Integer integer2 = new Integer(100);//引用类型
System.out.println(integer1 == integer2);//false
//引用类型，对象在堆里存放；此处比较的是栈里存的两个对象的地址
//Integer integer3 = 100;//自动装箱，用的是Integer.valueOf()方法
//Integer integer4 = 100;
Integer integer3 = Integer.valueOf(100);
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3 == integer4);//true
//100在-128到127之间的缓冲区，返回的是缓冲区间的对象
Integer integer5 = 200;//自动装箱
Integer integer6 = 200;
System.out.println(integer5 == integer6);//false
//200不在-128到127之间的，不是缓冲区，返回的是实际对象地址
}
}
4.String类
- 字符串是常量，创建之后不可改变
- 字符串字面值存储在字符串池中，可以共享
空间：
- 栈
- 堆
- 方法区
不是修改原来的数据，是重新开辟一个空间。–>不可改变性
package com.song.demo09;
public class Demo04 {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池当中
name = "zhangsan";//“zhangsan”赋值给name---是在字符串池中重新开辟的空间，不是把“hello”修改
String name2 = "zhangsan";
}
}
实现字符串池中的共享
字符串的创建：
- String s=“Hello”;//产生一个对象，字符串池中存储
- String s=new String(“Hello”);//产生两个对象，堆、池各存储一个。（实际真正运行，堆中指向的就是字符串池中的对象）
package com.song.demo09;
public class Demo04 {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池当中
name = "zhangsan";//“zhangsan”赋值给name---是在字符串池中重新开辟的空间，不是把“hello”修改
String name2 = "zhangsan";
//字符串中的另一种创建方式
String str = new String("Java是世界上最好的语言");//会浪费空间
String str2 = new String("Java是世界上最好的语言");
System.out.println(str == str2);//false
System.out.println(str.equals(str2));//true
}
}
提示：字符串的比较用equals
- ==比较的是地址
- equals比较的是数据（String重写的equals方法）
4.1常用方法
- public int length()：返回字符串的长度
- public char charAt(int index)：根据下标获取字符
- public boolean contains(String str)：判断当前字符串中是否包含str
- public char[] toCharArray()：将字符串转成char数组
- public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1
- public int lastIndexOf(String str)：查找str最后一次出现的下标，存在，则返回该下标；不存在，则返回-1
- public String trim()：去掉字符串前后的空格
- public String toUpperCase()：将小写转成大写
- public boolean endsWith(String str)：判断字符串是否以str结尾
- public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
- public String[] split(String str)：根据str做拆分
- equals();比较相等
- compareTo();比较字符串在在字典表中顺序大小
package com.song.demo09;
import java.util.Arrays;
import java.util.Locale;
public class Demo04 {
public static void main(String[] args) {
String name = "hello";//"hello"常量存储在字符串池当中
name = "zhangsan";//“zhangsan”赋值给name---是在字符串池中重新开辟的空间，不是把“hello”修改
String name2 = "zhangsan";
//字符串中的另一种创建方式
String str = new String("Java是世界上最好的语言");//会浪费空间
String str2 = new String("Java是世界上最好的语言");
System.out.println(str == str2);//false
System.out.println(str.equals(str2));//true
System.out.println("------------------字符串方法的使用---------------");
//字符串方法的使用
//1.length();返回字符串的长度
//2.charAt(int index);返回某个位置的字符
//3.contains(String str);判断是否包含某个字符串
String content = "Java是世界上最好的语言,Java真香，Java真好";
System.out.println(content.length());
System.out.println(content.charAt(content.length() - 1));
System.out.println(content.contains("Java"));
System.out.println(content.contains("PHP"));
System.out.println("-----------------------");
//4.toCharArray();返回字符串对应的数组
//5.indexOf();返回字符串首次出现的位置
//6.lastIndexOf();返回字符串最后一次出现的位置
System.out.println(content.toCharArray());
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"));
System.out.println("----------------------");
//7.trim();去掉字符串前后的空格
//8.toUpperCase();把小写变成大写 toLowerCase();把大写转成小写
//9.endsWith(str);判断是否以str结尾 startsWith(str);判断是否以str开头
String content2 = " Hello World ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename = "Hello.java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("Hello"));
System.out.println("----------------------");
//10.replace(old,new);用新的字符或字符串替换旧的
//11.split();对字符串进行拆分
System.out.println(content.replace("Java", "PHP"));
String say = "Java is the best programming language";
String[] arr = say.split(" ");
System.out.println(arr.length);
for (String string : arr) {
System.out.println(string);
}
String say2 = "Java is the best programming language,java is good";
String[] arr2 = say2.split("[ ,]");//[]表示选择，
System.out.println(Arrays.toString(arr2));
String say3 = "Java is the best programming language,java is good";
String[] arr3 = say2.split("[ ,]+");//+表示前面的空格和逗号可以连续出现一个或者多个
System.out.println(Arrays.toString(arr3));
//补充的方法
//equals();比较相等
//compareTo();比较字符串在在字典表中顺序大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2));//忽略大小的的比较
String s3 = "abc";//a--> 97
String s4 = "xyz";//x--> 120
String s5 = "acb";
System.out.println(s3.compareTo(s4));//-23 第一个字符不同，只比较第一个，相差-23，后面不再比较
System.out.println(s3.compareTo(s5));//-1 第一个字符相同，比较第二个，相差-1，后面的不再比较难
String s6 = "abc";
String s7 = "abcxyz";
System.out.println(s6.compareTo(s7));//-3 前面部分完全一致，则比较长度
}
}
4.2实例
package com.song.demo09;
public class Test {
public static void main(String[] args) {
String str = "this is a text";
//1.单词单独提出
String[] arr = str.split(" ");
for (String a : arr) {
System.out.println(a);
}
//2.替换
System.out.println(str.replace("text", "practice"));
//3.插入
System.out.println(str.replace("text", "easy text"));//变通方式！！
//4.首字母大写
for (int i = 0; i < arr.length; i++) {
char first = arr[i].charAt(0);//单词首字母
//把第一个字母转成大写
char upperfirst = Character.toUpperCase(first);
String newstr = upperfirst + arr[i].substring(1);//subs截取字符串
System.out.println(newstr);
}
}
}
4.3 可变字符串
- StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。
- StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全
package com.song.demo09;
/*
StringBuffer和StringBuilder的使用：
和String的区别：1）比String效率高；2）比String节省内存
*/
public class Demo05 {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
//StringBuilder sb =new StringBuilder();//StringBuilder与StringBuffer方法一样
//1.append();追加
sb.append("java is best");
System.out.println(sb.toString());
sb.append(" Java 真香");
System.out.println(sb.toString());
sb.append(" Java 真好");
System.out.println(sb.toString());
//2.insert();添加插入
sb.insert(0, "first");
System.out.println(sb.toString());
//3.replace();替换
sb.replace(0, 5, "hello");
System.out.println(sb.toString());
//4.delete();删除
sb.delete(0, 5);
System.out.println(sb.toString());
//5.清空
sb.delete(0, sb.length());
System.out.println(sb.length());
}
}
效率对比：StringBuilder>StringBuffer>String
package com.song.demo09;
//验证StringBuilder效率高于String
public class demo06 {
public static void main(String[] args) {
/*long start = System.currentTimeMillis();
String str = "";
for (int i = 0; i < 99999; i++) {
str += i;
}
System.out.println(str);
long end = System.currentTimeMillis();
System.out.println("用时：" + (end - start));//38879
*/
long start = System.currentTimeMillis();
StringBuilder str = new StringBuilder();
for (int i = 0; i < 99999; i++) {
str.append(i);
}
System.out.println(str);
long end = System.currentTimeMillis();
System.out.println("用时：" + (end - start));//49
}
}
5.BigDecimal类
package com.song.demo10;
public class TestBigDecimal {
public static void main(String[] args) {
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1 - d2);//0.0999999999
//面试题
double result=(1.4-0.5)/0.9;
System.out.println(result);//0.9999999
//以上问题由double的的近似值存储方式导致，看到的是1可能实际存储的是0.9999999
}
}
很多实际应用中需要精确运算，而double是近似值存储，不符合要求，需要借助一个精确的类——BigDecimal。
- 位置：java.math
- 作用：精确计算浮点数
- 创建方式：BigDecimal b2 = new BigDecimal(“0.9”);
- 方法：
- add() 加
- subtract() 减
- multiply() 乘
- divide() 除
package com.song.demo10;
import javax.swing.plaf.basic.BasicButtonUI;
import javax.xml.bind.SchemaOutputResolver;
import java.math.BigDecimal;
public class demo01 {
public static void main(String[] args) {
BigDecimal b1 = new BigDecimal("1.0");//一定要用字符串的构造方式！！保证精确
BigDecimal b2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = b1.subtract(b2);
System.out.println(r1);
//加法
BigDecimal r2 = b1.add(b2);
System.out.println(r2);
//乘法
BigDecimal r3 = b1.multiply(b2);
System.out.println(r3);
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.9"))
.divide(new BigDecimal("0.5"));
System.out.println(r4);
//特别注意，对于除法，除不尽时，要在指明保留几位小数与保留方法，否则报错
BigDecimal r5 = new BigDecimal("10")
.divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP);//四舍五入法保留两位小数
System.out.println(r5);
}
}
6.日期相关类
6.1Date类
- Date表示特定的瞬间，精确到毫秒。Dtae类中的大部分方法都已经被Calendaer类中的方法所取代。
- 位置：java.util.Date
- 时间单位
- 1秒=1000毫秒
- 1毫秒=1000微秒
- 1微秒=1000纳秒
很多方法已经过时，被Calendar类取代。
package com.song.demo10;
import java.util.Date;
public class demo02 {
public static void main(String[] args) {
//1.创建Date对象
Date date1 = new Date();//今天的时间
System.out.println(date1.toString());
System.out.println(date1.toLocaleString());//过时
Date date2 = new Date(date1.getTime() - 60 * 60 * 24 * 1000);//昨天的时间
System.out.println(date2.toString());
//2.方法 after before
boolean b1 = date1.after(date2);
System.out.println(b1);
boolean b2 = date1.before(date2);
System.out.println(b2);
//3.比较compareTo();用毫秒值比较,大返回1，小返回-1，相等返回0
System.out.println(date1.compareTo(date2));
System.out.println(date1.compareTo(date1));
//4.比较是否相等 equals()方法
boolean b = date1.equals(date2);
System.out.println(b);
}
}
6.2Calendar类
-
Calendar提供了获取和设置各种日历字段的方法
-
构造方法
protected Calander()：由于修饰符是protected，所以无法直接创建该对象。
-
其他方法
package com.song.demo10;
import java.util.Calendar;
public class demo03 {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toString());
System.out.println(calendar.getTimeInMillis());
//2.获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR);
//获取月 0-11，实际显示可以+1，即为正常理解的月份
int month = calendar.get(Calendar.MONTH);
//获取日
int day = calendar.get(Calendar.DATE);
//获取小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);//HOUR_OF_DAY--24小时；HOUR--12小时
//获取分钟
int minute = calendar.get(Calendar.MINUTE);
//获取秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
//3.修改时间
Calendar calendar2 = Calendar.getInstance();
System.out.println(calendar2.getTime().toString());
calendar2.set(Calendar.DAY_OF_MONTH, 5);//修改日
System.out.println(calendar2.getTime().toLocaleString());
calendar2.set(Calendar.MONTH, 2);//修改月
System.out.println(calendar2.getTime().toLocaleString());
calendar2.set(Calendar.HOUR, 8);//修改时
System.out.println(calendar2.getTime().toLocaleString());
//4.基于当前时间修改,增加
Calendar calendar3 = Calendar.getInstance();
System.out.println(calendar3.getTime().toLocaleString());
calendar3.add(Calendar.HOUR, 1);//基于当前时间，加一个小时
System.out.println(calendar3.getTime().toLocaleString());
calendar3.add(Calendar.HOUR, -2);//基于当前时间，减2个小时
System.out.println(calendar3.getTime().toLocaleString());
//5.补充方法
//获取当前时间所在月份的最大值
int max = calendar3.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar3.getActualMinimum(Calendar.DAY_OF_MONTH);
System.out.println(max);
System.out.println(min);
}
}
6.3SimpleDateFormat类
- SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化（日期->文本）、解析（文本->日期）
- 常用的时间模式字母
package com.song.demo10;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class demo04 {
public static void main(String[] args) throws ParseException {
//1.创建SimpleDateFormat对象 y 年 M 月(自定义格式）
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
//2.创建Date时间
Date date = new Date();
//格式化(日期转成字符串）
String str = sdf.format(date);
System.out.println(str);
//解析(字符串转成日期)
Date date2 = sdf.parse("1998年01月08日08:12:12");//必须要完全按照上面自定义的某种格式
System.out.println(date2);
}
}
7.System类
- System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。
package com.song.demo10;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student [name=" + name + ",age=" + age + "]";
}
//finalize是垃圾回收时会执行的方法
@Override
protected void finalize() throws Throwable {
System.out.println("回收了"+name);
}
}
package com.song.demo10;
import java.util.Arrays;
public class demo05 {
public static void main(String[] args) {
//1.arraycopy实现数组复制,
//src:源数组
//srcpos:从哪个位置开始复制
//des:目标数组
//despos:从哪个位置开始放置
//length:复制的长度
int[] src = {20, 18, 16, 14, 12, 88};
int[] des = new int[6];
System.arraycopy(src, 0, des, 0, src.length);
System.out.println(Arrays.toString(des));
System.arraycopy(src, 2, des, 0, src.length - 2);
System.out.println(Arrays.toString(des));
//2.currentTimeMillis()获取当前时间，常用来计时
System.out.println(System.currentTimeMillis());
//3.gc();//垃圾回收，只是建议，并不一定会回收
// Student s1 = new Student("aaa", 18);
// Student s2 = new Student("bbb", 18);
// Student s3 = new Student("ccc", 18);
new Student("aaa", 18);
new Student("bbb", 18);
new Student("ccc", 18);
System.gc();
//此时s1 s2 s3不在被使用了，判定为垃圾对象，被回收
//4.exit();退出jvm
System.exit(0);//状态0表示正常退出
System.out.println("程序退出了吗？");//程序已经退出不会再执行该语句
}
}
总结
-
内部类：
- 在一个类的内部再定义一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
-
Object类
所有类的直接或者间接父类，可以存储任何对象
-
包装类
基本数据类型对应的引用数据类型，可以使Object统一所有数据
-
String类
字符串是常量，创建之后不可修改，字面值保存在字符串池中，可以共享。
-
BigDecimal类
可以精确计算浮点数
-
Date类–特定时间
-
Calendar类–日历
-
SimpleDateFormat–格式化时间
-
System–系统类
System.out.println(“回收了”+name);
}
}
```java
package com.song.demo10;
import java.util.Arrays;
public class demo05 {
public static void main(String[] args) {
//1.arraycopy实现数组复制,
//src:源数组
//srcpos:从哪个位置开始复制
//des:目标数组
//despos:从哪个位置开始放置
//length:复制的长度
int[] src = {20, 18, 16, 14, 12, 88};
int[] des = new int[6];
System.arraycopy(src, 0, des, 0, src.length);
System.out.println(Arrays.toString(des));
System.arraycopy(src, 2, des, 0, src.length - 2);
System.out.println(Arrays.toString(des));
//2.currentTimeMillis()获取当前时间，常用来计时
System.out.println(System.currentTimeMillis());
//3.gc();//垃圾回收，只是建议，并不一定会回收
// Student s1 = new Student("aaa", 18);
// Student s2 = new Student("bbb", 18);
// Student s3 = new Student("ccc", 18);
new Student("aaa", 18);
new Student("bbb", 18);
new Student("ccc", 18);
System.gc();
//此时s1 s2 s3不在被使用了，判定为垃圾对象，被回收
//4.exit();退出jvm
System.exit(0);//状态0表示正常退出
System.out.println("程序退出了吗？");//程序已经退出不会再执行该语句
}
}
总结
-
内部类：
- 在一个类的内部再定义一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
-
Object类
所有类的直接或者间接父类，可以存储任何对象
-
包装类
基本数据类型对应的引用数据类型，可以使Object统一所有数据
-
String类
字符串是常量，创建之后不可修改，字面值保存在字符串池中，可以共享。
-
BigDecimal类
可以精确计算浮点数
-
Date类–特定时间
-
Calendar类–日历
-
SimpleDateFormat–格式化时间
-
System–系统类
851
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
