Java常用类
1内部类
概念:在一个类的内部再定义一个完整的类。
class Outer{
class Inner{
}
}
- 特点:
- 编译之后可生成独立的字节码文件。
- 内部类可直接访问外部类的私有成员,而不破坏封装。
- 可为外部类提供必要的内部功能组件。
1)成员内部类
-
在类的内部定义,与实例变量、实例方法同级别的类。
-
外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象。
-
当外部类、内部类存在重名属性时,会优先访问内部类属性。
-
成员内部类不能定义静态成员static,但可以包含静态常量 final
//外部类
public class Outer {
//实例变量
private String name = "张三";
private int age = 18;
//内部类
class Inner{
private String address = "南京";
private String phone = "120";
//属性和外部类的属性名字相同
private String name = "李四";
//方法
public void show(){
//打印外部类的属性,属性和外部类的属性名字相同,Outer.this
System.out.println(name);
System.out.println(Outer.this.name);
System.out.println(Outer.this.age);
//打印内部类的属性
System.out.println(this.address);
System.out.println(this.phone);
}
}
}
public class TestOuter {
public static void main(String[] args) {
// //1 创建外部类对象
// Outer outer = new Outer();
// //2 创建内部类对象
// Outer.Inner inner = outer.new Inner();
//一步的写法
Outer.Inner inner = new Outer().new Inner();
inner.show();
}
}
2) 静态内部类
-
不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员。
-
只能直接访问外部类的静态成员(实例成员需实例化外部类对象)
Outer.Inner inner = new Outer.Inner();
Outer.Inner.show();
public class Outer {
private String name = "***";
//静态内部类:和外部类相同
static class Inner{
private String address = "南京";
//静态成员
private static int count = 100;
public void show(){
//调用外部类的属性时
//1 先创建外部类对象
Outer outer = new Outer();
//2 调用外部类对象属性
System.out.println(outer.name);
//调用静态内部类的属性时
System.out.println(this.address);
//调用静态内部类的静态属性时
System.out.println(Inner.count);
}
}
}
public class TestOuter {
public static void main(String[] args) {
Outer.Inner inner = new Outer.Inner();
//调用方法
inner.show();
}
}
3)局部内部类
- 定义在外部类方法中,作用范围和创建对象范围仅限于当前方法。
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final。
- 限制类的使用范围。
public class Outer {
private String name = "张三";
private int age = 18;
public void show(){
//定义局部变量
String address = "南京";
//局部内部类:注意不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String phone = "123456";
private String email = "zhangsan@123.com";
public void show2(){
//访问外部类属性
System.out.println(Outer.this.name);
System.out.println(age);
//访问内部类属性
System.out.println(this.phone);
System.out.println(this.email);
//访问局部变量,jdk1.7要求,局部变量必须时常量,
// jdk1.8及以后自动添加final
System.out.println(address);
}
}
//创建局部类对象
Inner inner = new Inner();
inner.show2();
}
}
class Test{
public static void main(String[] args) {
Outer outer = new Outer();
outer.show();
}
}
4)匿名内部类
- 没有类名的局部内部类(一切特征都与局部内部类相同)
- 必须继承一个父类或者实现一个接口。
- 定义类、实现类、创建对象的语法合并,只能创建一个该类的对象。
- 优点:减少代码量,
- 缺点:可读性较差。
package com.huang.innerclass.Demo04;
//接口
public interface Usb {
//服务方法
void service();
}
package com.huang.innerclass.Demo04;
public class Mouse implements Usb{
@Override
public void service() {
System.out.println("连接电脑成功,鼠标开始共工作!");
}
}
package com.huang.innerclass.Demo04;
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 usb = new Usb(){
@Override
public void service() {
System.out.println("连接电脑成功,风扇开始工作!");
}
};
usb.service();
}
}
2 Object类
- 超类、基类,所有类的直接或间接父类,位于继承树的最顶层。
- 任何类,如没有书写extends显示继承某个类,都默认直接继承Object类,否则为间接继承。
- Object类中所定义的方法,是所有对象都具备的方法。
- Object类型可以存储任何对象。
- 作为参数,可接受任何对象。
- 作为返回值,可返回任何对象。
3 Object类常用方法
1)getClass方法
public final Class<?> getClass(){}
- 返回引用中存储的实际对象类型
- 应用:通常用于判断两个引用中实际存储对象类型是否一致。
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if(class1==class2){
}
2)hashCode方法
public int hashCode (){}
- 返回该对象的哈希码值。
- 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值。
- 一般情况下相同对象返回相同哈希码。
int hashValue = s1.hashCode();
3)toString方法
public String toString(){}
- 返回该对象的字符串表示(表现形式)
- 可以根据程序需求覆盖该方法(重写:快捷键Alt+insert),如:展示对象各个属性值。
public String toString() {
return "Outer{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
//输出为
// Outer{name='张三', age=18}
4)equals方法
public boolean equals(Object obj){}
- 默认实现为(this == obj),比较两个对象地址是否相同。
- 可进行覆盖(重写),比较两个对象的内容是否相同。
- 比较两个引用是否指向同一个对象。
- 判断obj是否为null
- 判断两个引用指向的实际对象类型是否一致。
- 强制类型转换
- 依次比较各个属性值是否相同。
public boolean equals(Object obj){
return(this == obj);
}
boolean value = s1.equals(s2);
//重写equals()方法
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;
}
5)finalize方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列。
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象。
- 垃圾回收:由GC销毁垃圾对象,释放数据存储空间。
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象。
- 手动回收机制:使用System.gc();通知JVM执行垃圾回收。
4 包装类
- 基本数据类型所对应的引用数据类型。
- Object可统一所有数据,包装类的默认值是null。
8种包装类对应,继承于Number类
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
基本类型存储在栈中,引用类型存储在堆中
装箱:把基本类型转换为引用类型(数据:栈–>堆)
拆箱:把引用类型转换为基本类型(数据:堆–>栈)
- 8种包装类提供不同类型间的转换方式:
- Number父类中提供的6个共性方法。
- parseXXX() 静态方法。(字符串–>基本类型)
- valueOf() 静态方法。(装箱,基本类型–>引用类型)
Number类
变量和类型 | 方法 | 描述 |
---|---|---|
byte | byteValue() | 返回指定数字的值 byte 。 |
abstract double | doubleValue() | 返回指定数字的值 double 。 |
abstract float | floatValue() | 返回指定数字的值 float 。 |
abstract int | intValue() | 以 int 返回指定数字的 int 。 |
abstract long | longValue() | 以 long 返回指定数字的值。 |
short | shortValue() | 返回指定数字的值 short 。 |
public class Demo01 {
public static void main(String[] args) {
//类型转换:装箱,基本类型-->引用类型
int num1 = 15;
//使用Integer类创建对象
Integer integer1 = new Integer(num1);//已弃用
Integer integer2 = Integer.valueOf(num1);
//类型转换:拆箱,引用类型-->基本类型
Integer integer3 = new Integer(100);
int num2 = integer3.intValue();
//JDK1.5之后,提供自动装箱和拆箱
int age = 20;
//自动装箱
Integer integer4 = age;
//自动拆箱
int age2 = integer4 ;
}
}
//基本类型和字符串之间的转换
//1 基本类型-->字符串
int n1 = 10;
//1.1使用 “+”
String s1 = n1 + "";
//1.2使用Integer中的toString()方法
String s2 = Integer.toString(n1);
String s3 = Integer.toString(n1,16);//重载方法,16表示16进制
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
//1 字符串-->基本类型
String str = "100";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);
System.out.println(n2);
//boolean字符串形式转成基本类型,“true"-->true,非”true“-->false
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
Integer缓冲区: -128 ~ 127
- Java预先创建了256个常用的整数包装类型对象。
- 在实际应用当中,对已创建的对象进行复用。
5 String类
- 字符串是常量,创建之后不可改变。
- 字符串 字面值 存储在字符串池 (方法区中) 中,可以共享。
- String s =“Hello”;产生一个对象,字符串池中存储。
- String s = new String(“Hello");//产生两个对象,堆、池各存储一个。
1)length()方法
public int length()
:返回字符串长度
2)charAt(int index)方法
public char charAt(int index)
:根据下标获取字符
3)contains(String str)方法
public boolean contains(String str)
:判断当前字符串中是否包含str
4)toCharArray()方法
public char[] toCharArray()
:将字符串转换成数组
5)indexOf(String str)方法
public int indexOf(String str)
:查找str首次出现的下标,存在,则返回该下标;不存在,则返回-1
6)lastIndexOf(String str)方法
public int lastIndexOf(String str)
:查找字符串在当前字符串中最后一次出现的下标索引
7)trim()方法
public String trim()
:去掉字符串前后的空格。
8)toUpperCase()方法
public String toUpperCase()
:将小写转成大写。
public String toLowerCase()
:将大写转成小写。
9)endWith(String str)方法
public boolean endWith(String str)
:判断字符串是否以str结尾。
10)replace(char oldChar,char newChar)方法
public String replace(char oldChar,char newChar)
:将旧字符串替换成新字符串
11)split(String str)方法
public String split(String str)
:根据str做拆分.
String[] arr = say.split("[ ,]+");
equals() 和compare()的比较
String s1 = "hello";
String s2 = "HELLO";
System.out.println(s1。equalsIgnoreCase(s2));//忽略大小写 true
String s3 = "abc";//97
String s4 = "xyz";//120
System.out.println(s3.compareTo(s4));//-23
String s3 = "abc";//3
String s4 = "abcxyz";//6
System.out.println(s5.compareTo(s6));//-3
案例演示
需求:已知String str = “this is a text”;
- 将str中的单词单独获取出来
- 将str中的text替换为practice
- 在text前面插入easy
- 将每个单词的首字母改为大写
/**
* 需求:已知String str = "this is a text";
*
* 1. 将str中的单词单独获取出来
* 2. 将str中的text替换为practice
* 3. 在text前面插入easy
* 4. 将每个单词的首字母改为大写
*/
public class Case {
public static void main(String[] args) {
String str = "this is a text";
//1. 将str中的单词单独获取出来
System.out.println("---------1. 将str中的单词单独获取出来-------");
String[] arr = str.split(" ");
for(String s:arr){
System.out.println(s);
}
//2. 将str中的text替换为practice
System.out.println("---------2. 将str中的text替换为practice-------");
String str2 = str.replace("text","practice");
System.out.println(str2);
//3. 在text前面插入easy
System.out.println("---------3. 在text前面插入easy-------");
String str3 = str.replace("text","easy text");
System.out.println(str3);
//4. 将每个单词的首字母改为大写
System.out.println("---------4. 将每个单词的首字母改为大写------");
for(int i=0; i<arr.length;i++){
char first = arr[i].charAt(0);
char upperfirst = Character.toUpperCase(first);
String news = upperfirst + arr[i].substring(1);
System.out.print(news + " ");
}
System.out.println();
}
}
/* ****输出结果******
---------1. 将str中的单词单独获取出来-------
this
is
a
text
---------2. 将str中的text替换为practice-------
this is a practice
---------3. 在text前面插入easy-------
this is a easy text
---------4. 将每个单词的首字母改为大写------
This Is A Text
*/
5.1 可变字符串
- StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全。
- StringBuilder:可变长字符串,JDK5.0提供,运行效率快、线程不安全。
public class StrBuf {
/*
* - StringBuffer:可变长字符串,JDK1.0提供,运行效率慢、线程安全。
- StringBuilder:可变长字符串,JDK5.0提供,运行效率快、线程不安全。
* */
public static void main(String[] args) {
// StringBuffer sb = new StringBuffer();
StringBuilder sb = new StringBuilder();
//1 append();追加
sb.append("java is best");
System.out.println(sb.toString());
sb.append(" Yes");
System.out.println(sb.toString());
//2 insert();添加
sb.insert(0,"我在前面 ");
System.out.println(sb.toString());
//3 replace();替换
sb.replace(0,4,"Hello");
System.out.println(sb.toString());
//4 delete();删除
sb.delete(0,5);
System.out.println(sb.toString());
//清空
sb.delete(0,sb.length());
System.out.println(sb.length());
}
}
6 BigDecimal类
//思考题
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);//输出0.09999999999999998
//面试题
double result = (1.4-0.5)/0.9;
System.out.println(result);//输出0.9999999999999999
很多实际应用中需要精确运算,而double是近似值存储,不在符合要求,需要借助BIgDecimal。
- 位置:java.math包中。
- 作用:精确计算浮点数。
- 创建方式:
BigDecimal bd=new BigDecimal("1.0");
- 除法:
divide(BigDecimal bd,int scal,RoundingMode mode)
- 参数scal:指定精确到小数点后几位。
- 参数mode:指定小数部分的取舍模式,通常采用四舍五入的模式,取值为BigDecimal.ROUND_HALF_UP。
//思考题
double d1 = 1.0;
double d2 = 0.9;
System.out.println(d1-d2);//输出0.09999999999999998
//面试题
double result = (1.4-0.5)/0.9;
System.out.println(result);//输出0.9999999999999999
//BigDecimal,大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0");
BigDecimal bd2 = new BigDecimal("0.9");
//减法
BigDecimal r1 = bd1.subtract(bd2);
System.out.println(r1); //输出 0.1
//加法
BigDecimal r2 = bd1.add(bd2);
System.out.println(r2);// 1.9
//乘法
BigDecimal r3 = bd1.multiply(bd2);
System.out.println(r3);// 0.90
//除法
BigDecimal r4 = new BigDecimal("1.4")
.subtract(new BigDecimal("0.5"))
.divide(new BigDecimal("0.9"));
System.out.println(r4);// 1
//除不尽的情况,保留小数位
BigDecimal r5 = new BigDecimal("20").divide(new BigDecimal("3"),3, RoundingMode.HALF_UP);
//RoundingMode.HALF_UP:4舍5入法
System.out.println(r5);// 6.667
7 Date类
Date表示特定的瞬间,精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。
时间单位。
1秒=1000毫秒
1毫秒=1000微秒
1微秒=1000纳秒
//1 创建Date对象
//今天
Date date1 = new Date();
System.out.println(date1.toString()); //Sat Feb 26 11:02:54 CST 2022
System.out.println(date1.toLocaleString());//2022年2月26日 上午11:02:54
//昨天
Date date2 = new Date(date1.getTime()-(60*60*24*1000));//一天的毫秒数:60*60*24*1000
System.out.println(date2.toLocaleString());//2022年2月25日 上午11:10:40
//2 方法 after before
System.out.println(date1.after(date2));//true
System.out.println(date1.before(date2));//false
//比较compareTo()
System.out.println(date1.compareTo(date2));//1
//equals()
System.out.println(date1.equals(date2));//false
8 Calendar类
-
Calendar提供了获取或设置各种日历字段的方法。
-
构造方法
- protected Calendar():由于修饰符是protected,所以无法直接创建该对象。
-
其他方法
变量和类型 | 方法 | 描述 |
---|---|---|
abstract void | add(int field, int amount) | 根据日历的规则,将指定的时间量添加或减去给定的日历字段 |
int | get(int field) | 返回给定日历字段的值。 |
static Calendar | getInstance() | 使用默认时区和区域设置获取日历。 |
Date | getTime() | 返回一个 Date 对象,表示此 Calendar 的时间值 |
long | getTimeInMillis() | 以毫秒为单位返回此Calendar的时间值。 |
void | set(int year, int month, int date, int hourOfDay, int minute, int second) | 设置字段中的值 YEAR , MONTH , DAY_OF_MONTH , HOUR_OF_DAY , MINUTE 和 `SECOND |
void | setTime(Date date) | 使用给定的 Date 设置此日历的时间。 |
//1 创建Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());//2022年2月26日 上午11:29:50
System.out.println(calendar.getTimeInMillis());//毫秒值1645846256953
//2 获取时间信息
int year = calendar.get(Calendar.YEAR);
int month = calendar.get(Calendar.MONTH);
int day = calendar.get(Calendar.DAY_OF_MONTH);
int hour = calendar.get(Calendar.HOUR_OF_DAY);//12小时制 HOUR_OF_DAY
int minute = calendar.get(Calendar.MINUTE);
int second = calendar.get(Calendar.SECOND);
System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+":"+minute+":"+second);//2022年2月26日11:39:13
//3 修改时间
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH,24);
System.out.println(calendar2.getTime().toLocaleString());//2022年2月24日 上午11:41:56
9 SimpleDATeFormat类
- SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类。
- 进行格式化(日期->文本)、解析(文本->日期)
常用的时间模式字母
字母 Date or Time Component Presentation Examples G
Era designator Text AD
y
Year Year 1996
;96
Y
Week year Year 2009
;09
M
Month in year (context sensitive) Month July
;Jul
;07
L
Month in year (standalone form) Month July
;Jul
;07
w
Week in year Number 27
W
Week in month Number 2
D
Day in year Number 189
d
Day in month Number 10
F
Day of week in month Number 2
E
Day name in week Text Tuesday
;Tue
u
Day number of week (1 = Monday, …, 7 = Sunday) Number 1
a
Am/pm marker Text PM
H
Hour in day (0-23) Number 0
k
Hour in day (1-24) Number 24
K
Hour in am/pm (0-11) Number 0
h
Hour in am/pm (1-12) Number 12
m
Minute in hour Number 30
s
Second in minute Number 55
S
Millisecond Number 978
z
Time zone General time zone Pacific Standard Time
;PST
;GMT-08:00
Z
Time zone RFC 822 time zone -0800
X
Time zone ISO 8601 time zone -08
;-0800
;-08:00
/**
* SimpleDATeFormat类
*/
public class Demo04 {
public static void main(String[] args) throws Exception{
//1 创建SimpleDATeFormat对象 y年 M月
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
//2 创建Date
Date date = new Date();
//格式化date(把日期转成字符串)
String str = sdf.format(date);
System.out.println(str);
//解析(字符-->日期)
Date date2 = sdf.parse("2022/02/26 11:55:04");//需抛出异常
System.out.println(date2.toLocaleString());
}
}
10 System类
- System系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的。
方法名 | 说明 |
---|---|
static void arraycopy(...) | 复制数组 |
static long currentTimeMillis() | 获取当前系统时间,返回的是毫秒值 |
static void gc() | 建议JVM赶快启动垃圾回收器回收垃圾 |
static void exit(int status) | 退出JVM,如果参数是0 表示正常退出JVM,非0表示异常退出JVM |
//1 arraycopy(),数据复制
//System.arraycopy(src,srcPos,dest,destPos,length);
//src:源数组
//srcPos:从哪个位置开始复制
//dest:目标数组
//destPos:目标数组的位置
//length:复制的长度
int[] arr = {1,2,3,4,8,7,6,5};
int[] dest = new int[8];
System.arraycopy(arr,4,dest,4,4);
for(int i=0; i<dest.length;i++){
System.out.println(dest[i]);
}
// Arrays.copyOf(original,newLength);
//2 currentTimeMillis(),获取时间
System.out.println(System.currentTimeMillis());
//计时
long start = System.currentTimeMillis();
for(int i = -99999;i<999999;i++){
for(int j = -99999;j<999999;j++){
int result = i+j;
}
}
long end = System.currentTimeMillis();
System.out.println("用时:"+(end-start));
//3 gc(),垃圾回收
//匿名使用后,会自动回收
System.gc();
//4 exit(0),退出
System.exit(0);//退出JVM
System.out.println("程序退出了!");//不会被执行
总结
- 内部类:
- 在一个类的内部再定义一个完整的类。
- 成员内部类、静态内部类,局部内部类、匿名内部类。
- Object类:
- 所有类的直接或间接父类,可存储任何对象。
- 包装类:
- 基本数据类型所对应的引用数据类型,可以使Object统一所有数据。
- String类:
- 字符串是常量,创建之后不可改变,字面值保存在字符串池中,可以共享。
- BigDecimal:
- 可精确计算浮点数。
- Date
- 特定时间
- Calendar
- 日历
- SimpleDateFormat
- 格式化时间
- System
- 系统类
资料整理来源:千峰教育
视频链接:点击此处