内部类
- 成员内部类
- 静态内部类
- 局部内部类
- 匿名内部类
什么是内部类
-
在一类的内部再定义一个完整的类
-
特点
-
编译之后可生成独立的字节码文件
-
内部类可直接访问外部类的私有成员,而不破坏封装
//身体 public class body { private String name = "空白"; //头部 class head{ public void show(){ System.out.println(name); } } public static void main(String[] args) { body body = new body(); body.head head = body.new head(); //通过外部类来实例内部类 head.show(); } }
- 可为外部类提供必要的内部功能组件
-
成员内部类
- 在类的内部定义,与实例变量、实例方法同级别的类
- 外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
- Outer outer = new Outer();
- Outer.Inner inner = outer.new Inner();
Outer类:
package com.oop.demo12;
//外部类
public class Outer {
//实例变量
private String name = "kongbai";
private int age = 20;
/*
内部类
因为Application不在同一个包内,内部类默认只能在同一个包下访问,
所以我将内部类修饰符改为public
*/
public class Inner{
private String address = "北京";
private String phone = "120";
//方法
public void show(){
//打印外部类
System.out.println(name);
System.out.println(age);
//打印内部类
System.out.println(address);
System.out.println(phone);
}
}
}
Application对象:
import com.oop.demo12.Outer;
//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
// //1.创建外部类对象
// Outer outer = new Outer();
// //2.创建内部类对象
// Outer.Inner inner = outer.new Inner();
// inner.show();
//用一段代码也可以完成
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}
-
当外部类、内部类存在重名属性时,会优先访问内部类属性
比如还是上面的代码,在内部类也有一个name属性,定义为“张三”;那么程序执行就会显示张三;那这时如何才能访问外部类的name呢?
//外部类
public class Outer {
//实例变量
private String name = "kongbai";
private int age = 20;
class Inner{
private String address = "北京";
private String phone = "120";
private String name = "张三";
//方法
public void show(){
//打印外部类
//内部类属性和外部类属性名字相同时加<外部类>.this
System.out.println(Outer.this.name);
System.out.println(age);
//打印内部类
System.out.println(address);
System.out.println(phone);
}
}
}
-
成员内部类不能定义静态成员,但是可以定义静态常量
class Inner{ private static final String country = "中国"; }
静态内部类
- 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员(只有静态内部类可以使用static修饰,普通类不行)
//外部类
public class Outer {
private String name = "空白";
private int age = 18;
//静态内部类,它的级别和外部类相同
static class Inner{
private String address = "安徽";
private String phone = "110";
//静态成员
private static int country = 999;
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.country);
}
}
}
测试对象
public class TestOuter {
public static void main(String[] args) {
//直接创建静态内部类对象
Outer.Inner inner = new Outer.Inner();
//调用方法
inner.show();
}
}
- 只能直接访问外部类的静态成员(实例成员需实例化外部类对象)
- Outer.Inner inner = new Outer.Inner();
- inner.show();
局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法(静态方法里不能直接访问非静态属性)
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final
- 限制类的使用范围
- 局部内部类不能定义静态属性,但可以定义静态常量
//外部类
public class Outer {
private String name = "kongbai";
private int age = 35;
public void show(){
//定义局部变量
String address = "宿州";
//局部内部类,不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String phone = "117790";
private String email = "117790@163.com";
public void show2() {
//访问外部类的属性
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//访问内部类的属性
System.out.println(this.phone);
System.out.println(this.email);
//访问局部变量,在jdk1.7要求变量必须是常量final;jdk1.8自动添加final
System.out.println(address);
}
}
//创建局部内部类对象
Inner inner = new Inner();
inner.show2();
}
}
public class TestOuter {
public static void main(String[] args) {
//直接运行不会有任何结果,因为Inner只做了声明,需要在Outer里创建局部内部类对象
Outer outer = new Outer();
outer.show();
}
}
匿名内部类
- 没有类名的局部内部类(一切特征都与局部内部类相同)
- 必须继承一个父类或者实现一个接口
Usb接口:
//接口
public interface Usb {
//服务方法
void service();
}
测试对象:
public class TestUsb {
public static void main(String[] args) {
//创建接口类型的变量
// Usb usb = new Mouse();
// usb.service();
//局部内部类
// class keyboard implements Usb{
// @Override
// public void service() {
// System.out.println("连接电脑成功,键盘开始工作");
// }
// }
// //使用局部内部类创建对象
// Usb usb = new keyboard();
// usb.service();
//使用匿名内部类优化(相当于创建了一个局部内部类)
Usb usb = new Usb() {
@Override
public void service() {
System.out.println("连接电脑成功,键盘开始工作");
}
};
usb.service();
}
}
- 定义类、实现类、创建对象的语法合并,只能创建一个该类的对象
- 优点:减少代码量
- 缺点:可读性较差
Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层
- 任何类,如没有写extends显示继承某个类,都默认直接继承Object类,否则为间接继承
- Object类中所定义的方法,是所有对象都具备的方法
- Object类型可以存储任何对象
- 作为参数,可接受任何对象
- 作为返回值,可返回任何对象
getClass()方法
- public final Class<?> getClass () {}
- 返回引用中存储的实际对象类型
- 应用:通常用于判断两个引用中实际存储对象类型是否一致
Student类:
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;
}
}
TestStudent测试对象:
public class TestStudent {
public static void main(String[] args) {
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 222);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
}
}
hashCode()方法
- public int hashCode() {}
- 返回该对象的哈希码值
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值
- 一般情况下相同对象返回相同哈希码值
Student类:
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;
}
}
TestStudent测试对象:
public class TestStudent {
public static void main(String[] args) {
//getClass方法
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 222);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("================================");
//hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println("================================");
Student s3 = s1; //s1值给了s3,所以hashCode是一样的
System.out.println(s3.hashCode());
}
}
toString()方法
- public String toString() {}
- 返回该对象的字符串表示(表现形式)
- 可以根据程序需求覆盖该方法,如:展示对象各个属性值
依旧是上面的代码
TestStudent对象:
public class TestStudent {
public static void main(String[] args) {
//getClass方法
System.out.println("================getClass================");
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 222);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("================hashCode================");
//hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println("-------------");
Student s3 = s1; //s1值给了s3,所以hashCode是一样的
System.out.println(s3.hashCode());
System.out.println("================toString================");
//toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
}
}
前面就是一些信息,后面的数字就是hashCode,因为这里显示的是16进制,所以跟上面的hashCode不一样,可以自己转换为10进制看一下
这样的结果往往没有什么意思,怎样通过toString把s1和s2的值显示出来?只需在Student类中重写toString方法
快捷键alt+insert,选择toString()
点击ok,即可自动生成重写
![image.png](https://i-blog.csdnimg.cn/blog_migrate/f3a1a40c494ad93721ab02ae2d9d7f79.png)
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
这样就是一个有用的数据了,当然手动重写也一样,无非就是return后不同
equals()方法
- public boolean equals(Object obj) {}
- 默认实现(this == obj),比较两个对象地址是否相同
- 可进行覆盖,比较两个对象的内容是否相同
public class TestStudent {
public static void main(String[] args) {
//getClass方法
System.out.println("================getClass================");
Student s1 = new Student("aaa", 20);
Student s2 = new Student("bbb", 222);
//判断s1和s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2) {
System.out.println("s1和s2属于同一个类型");
}else {
System.out.println("s1和s2不属于同一个类型");
}
System.out.println("================hashCode================");
//hashCode方法
System.out.println(s1.hashCode());
System.out.println(s2.hashCode());
System.out.println("-------------");
Student s3 = s1; //s1值给了s3,所以hashCode是一样的
System.out.println(s3.hashCode());
System.out.println("================toString================");
//toString方法
System.out.println(s1.toString());
System.out.println(s2.toString());
System.out.println("================equals================");
//equals方法,判断两个对象是否相等
System.out.println(s1.equals(s2));
Student s4 = new Student("小明", 17);
Student s5 = new Student("小明", 17);
System.out.println(s4.equals(s5));
}
}
![image.png](https://i-blog.csdnimg.cn/blog_migrate/5a2c25ed61c7d7563833b7c82cc97cee.png)
equals()方法覆盖步骤
上面的代码可以看见s4和s5也不相同,Student s4 = new Student(“小明”, 17);重新new了对象,在堆内存中开辟了新的空间,所以地址值不想等,而equals方法比较两个字符串的内容是否相等
怎么改变equlas的输出结果?只要值相同就为true,可以重写equlas方法
- 比较连个引用是否指向同一个对象
- 判断obj是否为null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 一次比较各个属性值是否相同
在Student类中重写:
@Override
public boolean equals(Object obj) {
//1.判断两个对象是否是同一个引用
if (this == obj) {
return true;
}
//2.判断obj是否为null
if (obj == null) {
return false;
}
//3.判断是否是同一个类型
if (obj instanceof Student) {
//4.强制类型转换
Student s = (Student) obj;
//5.比较属性值
if (this.name.equals(s.getName()) && this.age == s.getAge()) {
return true;
}
}
return false;
}
再运行一遍,此时s4和s5相等
![image.png](https://i-blog.csdnimg.cn/blog_migrate/37a6b0c12161c7952d7595903e7115d6.png)
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象
- 垃圾回收:由GC销毁垃圾对象,释放数据存储空间
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
- 手动回收机制:使用System.gc();通知JVM执行垃圾回收
在finalize源码中这个方法是空的
protected void finalize() throws Throwable { }
我们需要在Student中重写一下,方便显示效果
@Override
protected void finalize() throws Throwable {
System.out.println(this.name + "对象已回收");
}
TestStudent2类:
public class TestStudent2 {
public static void main(String[] args) {
//没有任何调用为垃圾对象
new Student("aaa", 20);
new Student("bbb", 20);
new Student("ccc", 20);
new Student("ddd", 20);
new Student("eee", 20);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
}
}
包装类
什么是包装类
- 基本数据类型所对应的引用数据类型
- Object可统一所有数据,包装类的默认值是null
包装类对应
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
类型转换与装箱、拆箱
基本类型转换为引用类型为装箱,反之为拆箱
- 8种包装类提供不同类型间的转换方式:
- Number父类中提供的6个共性方法
![image.png](https://i-blog.csdnimg.cn/blog_migrate/ed2fb305eab5e64096ab3fa4ba50156e.png)
举个例子
public class Demo01 {
public static void main(String[] args) {
//类型转换:装箱,基本类型转换为引用类型
int num1 = 10;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);
Integer integer2 = Integer.valueOf(num1);
System.out.println("装箱");
System.out.println(integer1);
System.out.println(integer2);
//类型转换:拆箱,引用类型转换为基本类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
System.out.println("拆箱");
System.out.println(num2);
//上面为1.5之前,jdk1.5之后提供自动装箱和拆箱
int age = 20;
//自动装箱
Integer integer4 = age;
System.out.println("自动装箱");
System.out.println(integer4);
//自动拆箱
int age2 = integer4;
System.out.println("自动拆箱");
System.out.println(age2);
}
}
![image.png](https://i-blog.csdnimg.cn/blog_migrate/f23b715bfac7cad717e555444ddc7a39.png)
可以查看一下class文件做个对比
整数缓冲区
- Java预先创建了256个常用的整数包装类型对象
- 在实际应用当中,对已创建的对象进行复用
public class Demo02 {
public static void main(String[] args) {
Integer integer1 = new Integer(100);
Integer integer2 = new Integer(100);
System.out.println(integer1 == integer2);
//自动装箱
Integer integer3 = 100;
Integer integer4 = 100;
System.out.println(integer3 == integer4);
//自动装箱
Integer integer5 = 200;
Integer integer6 = 200;
System.out.println(integer5 == integer6);
}
}
第一个为false是因为内存地址不同;第二个和第三个为何输出结果不同?
其实自动装箱写完整是这样的
//自动装箱
Integer integer3 = Integer.valueOf(100);
Integer integer4 = Integer.valueOf(100);
System.out.println(integer3 == integer4);
//自动装箱
Integer integer5 = Integer.valueOf(200);
Integer integer6 = Integer.valueOf(200);
System.out.println(integer5 == integer6);
查看一下valueOf的源码
public static Integer valueOf(int i) {
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
return new Integer(i);
}
从源码可以看出这是有一个范围的,点进low或high看一下
![image.png](https://i-blog.csdnimg.cn/blog_migrate/92f1b1ef9801ba0474ea777e09fe5e95.png)
IntegerCache,缓冲区,不难看出它定义的范围为-128~127,100在这个范围内,所以对比为true;而200超过这个范围,它就会执行if后面的语句:return new Integer(i);直接在堆中开辟一个空间,这样对比内存地址不同,所以为false
String类
- 字符串是常量,创建之后不可改变
- 字符串字面值存储在字符串池中,可以共享
public class Dmoe01 {
public static void main(String[] args) {
String name = "hello"; //常量,存储在字符串池中(常量池)
name = "kongbai"; //并没有修改值,而是重新开辟一个空间
String name2 = "kongbai";
}
}
![image.png](https://i-blog.csdnimg.cn/blog_migrate/bbaec8aa85830771b27c03d97d4250ef.png)
- String s = “hello”;产生一个对象,字符串池中存储
- String s = new String(“hello”);产生两个对象,堆、池各存储一个
//new创建字符串
String str = new String("java");
这里的“Java”在实际运行的时候只有一个对象,存放在方法区,画图只是可以这样理解
![image.png](https://i-blog.csdnimg.cn/blog_migrate/cfbd590c5b54f215fbc3c6506cffcbc2.png)
比如这里又new了一个str2
String str = new String("java");
String str2 = new String("java");
System.out.println(str == str2);
System.out.println(str.equals(str2));
![image.png](https://i-blog.csdnimg.cn/blog_migrate/6ebd428de30509a11eb05c70d751c731.png)
因此字符串的比较要用equals而不是"==",equals比较的值,"=="比较地址
== 比较的是变量(栈)内存中存放的对象的(堆)内存地址,用来判断两个对象的地址是否相同,即是否是指相同一个对象。比较的是真正意义上的指针操作。
equals用来比较的是两个对象的内容是否相等,由于所有的类都是继承自java.lang.Object类的,所以适用于所有对象,如果没有对该方法进行覆盖的话,调用的仍然是Object类中的方法,而Object中的equals方法返回的却是==的判断。
String常用方法
-
public int length():返回字符串的长度
-
public char charAt(int index):根据下标获取字符
-
public boolean contains(String str):判断当前字符串中是否包含str
-
public char[] toCharArray():将字符串转换成数组
-
public int indexOf(String str):查找str首次出现的下标,存在,则返回该下标,不存在,则返回-1
-
public int lastIndexOf(String str):查找字符串在当前字符串中最后一次出现的下标索引
-
public String trim():去掉字符串前后的空格
-
public String toUpperCase():将小写转换为大写;toLowerCase():将大写转换为小写
-
public boolean endWith(String str):判断字符串是否以str结尾;startWith(String str):判断字符串是否以str开头
-
public String replace(char oldChar, char newChar):将旧字符串替换为新字符串
-
public String[] split(String str):根据str做拆分
import java.util.Arrays;
public class Demo01 {
public static void main(String[] args) {
System.out.println("============字符串方法使用1============");
/*
字符串方法的使用1
1.length():返回字符串的长度
2.charAt(int index):根据下标获取字符
3.contains(String str):判断当前字符串中是否包含str
*/
String count = "javaNB,java真香,java";
System.out.println(count.length()); //length()
System.out.println(count.charAt(0)); //charAt()
//减一是因为字符长度为13,而下标是从0开始的,0位是"j",结束下标为12;
System.out.println(count.charAt(count.length()-1)); //length()和charAt()
System.out.println(count.contains("java")); //contains()
System.out.println(count.contains("php"));
System.out.println("============字符串方法使用2============");
/*
字符串方法的使用2
1.toCharArray():将字符串转换成数组
2.indexOf(String str):查找str首次出现的位置
3.int lastIndexOf(String str):查找字符串最后出现的位置
*/
System.out.println(Arrays.toString(count.toCharArray())); //toCharArray()
System.out.println(count.indexOf("java")); //indexOf()
System.out.println(count.indexOf("java", 4)); //从第4位开始找
System.out.println(count.lastIndexOf("java")); //lastIndexOf()
System.out.println("============字符串方法使用3============");
/*
字符串方法的使用3
1.trim():去掉字符串前后的空格
2.toUpperCase():将小写转换为大写;toLowerCase():将大写转换为小写
3.endWith(String str):判断字符串是否以str结尾;startWith(String str):判断字符串是否以str开头
*/
String count2 = " Hello World ";
System.out.println(count2.trim()); //trim()
System.out.println(count2.toUpperCase()); //toUpperCase()
System.out.println(count2.toLowerCase()); //toLowerCase()
String count3 = "hello.java";
System.out.println(count3.endsWith("java")); //endWith()
System.out.println(count3.startsWith("java")); //startWith()
System.out.println("============字符串方法使用4============");
/*
字符串方法的使用4
1.replace(char oldChar, char newChar):将旧字符串替换为新字符串
2.split(String str):根据str做拆分
*/
String conut4 = "javaNB,java真香,java";
System.out.println(conut4.replace("java", "php")); //replace()
System.out.println(count2.replace(" ", "")); //将count2的空格替换掉
String count5 = "java is the best programing language";
String[] array = count5.split(" "); //split(),这里以空格作为拆分单位
System.out.println(count5.length());
for (String string : array) { //增强型for循环;意思是把array中的每个元素依次赋值给string
System.out.println(string);
}
System.out.println("-----split()使用技巧1-----");
//关于split有一个技巧,比如count6,如果我们想分别用空格和“,”号来进行拆分,怎么做
String count6 = "java is the best programing language,java";
String[] array1 = count6.split("[ ,]"); //小括号里面输入空格和逗号
System.out.println(count6.length());
for (String string1 : array1) {
System.out.println(string1);
}
System.out.println("-----split()使用技巧2-----");
/*
再假如如果不小心空格打多了怎么办?
比如String count7 = "java is the best programing language,java";
我在the后面打了两个空格,这时打印的话就会在the后面出现一个空格
也可以解决
*/
String count7 = "java is the best programing language,java";
String[] array2 = count7.split("[ ,]+"); //后面再添加一个+符号,表示前面的空格或逗号可以连续出现多个也可以拆分
System.out.println(count7.length());
for (String string2 : array2) {
System.out.println(string2);
}
System.out.println("-----补充-----");
//补充两个方法equals()、compareTo()比较大小
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1.equals(s2));
System.out.println(s1.equalsIgnoreCase(s2)); //忽略大小写比较
//compareTo()比较的是编码表的位置,只要第一位对比出结果就行;
//如果第一位都一样,那就比第二位,以此类推
String s3 = "abc"; //a=97
String s4 = "xyz"; //x=120
System.out.println(s3.compareTo(s4)); //s3-s4的结果
//这种情况的比较就不是比大小,而是比位数
String s5 = "abc";
String s6 = "abcxyz";
System.out.println(s5.compareTo(s6));
}
}
============字符串方法使用1============
18
j
a
true
false
============字符串方法使用2============
[j, a, v, a, N, B, ,, j, a, v, a, 真, 香, ,, j, a, v, a]
0
7
14
============字符串方法使用3============
Hello World
HELLO WORLD
hello world
true
false
============字符串方法使用4============
phpNB,php真香,php
HelloWorld
36
java
is
the
best
programing
language
-----split()使用技巧1-----
41
java
is
the
best
programing
language
java
-----split()使用技巧2-----
42
java
is
the
best
programing
language
java
-----补充-----
false
true
-23
-3
Process finished with exit code 0
String案例演示
- 需求
- 已知String str = “this is a text”;
- 1.将str中的单词单独获取出来
- 2.将str中的text替换为practice
- 3.在text前面插入一个easy
- 4.将每个单词的首字母改为大写
/**
* 需求
* - 已知String str = "this is a text";
* - 1.将str中的单词单独获取出来
* - 2.将str中的text替换为practice
* - 3.在text前面插入一个easy
* - 4.将每个单词的首字母改为大写
*/
public class Demo01 {
public static void main(String[] args) {
String str = "this is a text";
System.out.println("========1========");
//1.将str中的单词单独获取出来
String[] array = str.split(" ");
for (String s : array) {
System.out.println(s);
}
System.out.println("========2========");
//2.将str中的text替换为practice
String str2 = str.replace("text", "practice");
System.out.println(str2);
System.out.println("========3========");
//3.在text前面插入一个easy
String str3 = str.replace("text", "easy text");
System.out.println(str3);
System.out.println("========3========");
//4.将每个单词的首字母改为大写
for (int i = 0; i <array.length ; i++) {
char first = array[i].charAt(0);
//把第一个字符转换为大写
char upperfirst = Character.toUpperCase(first);
/*
substring()方法返回字符串的子字符串
数组是这样的:array = {"this", "is", "a", "text"}
array[0]为"this",这个代码意思就是首字母大写T + array[0]从第二个字符开始之后的字符
数组可以这样写,但如果是字符串,那么就得一个一个来
*/
String news = upperfirst + array[i].substring(1); //这个1表示从第二个开始
System.out.print(news + " "); //print不换行打印,后面加个空格增加可读性
}
}
}
![image.png](https://i-blog.csdnimg.cn/blog_migrate/26b83ad5dd3e9b1cae0ba6418b647b53.png)
可变字符串
- StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全
- StringBuilder:可变长字符串,JDK5.0提供,运行效率快,线程不安全
以下是StringBuffer和StringBuilder的一些使用方法
//StringBuffer和StringBuilder
//比String效率高,比String节省内存
public class Demo01 {
public static void main(String[] args) {
/*
以下方法StringBuffer和StringBuilder都能用且使用效果一样
因为StringBuilder效率高,所以尽量使用StringBuilder
*/
//StringBuffer sb = new StringBuffer();
StringBuilder sb = new StringBuilder();
//1.append();追加
sb.append("妙啊");
System.out.println(sb.toString());
sb.append("javaNB");
System.out.println(sb.toString());
//2.insert();添加 这个0表示在哪添加
sb.insert(0, "我第一");
System.out.println(sb.toString());
//3.replace();替换 与前面replace()方法类似,但这个可以指定替换位置
sb.replace(0, 3, "hello"); //左闭右开原则
System.out.println(sb.toString());
//4.delete();删除
sb.delete(0, 3); //左闭右开原则
System.out.println(sb.toString());
//清空
sb.delete(0, sb.length());
System.out.println(sb.length()); //查看长度
}
}
下面来验证一下StringBuffer或StringBuilder的效率比String高
先来看看String,输出1~99999要花多久,注意这个数值别弄太大,小心电脑卡死或长时间无结果
//StringBuilder和StringBuffer效率都高于String
//验证StringBuilder效率高于String
public class Demo02 {
public static void main(String[] args) {
long start = System.currentTimeMillis(); //开始时间
String string = " ";
for (int i = 0; i < 99999; i++) {
string += i;
}
System.out.println(string);
long end = System.currentTimeMillis(); //结束时间
System.out.println("用时:" + (end - start));
}
}
上面是结果,下面是耗时,大约18秒
18接下用StringBuilder试一下
long start = System.currentTimeMillis(); //开始时间
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 99999; i++) {
sb.append(i);
}
System.out.println(sb.toString());
long end = System.currentTimeMillis(); //结束时间
System.out.println("用时:" + (end - start));
可以看到非常快;0.023秒
BigDecimal
-
思考:一下程序输出结果是多少
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); } }
为什么会这样
Java中的简单浮点数类型float和double不能够进行运算,因为大多数情况下是正常的,但是偶尔会出现如上所示的问题。这个问题其实不是JAVA的bug,因为计算机本身是二进制的,而浮点数实际上只是个近似值,所以从二进制转化为十进制浮点数时,精度容易丢失,导致精度下降
要保证精度就要使用BigDecimal类,而且不能直接从double直接转BigDecimal,要将double转string再转BigDecimal。也就是不能使用BigDecimal(double val) 方法,你会发现没有效果。要使用BigDecimal(String val) 方法
- 位置:java.math包中
- 作用:精确计算浮点数
- 创建方式:BigDecimal bd = new BigDecimal(“1.0”);
- 方法:
- BigDecimal add(BigDecimal bd)–加
- BigDecimal subtract(BigDecimal bd)–减
- BigDecimal multiply(BigDecimal bd)–乘
- BigDecimal divide(BigDecimal bd)–除
import java.math.BigDecimal;
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);
System.out.println("==========================");
//BigDecimal,浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//类的减法运算
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1);
//加法运算
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);
//乘法运算
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);
//除法运算,这里1.0 / 0.9除不尽,所以换个数;这里使用链式编程,就是定义和运算写在一块
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4);
//除法可能会出现除不尽的情况,divide方法有一个四舍五入方法:BigDecimal.ROUND_HALF_UP
BigDecimal r5 = new BigDecimal("10")
.divide(new BigDecimal("3"), 2, BigDecimal.ROUND_HALF_UP); //保留2位
System.out.println(r5);
}
}
- 除法:divide(BigDecimal bd, int scal, RoundingMode mode)
- 参数scal:指定精确到小数点后几位
- 参数mode:
- 指定小数部分的取舍模式,通常采用四舍五入的模式ROUND_HALF_UP
- 取值为BigDecimal.ROUND_HALF_UP
Date类
- Date表示特定的瞬间,精确到毫秒;Date类中的大部分方法都已经被Calendar类中的方法所取代
- 时间单位
- 1秒 = 1000毫秒
- 1毫秒 = 1000微秒
- 1微秒 = 1000纳秒
过时的方法会用删除线表示出来
import java.util.Date;
public class Demo01 {
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.toLocaleString()); 已过时的方法
//2.方法after()测试此日期是否在指定日期之后、before()测试此日期是否在指定日期之前
boolean b1 = date1.after(date2);
System.out.println(b1);
boolean b2 = date1.before(date2);
System.out.println(b2);
//compareTo();比较两个日期,比较毫秒值
int d = date1.compareTo(date2);
System.out.println(d);
int d1 = date2.compareTo(date1);
System.out.println(d1);
//equals();比较是否相等
boolean b3 = date1.equals(date2);
System.out.println(b3);
}
}
Calendar类
- Calendar提供了获取或设置各种日历字段的方法
- 构造方法
- protected Calendar():由于修饰符是protected,所以无法直接创建该对象
- 其它方法
方法名 | 说明 |
---|---|
static Calendar getInstance() | 使用默认时区和区域获取日历 |
void set(int year, int month, int date, int hourofday, int minute, int second) | 设置如理的年、月、日、时、分、秒 |
int get(int field) | 返回给定日历字段的值,字段比如年、月、日等 |
void setTime(Date date) | 用给定的Date设置此日历的时间,Date-Calendar |
Date getTime() | 返回一个Date表示此日历的时间,Calendar-Date |
void add(int field, int amount) | 按照日历的规则,给指定字段添加或减少时间量 |
long getTimeMillies() | 毫秒为单位返回该日历的时间值 |
import java.util.Calendar;
public class Demo02 {
public static void main(String[] args) {
//1.创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis()); //毫秒值,从1970年开始
//2.获取时间信息
//获取年
int year = calendar.get(Calendar.YEAR); //这里面可以直接写1,但这样代码可读性会降低
System.out.println(year);
//获取月,需要注意月的范围是0-11,所以输出结果需要+1
int month = calendar.get(Calendar.MONTH);
System.out.println(month);
//获取日
int day = calendar.get(Calendar.DAY_OF_MONTH); //也可以用DATE
System.out.println(day);
//小时
int hour = calendar.get(Calendar.HOUR_OF_DAY); //24小时制;也可以用HOUR,12小时制
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 + "秒");
//3.修改时间
Calendar calendar1 = Calendar.getInstance();
/*
这里我发现一个奇怪的问题,修改月份的时候,输出的结果要比这个数大1
比如当前12月,我想把日期改为11月,如果这里填11结果还是12
想改为11就必须填10,好像会自动+1;
应该跟月份的设置范围有关,因为这里月份是0-11
*/
calendar1.set(Calendar.MONTH, 10); //月份修改为11
System.out.println(calendar1.getTime().toLocaleString());
//4.add方法修改时间
calendar1.add(Calendar.HOUR, 1); //小时增加1,减少就用负数,如-1
System.out.println(calendar1.getTime().toLocaleString());
//5.补充方法;获取当前时间的最大值或最小值
calendar1.add(Calendar.MONTH, 1); //月份+1
System.out.println(calendar1.getTime().toLocaleString());
int max = calendar1.getActualMaximum(Calendar.DAY_OF_MONTH); //本月最大的一天
int min = calendar1.getActualMinimum(Calendar.DAY_OF_MONTH); //本月最小的一天
System.out.println(max);
System.out.println(min);
}
}
SimpleDateFormat类
-
SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
-
进行格式化(日期->文本)、解析(文本->日期)
-
常用的时间模式字母
字母 日期或时间 示例 y 年 2019 M 月 08 d 日 10 H 一天中小时数(0-23) 22 m 分钟 16 s 秒 59 S 毫秒 367 import java.text.SimpleDateFormat; import java.util.Date; public class Demo03 { public static void main(String[] args) throws Exception{ //1.创建SimpleDateFormat对象 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日"); //输出的格式 //2.创建Date Date date = new Date(); //格式化date 把日期转为字符串 String str = sdf.format(date); System.out.println(str); //解析 把字符转转为日期 Date date1 = sdf.parse("2020年10月11日"); //必须与上面的格式相对应 System.out.println(date1.toLocaleString()); } }
System类
-
System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的
方法名 说明 static void arraycopy() 复制数组 static long currentTimeMillis() 获取当前系统时间,返回的是毫秒值 static void gc() 建议JVM赶快启动垃圾回收器回收垃圾 static void exit(int status) 退出JVM,如果参数是0表示正常退出jvm,非0表示异常退出jvm
看一下arraycopy和exit即可,另外两个前面已学习
public class Demo01 {
public static void main(String[] args) {
//1.arraycope(src, srcPos, dest, desPos, length):数组复制
/*
src:源数组;
srcPos:从哪个位置开始复制;
dest:目标数组;
destPos:目标数组的位置
length:复制的长度
*/
int[] array = {1, 5, 8, 20, 55, 7, 90, 6};
int[] dest = new int[8];
System.arraycopy(array, 2, dest, 4, 3);
for (int i = 0; i < dest.length; i++) {
System.out.println(dest[i]);
}
//2.退出jvm
System.exit(0); //非0为异常退出
System.out.println("jvm退出了"); //上面已经退出,所以这里不会执行了
}
}
总结
- 内部类
- 在一个类的内部再定义的一个完整的类
- 成员内部类、静态内部类、局部内部类、匿名内部类
- Object类
- 所有类的直接或间接父类,可存储任何对象
- 包装类
- 基本数据类型所对应的引用数据类型,可以使Object统一所有数据
- String类
- 字符串是常量,创建之后不可改变,字面值保存在字符串池中,可以共享
- BigDecimal类
- 可精确计算浮点数
- Date类
- 特定时间
- Calendar类–对Date类的改善
- 日历
- SimpleDateFormat类
- 格式化时间
- System类
- 系统类