Java常用类
内部类
- 成员内部类
- 静态内部类
- static
- 局部内部类
- 匿名内部类
public class Demo01 {
private String name = "weirui";
class Header{
public void show(){
System.out.println(name);//内部类访问外部类的私有成员
}
}
}
概念:在一个类的内部再定义一个完整的类
特点:
- 编译之后可生成独立的字节码文件
- 内部类可直接访问外部类的私有成员,而不破坏封装
- 可为外部类提供必要的内部功能组件
成员内部类
-
再类的内部定义,与实例变量、实例方法同级别的类
-
外部类的一个实例部分,创建内部类对象时,必须依赖外部类对象
-
public class Test { public static void main(String[] args) { // //创建外部类对象 // Demo01 demo01 = new Demo01(); // //创建内部类对象 // Demo01.Inner inner = demo01.new Inner(); //一步到位 Demo01.Inner inner = new Demo01().new Inner(); inner.show(); } }
-
当外部类,内部类存在重名属性时,会优先访问内部类属性
public class Demo01 {
private String name = "weirui";
private int age = 20;
class Inner {
private String adderss = "beijing";
//会优先访问内部类
private String name = "ye";
//打印外部类的属性,内部类属性和外部类的属性名字相同,Demo01.this
public void show() {
//重名访问外部类属性
System.out.println(Demo01.this.name);
//打印外部类属性
System.out.println(name);//内部类访问外部类的私有成员
//打印内部类属性
System.out.println(adderss);
}
}
}
- 成员内部类不能定义静态成员、但是可以包含静态常量 static final
静态内部类
- 不依赖外部类对象,可直接创建或通过类名访问,可声明静态成员
- 只有内部类,才可以使用 static 修饰
//外部类
public class Demo02 {
private String name = "qqq";
private int age = 11;
//静态内部类,和外部类相同
static class Inner{
private String address = "wei";
//静态成员
private static int count = 100;
public void show(){
//调用外部类的属性
//1.先创建外部类对象
Demo02 demo02 = new Demo02();
//2.调用外部类对象的属性
System.out.println(demo02.name);
System.out.println(demo02.age);
//3.调用静态内部类的属性和方法
System.out.println(this.address);
//4.调用静态内部类的静态属性
System.out.println(Inner.count);
}
}
}
public class Test {
public static void main(String[] args) {
//直接创建静态内部类对象
Demo02.Inner inner = new Demo02.Inner();//包含关系
//调用方法
inner.show();
}
}
局部内部类
- 定义在外部类方法中、作用范围和创建对象范围仅限于当前方法
- 局部内部类不包含 静态常量 static 但是可以包含 final 静态常量
- 局部内部类访问外部类当前方法中的局部变量时,因无法保障变量的生命周期与自身相同,变量必须修饰为final
- 限制类的使用范围
//外部类
public class Demo03 {
private String name = "weirui";
private int age = 88;
public void show(){
//定义局部变量
String address = "yyy";
//局部内部类: 注意不能加任何访问修饰符
class Inner{
//局部内部类的属性
private String email = "464@w";
public void show1(){
//访问外部类的属性
System.out.println(Demo03.this.name);
System.out.println(Demo03.this.age);
//访问内部类的属性
System.out.println(this.email);
// 访问局部变量,JDK1.7要求:变量必须是常量final jdk1.8自动添加 final
System.out.println(address);
}
}
// 创建局部内部类对象 调用内部方法
Inner inner = new Inner();
inner.show1();
}
}
public class Test {
public static void main(String[] args) {
Demo03 demo03 = new Demo03();
//创建外部类 调用内部方法
demo03.show();
}
}
匿名内部类
- 没有类名的局部内部类(一切特征和局部内部类相同)
- 必须继承一个父类或实现一个接口
- 定义类、实现类、创建对象的语法合并、只能创建一个该类的对象
- 优点:减少代码量 缺点: 可读性较差
public class Test {
public static void main(String[] args) {
// //创建接口类型的变量
// Demo04 demo04 = new Demo05();
// demo04.service();
// //局部内部类 实现接口
// class Fun implements Demo04{
// @Override
// public void service() {
// System.out.println("连接电脑,fun起来");
// }
// }
// //使用局部内部类创建对象
// Demo04 demo004 = new Fun();
// demo004.service();
//
//使用匿名内部类 (相当于创建了一个局部内部类)
Demo04 demo004 = new Demo04() {
@Override
public void service() {
System.out.println("连接电脑,fun起来,匿名");
}
};
demo004.service();
}
}
public class Demo05 implements Demo04{
@Override
public void service() {
System.out.println("连接成功");
}
}
//接口
public interface Demo04 {
//服务
void service();
}
Object类
- 超类、基类、所有类的直接或间接父类、位于继承树的最顶层
- 任何类,如果没有书写 extends 显示继承某个类,都默认直接继承Object类,否则为间接继承。
- Object 类中所定义的方法,是所有对象都具备的方法
- Obejct类型可以存储任何对象
- 作为参数,可接收任何对象
- 作为返回值们可以返回任何对象
Object类常用方法
getClass()方法
- public final Class<?> getClass(){}
- 返回引用存储的实际对象类型
- 应用:通常判断两个引用中实际存储对象类型是否一致
public class Test {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",50);
//判断s1 和 s2是不是同一类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
if (class1 == class2){
System.out.println("类型相同");
}else {
System.out.println("类型不同");
}
}
}
hashCode()方法
- public int hashCode()
- 返回该对象的哈希码值
- 哈希值根据 对象的地址 或 字符串 或 数字 使用hash算法计算出来的 int 类型的数值
- 一般情况下 相同对象返回相同哈希码
public class Test {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",50);
System.out.println(s1.hashCode());//356573597
System.out.println(s2.hashCode());//1735600054
Student s3=s1;
System.out.println(s3.hashCode());//356573597
}
}
toString()方法
- public String toString(){}
- 返回该对象的字符串表示(表现形式)
- 可以根据程序需求覆盖该方法,如:展示对象各个属性值
public class Test {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",50);
//toString 方法
System.out.println(s1.toString());//com.normalclass.Student@1540e19d
System.out.println("--------------");
System.out.println(s2.toString());//com.normalclass.Student@677327b6
//包 + 哈希值
//重写方法
}
}
// public String toString() {
// return name + ":" + age;
// }
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
equals() 方法
- public boolean equals(Object obj){}
- 默认实现为(this == obj),比较两个对象地址是否相同
- 可进行覆盖,比较两个对象的内容是否相同
equals()方法覆盖步骤
- 比较两个引用是否指向同一个对象
- 判断obj 是否为null
- 判断两个引用指向的实际对象类型是否一致
- 强制类型转换
- 依次比较各个属性值是否相同
@Override
public boolean equals(Object o) {
if (this == o) return true; // 1. 判断两个对象是否是同一个引用
//判断obj是否null 判断是否是同一个类型
if (o == null || getClass() != o.getClass()) return false;
//强制类型转换
Student student = (Student) o;
//比较两对象的指是否相同
return age == student.age &&
Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
public class Test {
public static void main(String[] args) {
Student s1 = new Student("aaa",20);
Student s2 = new Student("bbb",50);
Student s3 = new Student("xiaoming",17);
Student s4 = new Student("xiaoming",17);
//equals 方法,判断两个对象是否相等
System.out.println(s1.equals(s2));//false
System.out.println(s3.equals(s4));//false 对象地址还是不一样
// 判断 参数相同的判断 equals 可以重写
}
}
finalize()方法
- 当对象被判定为垃圾对象时,由JVM自动调用此方法,用以标记垃圾对象,进入回收队列
- 垃圾对象:没有有效引用指向此对象时,为垃圾对象
- 垃圾回收:由GC销毁垃圾对象,释放数据存储空间
- 自动回收机制:JVM的内存耗尽,一次性回收所有垃圾对象
- 手动回收机制: 使用System.gc(); 通知JVM执行垃圾回收
public class Test {
public static void main(String[] args) {
// Student s1 = new Student("aaa",20);
// Student s2 = new Student("bbb",50);
// Student s3 = new Student("xiaoming",17);
// Student s4 = new Student("xiaoming",17);
new Student("aaa", 20);
new Student("bbb", 50);
new Student("xiaoming", 17);
new Student("xiaoming", 17);
//回收垃圾
System.gc();
System.out.println("回收垃圾");
// xiaoming回收了
// xiaoming回收了
// bbb回收了
// aaa回收了
}
}
@Override
protected void finalize() throws Throwable {
System.out.println(this.name + "回收了");
}
包装类
- 基本数据类型所对应的引用数据类型
- Object 可统一所有数据,包装类的默认值是null
基本数据类型 | 包装类型 |
---|---|
byte | Byte |
b | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
boolean | Boolean |
char | Character |
类型转换与装箱,拆箱
public class Demo06 {
public static void main(String[] args) {
int num = 10;
//JDK1.5 之前
//类型转换: 装箱,基本类型转成引用类型的过程
// 基本类型
//使用 Integer 类创建对象
Integer integer1 = new Integer(num);
Integer integer2 =Integer.valueOf(num);
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);
//JDK1.5 之后 自动装箱和拆箱
int age = 60;
//自动装箱
Integer integer4 = age;
System.out.println("自动装箱");
System.out.println(integer4);
//自动拆箱
int age2 = integer4;
System.out.println("自动拆箱");
System.out.println(age2);
}
}
- 8种包装类提供不同类型间的转换形式
- Number父类种提供六个共性方法
- parseXXX()静态方法
- valueOf() 静态方法
public class Demo06 {
public static void main(String[] args) {
//基本类型和字符串之间转换
//1. 基本类型转换成字符串
int n1 = 15;
//1.1 使用 + 号
String s1 = n1 + "";
//1.2 使用Integer 的toString()方法
String s2 = Integer.toString(n1, 16);
System.out.println(Integer.toHexString(n1));
System.out.println(s1);
System.out.println(s2);
//字符串转成基本类型
String str = "150";
//使用Integer.parseXXX();
int n2 = Integer.parseInt(str);//字符串转数字
System.out.println(n2);
//boolean字符串形式壮成基本类型 “true”->true 非"true"->
String str2 = "true";
boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1);
}
}
注意:需要保证类型兼容,否则抛出NumberFormatExeption 异常
整数缓冲区
- Java预先创建了256个常用的整数包装类型对象
- 在实际应用当中,对已创建的对象进行复用
String 类
- 字符串是常量,创建之后不可以改变
- 字符串字面值存储在字符串池中,可以共享
- String s = “Hello”; 产生一个对象,字符串中存储
- Sting s = new String(“Hello”); //产生两个对象,堆、各存储一个
public class Demo08 {
public static void main(String[] args) {
String name = "hello";//hello 常量存储再字符串池中
name = "zhangsan"; // 赋给 name 给字符串赋值时,没有修改数据,而是重新开辟空间
String name2 = "zhangsan"; // 指向字符串池中 同一个 字符串
//演示字符串的另一种创建方式
String str = new String("java");
String str1 = new String("java");
System.out.println(str == str1); //false
System.out.println(str.equals(str1));//true
}
}
常用方法
- public int length() 返回字符串长度
- public char charAt (int index) 根据下标获取字符
- public boolean contains(String str) 判断当前字符串中是否包含str
//length() 返回字符串的长度
//charAt(int index) 返回某个位置的字符
//contains(String str) 判断是否包含某个字符串
String content = "java the best language";
System.out.println(content.length()); //22 一个空格也是一个字符
System.out.println(content.charAt(10));//某个位置的字符
System.out.println(content.contains("java"));
- public char[] toCharArray(): 将字符串转换为数组
- public int indexOf (String str): 查找str 首次出现的下标,存在,则返回该下标;不存在,则返回-1
- public int lastIndexOf(String str): 查找字符串在当前字符串中最后一次出现的下标索引
//toCharArray(): 将字符串转换为数组
//indexOf (String str): 查找str 首次出现的下标
//lastIndexOf(String str): 查找字符串在当前字符串中最后一次出现的下标索引
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java",5));
System.out.println(content.lastIndexOf("java"));
- public String trim() 去掉字符串前后的空格
- public String toUpperCase() 将小写转成大写
- public boolean endWith(String str) 判断字符串是否以str 结尾
//trim() 去掉字符串前后的空格
//toUpperCase() 将小写转成大写 toLowerCase()将大写转成小写
//endWith(String str) 判断字符串是否以str 结尾
//starWith(String 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"));//true
System.out.println(filename.startsWith("hello"));//true
- public String replace(char oldChar,char newChar): 将旧字符串替换成新字符串
- public String[] split(String str): 根据str 做拆分
//equals()\compareTo() 比较大小、比较大小
System.out.println("*********************");
String ss = "hello";
String sa = "Hello";
System.out.println(ss.equals(sa)); // false
System.out.println(ss.equalsIgnoreCase(sa)); // true 忽略大小写比较
//compare() 比较编码的位置
String s3 = "abc";
String s4 = "qwe";
System.out.println(s3.compareTo(s4)); //s3 的首字母 减去 s4 首字母
String s5 = "abc";
String s6 = "abcdefg";
//如果字符一样 比较字符的长度,前面的字符串长度减去后面字符串的长度
System.out.println(s5.compareTo(s6)); //-4
System.out.println(s6.compareTo(s5)); //4
String 实例
- 需求:
- 已知String str = “this is a text”;
-
- 将str中的单词单独获取出来
- 将str 中的text替换为practice
- 在text前面插入一个easy
- 将每个单词的首字母改为大写
public class Demo09 {
public static void main(String[] args) {
String str = "this is a text";
String[] arr = str.split(" ");
// 每个单词 单独输出
for (String s : arr){
// 遍历
System.out.println(s);
}
// str 中的text 替换 成 practice
System.out.println("-----2-----");
String str2 = str.replace("text","practice");
System.out.println(str2);
// 在 text 前面 加一个 easy 将 text 替换成 easy text
System.out.println("-----3-------");
String str3 = str.replace("text","easy text");
System.out.println(str3);
// 每个单词的首字母 改为大写, 根据第一步的分割 拿到每个字母的数组
System.out.println("-------4------");
for (int i = 0;i<arr.length;i++){
// 拿到每一个单词的 第一个字母
char first = arr[i].charAt(0);
// 字符变大写
char upperfirst = Character.toUpperCase(first);
// subString 替换(开始位置,结束位置)
String news = upperfirst + arr[i].substring(1);
System.out.println(news);
}
}
}
可变字符串
- StringBuffer: 可变长字符串,运行效率慢,线程安全(都比 string更快)
- StringBuilder: 可变长字符串,运行效率快,线程不安全
方法和效率比较
/**
* stringbuffer 和 stringbuilder 之间的区别
* 区别 1. 效率比string 会更高,更节省内存
*/
public class Demo10 {
public static void main(String[] args) {
// stringbuffer 和 stringbuilder 功能介绍(功能相同)
StringBuffer sb = new StringBuffer();
// 1. append(); 追加
sb.append("Java no.1");
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.reverse();
// System.out.println(sb);
// 6. 清空 操作 0 - str.length
sb.delete(0, sb.length());
// 清空 整个 stringbuffer
// 推荐使用stringbuilder
/**
* 验证 stringbuilder 高于 stringbuffer 的效率
*/
// 获得一个开始时间
long star = System.currentTimeMillis();
String string = "";
for (int i = 0; i < 9999; i++) {
// 字符串拼接
string+=i;
}
System.out.println(string);
long end = System.currentTimeMillis();
System.out.println("用时: "+ (end - star));
//用时 421
// stringbuilder 效率
star = System.currentTimeMillis();
StringBuilder sbb = new StringBuilder();
for (int i = 0; i < 9999; i++) {
// 字符串拼接
sbb.append(i);
}
System.out.println(sbb.toString());
end = System.currentTimeMillis();
System.out.println("用时: "+ (end - star));
//用时 16
}
}
BigDecimal类
- 位置: java.math 包中
- 作用:精确计算浮点数
- 创建方式: BigDecimal bd = new BigDecimal(“1.0”)
public class Demo11 {
public static void main(String[] args) {
// BigDecimal 类
double d1 = 1.0;
double d2 = 0.5;
System.out.println(d1 - d2);
//double 存储的是近似值,运算是会存在误差的
//BigDecimal 大的浮点数精确计算
BigDecimal bd1 = new BigDecimal("1.0"); //创建使用字符串
BigDecimal bd2 = new BigDecimal("0.9");
//创建使用字符串 转化后 更加准确
//类不能直接只用运算符 对应类,使用方法运算
//减法
BigDecimal re1 = bd1.subtract(bd2);
// 实现精确计算
System.out.println(re1);
//加法
BigDecimal re2 = bd1.add(bd2);
System.out.println(re2);
//乘法
BigDecimal re3 = bd1.multiply(bd2);
System.out.println(re3);
//除法 如果结果是除不尽的话,会报告异常
BigDecimal re4 = bd1.divide(bd2,2,BigDecimal.ROUND_HALF_UP);
// 保留两位小数 四舍五入
/**
* 参数 scal 指定精确到小数点后几位
* 参数 mode 指定小数部分的取舍模式,通常采用四舍五入的模式
* 取值为BigDecimal.ROUND_HALF_UP
*/
System.out.println(re4);
}
}
Date类
过时的方法~
- Date 表示特定的瞬间,精确到毫秒,Date类 大部分方法都被Calendar类中的方法所取代
public class Demo12 {
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));
// 2.方法 after before 判断两个日期顺序,返回布尔值
boolean f1 = date1.after(date2);
System.out.println(f1);
// 3. 比较 compareTo(); 返回int 相差的天数
int d = date1.compareTo(date2);
System.out.println(d);
//equals(); 比较是否相等
}
}
Calendar类
勤查API 查看方法
- Calender 提供了获取或设置各种日历字段的方法
- 构造方法
- protected() Calender() : 由于修饰符是protected 所以无法直接创建该对象
- 其他常用方法使用
public class Demo13 {
public static void main(String[] args) {
// 1. 创建 Calender 对象 因为受保护的,无法直接new 一个对象
// 使用 getInstance
Calendar calendar = Calendar.getInstance();
// 打印时间
System.out.println(calendar.getTime());
System.out.println(calendar.getTimeInMillis());
//2. 获取时间信息
// 获取 年
int year = calendar.get(Calendar.YEAR);
// 月 返回的是 0-11
int month = calendar.get(Calendar.MONTH);
// 日
int day = calendar.get(Calendar.DAY_OF_MONTH);
// 小时
int hour = calendar.get(Calendar.HOUR_OF_DAY);
// HOUR 12小时 HOUR_OF_DAY 24小时
// 分钟
int minute = calendar.get(Calendar.MINUTE);
// 秒
int second = calendar.get(Calendar.SECOND);
System.out.println(year + "年" + (month + 1) + "月" + day + "日" + hour + ":" + minute + ":" + second);
// 2020年10月21日11:46:23
//修改时间 .set
Calendar calendar2 = Calendar.getInstance();
calendar2.set(Calendar.DAY_OF_MONTH, 20);//修改日期
System.out.println(calendar2.getTime().toLocaleString());
//add 方法 修改时间
// 增加一个小时
calendar2.add(Calendar.HOUR,1);
System.out.println("增加一个小时 add方法");
System.out.println(calendar2.getTime().toLocaleString());
// 补充方法
// getactualmaximum 获取当月的最大天 或者 最小天
int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH);
int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH);
// 当月最多 31 天
System.out.println(max);
// 当月最少 1 天
System.out.println(min);
}
}
SimpleDateFormat类
- SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类
- 进行格式化(日期-》文本)解析(文本-》日期)
字母 | 日期或时间 | 示例 |
---|---|---|
y | 年 | 2019 |
M | 年中月份 | 08 |
d | 月中天数 | 10 |
H | 1天中小时数(0-23) | 22 |
m | 分钟 | 16 |
s | 秒 | 89 |
S | 毫秒 | 367 |
public class Demo14 {
public static void main(String[] args) throws Exception{
// 1. 创建一个simpledateformat 对象 pattern 指定时间格式 输出
// simpledateformat 类似一种加工厂 将输入的时间 date 转换成指定的pattern格式输出
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH-mm-ss");
// 2. 创建date
Date date = new Date();
// 格式化 date format -> data 放入 string 存放
// 把日期 转成 字符串
String str = sdf.format(date);
System.out.println(str);
//2020年10月21日19:05:22
// 解析(把字符串转化成日期) 没有按照给定的parse格式,会抛出异常
Date date2 = sdf.parse("1990/05/01");
System.out.println(date2);
}
}
System类
- System 系统类,主要用于获取系统的属性数据和其他操作,构造方法私有的
public class Demo15 {
public static void main(String[] args) {
/**
* system 类的演示 使用,方法是私有的,使用的时候不需要创建对象,直接使用
* arraycopy 数组的复制
* 参数: src:源数组
* srcPos: 从哪个位置开始复制,默认为0
* dest: 目标数组
* destPos: 目标数组的位置
* length: 复制的长度
*/
int [] arr = {20,18,15,8,25,48,90,1};
int [] dest = new int[8];
// 可对应调整参数
System.arraycopy(arr,0,dest,0,arr.length);
for (int i = 0; i <dest.length ; i++) {
System.out.println(dest[i]);
}
//对比 Arrays.copyof 里面的源码 就是通过 system.arrycopy实现的
// 记录当前的时间 毫秒 计算运行的时间
System.out.println(System.currentTimeMillis());
// System.gc(); 告诉垃圾回收器 回收,干预对象的内存回收,三个对应情况下的垃圾回收,还是系统判断
//退出JVM 程序正常后退出
System.exit(0);
//程序到这儿 就结束了 status: 参数是0 正常退出JVM 非0表示异常退出JVM
}
}
总结
- 内部类
- 在一个类的内部再定义一个完整的类
- 成员内部类,静态内部类,局部内部类,匿名内部类
- Object类:
- 所有类的直接或间接父类,可存储任何对象
- 包装类
- 基本数据类型所对应的应用数据类型,可以使Object统一所有数据
- String类
- 字符串是常量,创建之后不可改变,字面值保存在字符串池中,可以共享
- BigDecimal:
- 可精确计算浮点数
- Date
- 特定时间
- Calender
- 日历
- SimpleDateFormat
- 格式化时间
- System
- 系统类