Java常用类笔记总结

常用类笔记总结"/>

Java常用类笔记总结

1. 内部类

（1）内部类的分类

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

（2）内部类概念

• **概念：**在一个类的内部再定义一个完整的类。

• 特点：

  • 编译之后可生成独立的字节码文件
  • 内部类可直接访问外部类的私有成员，而不破坏封装
  • 可为外部类提供必要的内部功能组件

（3）成员内部类

• 在类的内部定义，与实例变量、实例方法同级别的类

• 外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象

  Outer out = new Outer();
  Outer.Inner in = out.new Inner();
  

//一步到位
Inner inner = new Outer().new Inner();

• 当外部类、内部类存在同名属性时，会优先访问内部类属性。

  此时要访问外部类属性，需要外部类名字.this.属性

  Outer.this.name
  

• 成员内部类不能定义静态成员。但可以定义静态常量

  package com.dflmonclass.demo01;//外部类
  public class Outer {//实例变量private String name = "董方龙";private int age = 22;//内部类class Inner{private String address = "武汉";private String phone = "0853";//方法public void show(){//打印外部类的属性System.out.println(name);System.out.println(age);//打印内部类中的属性System.out.println(address);System.out.println(phone);}}
  }
  //========================================================
  package com.dflmonclass.demo01;public class TestOuter {public static void main(String[] args) {//创建一个外部类对象Outer outer = new Outer();//创建内部类对象Outer.Inner inner = outer.new Inner();inner.show();}
  }
  

（4）静态内部类

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。

package com.dflmonclass.demo02;public class Outer {private String name = "dfl";private int age = 21;//静态内部类,外部类相同级别static class Inner{private String address = "广州";private String phone = "177";//静态成员private static int count = 1000;public void show(){//调用外部类的属性//1.先创建外部类对象Outer outer = new Outer();//2.调用外部类对象的属性System.out.println(outer.name);System.out.println(outer.age);//3.调用静态内部类的属性和方法System.out.println(address);System.out.println(phone);//4.调用静态内部类的静态属性System.out.println(Inner.count);}}
}
//=====================================================
package com.dflmonclass.demo02;public class TestOuter {public static void main(String[] args) {//直接创建静态内部类对象Outer.Inner inner = new Outer.Inner();//调用方法inner.show();}
}

只有内部类才可以使用static修饰

（5）局部内部类

• 定义在外部类的方法中，作用范围和创建对象范围仅限于当前方法。

• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的声明周期与自身相同，变量必须修饰为final

• 限制类的使用范围

  package com.dflmonclass.demo03;public class Outer {private String name = "刘德华";private int age = 35;public void show(){//定义局部变量String address ="深圳";//局部内部类：不能加任何访问修饰符class Inner{private String phone = "17740500853";private String email = "google";public void show2(){//访问外部类的属性System.out.println(name);System.out.println(age);//访问内部类的属性System.out.println(phone);System.out.println(email);//访问局部变量,jdk1.7要求变量必须是final，jdk1.8自动添加finalSystem.out.println(address);}}//创建局部内部类对象Inner inner = new Inner();inner.show2();}
  }
  //===============================================================
  package com.dflmonclass.demo03;public class TestOuter {public static void main(String[] args) {Outer outer = new Outer();outer.show();}
  }
  

（6）匿名内部类

• 没有类名的局部内部类（一切特征都与局部内部类相同）
• 必须继承一个父类或者实现一个接口
• 定义类、实现类、创建对象的语法合并，只能创建一个该类的对象
• 优点：减少代码量
• 缺点：可读性较差

package com.dflmonclass.demo04;public interface USB {void service();//服务
}
//=============================================
package com.dflmonclass.demo04;public class TestUSB {public static void main(String[] args) {//创建接口类的变量/*USB usb = new Mouse();usb.service();*///局部内部类/*      class Fan implements USB{@Overridepublic void service() {System.out.println("连接电脑成功，风扇开始工作了。。。。");}}//使用局部内部类创建对象USB usb = new Fan();usb.service();*///使用匿名内部类优化(接口不能实例化，相当于创建了一个局部内部类)USB usb = new USB() {@Overridepublic void service() {System.out.println("连接电脑成功，风扇开始工作了。。。。");}};usb.service();}}

2. Object类

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写extends显示继承某个类，都默认继承Object类，否则为间接继承。
• Object类中定义的方法，是所有对象都具备的方法
• Object类型可以存储任何对象
  • 作为参数，可接受任何对象
  • 作为返回值，可返回任何对象

3. Object类常用方法

（1）getClass() 方法

public final Class<?> getClass(){}

返回引用中存储的实际对象类型。

应用：通常用于判断两个引用中实际存储类型是否一致

（2）hashCode() 方法

• public int hashCode(){}

• 返回该对象的哈希码值

• 哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的数值

• 一般情况下形同对象返回相同哈希码值

• //hashCode方法System.out.println(s1.hashCode());System.out.println(s2.hashCode());Student s3 = s1;System.out.println(s3.hashCode());
  //s3和s1哈希值相同
  /*
  460141958
  1163157884
  460141958
  */
  //重写
  @Overridepublic int hashCode() {return Objects.hash(name, age);}
  

（3）toString() 方法

• public String toString（）{}

• 返回该对象的字符串表示（表现形式）

• 可以根据程序需求覆盖该方法，如：展示对象各个属性值

• //3.toString方法System.out.println("--------------------3.toString------------------");System.out.println(s1.toString());System.out.println(s2.toString());
  /*输出结果：
  com.dflmonclass.Object.demo01.Student@1b6d3586
  com.dflmonclass.Object.demo01.Student@4554617c
  */
  //可以重写
  @Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
  

（4）equals() 方法

public boolean equals(Object obj) {return (this == obj);}

比较两个对象地址是否相同。

//4.equals方法System.out.println("--------------4.equals------------------");System.out.println(s1.equals(s2));System.out.println(s1.equals(s3));

可进行覆盖，比较两个对象的内容是否相同

equals()方法覆盖步骤

• 比较两个引用是否指向同一个对象

• 判断obj是否为null

• 判断两个引用指向的实际对象类型是否一致

• 强制类型转换

• 依次比较各个属性值是否相同。

  @Overridepublic boolean equals(Object o) {if (this == o) return true;if (o == null || getClass() != o.getClass()) return false;Student student = (Student) o;return age == student.age && Objects.equals(name, student.name);}
  

（5）finalize() 方法

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象,进入回收队列。

• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。

• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。

• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。

• 手动回收机制：使用System.gc()；通知JVM执行垃圾回收。

  public class TestStudent2 {public static void main(String[] args) {/*Student s1 = new Student("aaa",20);Student s2 = new Student("bbb",20);Student s3 = new Student("ccc",20);Student s4 = new Student("ddd",20);Student s5 = new Student("eee",20);*/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("回收垃圾");}
  }
  /*
  回收垃圾
  eee对象被回收了
  ddd对象被回收了
  ccc对象被回收了
  bbb对象被回收了
  aaa对象被回收了
  */
  

4. 包装类

Java Platform Standard Edition

（1）什么是包装类？

基本数据类型所对应的引用数据类型

Object可统一所有的数据，包装类的默认值是null

基本数据类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
boolean	Boolean
char	Character

（2）类型转换与装箱、拆箱

• 装箱：自动将基本数据类型转换为包装器类型；

• 拆箱：自动将包装器类型转换为基本数据类型。

• package com.dflmonclass.packaged.demo01;public class Demo01 {public static void main(String[] args) {//int num=10;//类型转换：装箱，基本类型转换为引用类型的过程//基本类型int num1 = 18;//使用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);//JDK1.5之后，提供自动装箱和拆箱int age = 30;//自动装箱Integer integer4 = age;System.out.println("---------自动装箱-----------");System.out.println(integer4);//自动拆箱int age2 = integer4;System.out.println("---------自动拆箱-----------");System.out.println(age2);}
  }
  

8种包装类提供不同类型间的转换方式：

• Number父类中提供的6个共性方法
• parseXXX（）静态方法
• valueOF（）静态方法

注意：需保持类型兼容，否则抛出NumberFormatException异常。

//接本类型和字符串之间转换//1.基本类型转换为字符串int n1 = 100;//1.1使用+号String s1 = n1 + "";//1.2使用Integer中的toString()方法String s2 = Integer.toString(n1,16);  //fSystem.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"--->falseString str2 = "true";boolean b1 = Boolean.parseBoolean(str2);System.out.println(b1);

（3）整数缓冲区

• Java预先创建了256个常用的整数包装类型对象

• 在实际应用当中，对已创建的对象进行复用

• public class Demo02 {public static void main(String[] args) {//面试题Integer inter1 = new Integer(100);Integer inter2 = new Integer(100);System.out.println(inter1==inter2);//结果为：falseInteger integer3=100;      //自动装箱Integer integer4=100;//调用的语句：Integer integer3=Integer.valueOf(100);System.out.println(integer3==integer4);//结果为：trueInteger integer5=200;      //自动装箱Integer integer6=200;//调用的语句：Integer integer5=Integer.valueOf(200);//valueOfSystem.out.println(integer5==integer6);//结果为：false//在通过valueOf方法创建Integer对象的时候，如果数值在[-128,127]之间，//便返回指向IntegerCache.cache中已经存在的对象的引用；否则创建一个新的Integer对象。}
  }

5. String类

（1）String概述

• 字符串是常量，创建之后不可改变

• 字符串字面值存储在字符串池中，可以共享

• String s = “Hello”;产生一个对象，字符串池中存储

• String s = new String(“Hello”);//产生两个对象，堆、池各存储一个

  • 堆和方法区（字符串池）各有一个“Hello”对象，但是栈里的s指向堆里的·“Hello”

  String str = new String("java");
  String str2 = new String("java");
  System.out.println(str==str2);   //false  地址
  System.out.println(str.euqals(str2)); //true  数据
  

（2）常用方法

• 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（）将小写转成大写

• public boolean endWith（String str）：判断字符串是否以str结尾

• public String replace（char oldChar,char newChar）;将旧字符串替换成新字符串

• public String[] split(String str):根据str做拆分

  package com.dflmonclass.String;import java.util.Arrays;
  import java.util.Locale;public class Demo03 {public static void main(String[] args) {String name = "hello";name = "张三";System.out.println("--------字符串方法的使用1--------");//字符串方法的使用//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("--------字符串方法的使用2--------");//字符串方法的使用//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("--------字符串方法的使用3--------");//7.trim();去掉字符串前后的空格//8.toUpperCase();把小写转成大写      toLowerCase()把大写转成小写//9.endWith(str);判断是否以str结尾    StartWith(str);判断是否以str开头String comtent2 = "     hello world       ";System.out.println(comtent2.trim());System.out.println(comtent2.toUpperCase());System.out.println(comtent2.toLowerCase());String filename = "hello.java";System.out.println(filename.endsWith(".java"));System.out.println(filename.startsWith("hello."));System.out.println("--------字符串方法的使用3--------");//10.replace(char old,char new);用芯替旧//11.split();拆分System.out.println(content.replace("java","php"));String say = "java  is the,best programing language ,123";String[] arr = say.split("[ ,]+");System.out.println(arr.length);for (String string : arr) {System.out.println(string);}//补充两个方法equals、compareTo();比较大小String s1 = "hello";String s2 = "HELLO";System.out.println(s1.equals(s2));System.out.println(s1.equalsIgnoreCase(s2));String s3 = "abc";   //97String s4 = "xyz";   //120System.out.println(s3pareTo(s4));     //-23String s5 = "abcxyz";System.out.println(s3pareTo(s5));     //此时比较长度 -3}
  }

（3）案例

需求：

• 已知String str = “this is a text”
  1. 将str中的单次单独提取出来
  2. 将str2中的text替换为practice
  3. 在text前插入一个easy
  4. 将每个单次的首字母改为大写

package com.dflmonclass.String;
/***@ClassName: Demo04*@Description*@Author 董方龙*@Date*@Time 19:36** **需求：**** - 已知String str = "this is a text"*   1. 将str中的单次单独提取出来*   2. 将str2中的text替换为practice*   3. 在text前插入一个easy*   4. 将每个单次的首字母改为大写*/public class Demo04 {public static void main(String[] args) {String str ="this is a text";//1.将str中的单次单独获取出来String[] arr = str.split(" ");System.out.println("------将str中的单次单独获取出来------");for (String s :arr) {System.out.println(s);}//2.将str的text替换为practiceString str2 = str.replace("text","practice");System.out.println(str2);//3.在text前面插入一个easySystem.out.println("------3.在text前面插入一个easy------");String str3 = str.replace("text","easy text");System.out.println(str3);//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.println(news);}}
}

（4）可变字符串

• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢，线程安全。

• StringBuilder：可变长字符串，JDK5.0提供，运行效率快，线程不安全（单线程用）

  package com.dflmonclass.String;
  /***@ClassName: Demo05*@Description StringBuffer 和 StringBuilder的使用* 和String区别 （1）效率比String高  （2）比String节省内存*@Author 董方龙*@Date*@Time 20:02*/
  public class Demo05 {public static void main(String[] args) {StringBuffer stringBuffer = new StringBuffer();System.out.println(stringBuffer.toString());//1.append();追加stringBuffer.append("java世界第一");System.out.println(stringBuffer.toString());stringBuffer.append("java真香");System.out.println(stringBuffer.toString());stringBuffer.append("java不错");System.out.println(stringBuffer.toString());//2.insert();添加stringBuffer.insert(0,"我在最前面");System.out.println(stringBuffer.toString());//3.replace();stringBuffer.replace(0,5,"hello");System.out.println(stringBuffer.toString());//4.delete();删除stringBuffer.delete(0,5);System.out.println(stringBuffer.toString());//清空·stringBuffer.delete(0,stringBuffer.length());System.out.println(stringBuffer.toString());}
  }
  

  package com.dflmonclass.String;/***@ClassName: Demo06*@Description 验证StringBuilder效率高于String*@Author 董方龙*@Date*@Time 20:44*/
  public class Demo06 {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);*/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));}
  }
  

6. Bigdecimal类

（1）思考

package com.dflmonclass.bigdecimal;public class Demo07 {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

Bigdecimal类精度更高

（2）概述

位置：java.math包中

作用：精确计算浮点数

创建方式：BigDecimal bd = new BigDecimal(“1.0”);

package com.dflmonclass.bigdecimal;import java.math.BigDecimal;public class Demo07 {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);//BigDecimalBigDecimal 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);//除法BigDecimal r4 = new BigDecimal("1.4").subtract(new BigDecimal("0.5")).divide(new BigDecimal("0.9"));System.out.println(r4);BigDecimal r5 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);//保留两位小数，四舍五入System.out.println(r5);}
}

除法：divide（BigDecimal bd , int scal , RoundingMode mode）

参数scal：指定精确到小数点后几位

参数mode：

• ​ 指定小数点后的取舍模式，通常采用四舍五入的模式
• ​ 取值为BigDecimal.ROUND_HALF_UP

7. Date类

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代
• 时间单位
  • 1秒 = 1000毫秒
  • 1毫秒 = 1000微秒
  • 1微秒 = 1000纳秒

package com.dflmonclass.date;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 和 beforeboolean b1 = date1.after(date2);System.out.println(b1);boolean b2 = date1.before(date2);System.out.println(b2);//比较compareTo();int d = date1pareTo(date2);System.out.println(d);int e = date1pareTo(date1);System.out.println(e);int f = date2pareTo(date1);System.out.println(f);//比较是否相等equals();boolean g =date1.equals(date2);System.out.println(g);}
}

8.SimpleDateFormat

• SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类

• 进行格式化（日期 –> 文本）、解析（文本 –> 日期）

• 常用的时间模式字母

  字母	日期或时间	示例
  y	年	2019
  M	年中月份	08
  d	月中天数	10
  H	1天中小时数（0-23）	22
  m	分钟	16
  s	秒	59
  S	毫秒	367

  package com.dflmonclass.simpleDateFormat;import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;public class Demo07 {public static void main(String[] args) throws ParseException {//1.创建SimpleDateFormat对象 y年 M月//SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");//2.创建DateDate date = new Date();//格式化Date()把日期转换成字符串String str = sdf.format(date);System.out.println(str);//解析(把字符串转换成日期)Date date2 = sdf.parse("2000/06/04");System.out.println(date2);}}
  

9. System类

• System系统类，主要用于获取系统的属性数据和其他操作，构造方法私有的。

方法名	说明
static void arraycopy(…)	复制数组
static long currentTimeMills();	获取当前系统时间，返回的是毫秒值
static void gc();	建议JVM赶快启动垃圾回收机制
static void exit (int status)	退出JVM，如果参数是0表示正常退出jvm，非0表示异常退出jvm

package com.dflmonclass.system;public class Demo08 {public static void main(String[] args) {//arraycopy:数组的复制//src:源数组//srcPos:从哪个位置开始复制 0//dest:目标数组//destPos:目标数组的位置//length:复制的长度int[] arr = {20,18,15,8,35,26,45,90};int[] dst = new int[8];System.arraycopy(arr,4,dst,0,2);for (int i = 0; i < dst.length; i++) {System.out.print(dst[i]+"  ");}//Arrays.copyOf(original,newLength)System.out.println(System.currentTimeMillis());long start = System.currentTimeMillis();for (int i = 0; i < 999999999; i++) {for (int j = 0; j < 999999; j++) {int result = i+j;}}long end = System.currentTimeMillis();System.out.println("用时："+(end-start));Student s1 = new Student("aaa",18);Student s2 = new Student("bbb",18);Student s3 = new Student("ccc",18);System.gc();  //告诉垃圾回收期回收new Student("a",7);new Student("b",8);new Student("c",9);System.gc();  //告诉垃圾回收期回收/*输出回收了a    7回收了b    8回收了c    9*/System.exit(0);System.out.println("程序结束了");  //这条语句没有执行}
}
//=====================================================================
package com.dflmonclass.system;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;}@Overridepublic String toString() {return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';}@Overrideprotected void finalize() throws Throwable {System.out.println("回收了"+name+"    "+age);}
}

10.总结

• 内部类：

  • 在一个类的内部再定义一个类
  • 成员内部类、静态内部类、局部内部类、匿名内部类

• Object类：

  • 所有类的直接或间接父类，可存储任何对象

• 包装类：

  • 基本数据类型所对应的引用数据类型，可以使用Object统一所有数据

• String类：

  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。

• BigDecimal：

  • 可精确计算浮点数。

• Date

  • 特定时间

• Calendar

  • 日历

• SimpleDateFormat

  • 格式化时间

• System

  • 系统类

码字不易，请大家点赞关注一下，一起进步嗷！