Java的八大常用类

1.内部类

• 内部类就是在一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

1. 成员内部类

   成员内部类：类比成员方法，不能拥有静态域但是可以访问外部类的静态域

   示例

   package com.oop.demo09;public class Outer {private int id=10;public void out(){System.out.println("这是外部类的方法");}public  class Inner{public void in(){System.out.println("这是内部类的方法");}//获得外部类的私有属性public void getId(){System.out.println(id);}}}//一个java类中可以有多个class类，但是只能有一个public class类
   class A{public static void main(String[] args) {}
   }
   Application：
   package com.oop;import com.oop.demo09.Outer;public class Application {public static void main(String[] args) {//newOuter outer = new Outer();//通过这个外部类来实例化内部类Outer.Inner inner = outer.new Inner();inner.in();}
   }

2. 静态内部类

   定义在外部类的内部，使用static修饰，类比静态方法，静态内部类不需要外部类对象产生就能使用，不能访问外部类的成员域，但能访问静态域

   static int age;
   String name;
   //静态内部类 - 类比静态变量
   static class Inner {public void test(){System.out.println(age);System.out.println(name);}
   }
   

   静态内部类的创建语法：

   1.外部类内部：与成员内部类一样

   2.外部类外部：StaticInnerClass.Inner inner = new StaticInnerClass.Inner();

3. 局部内部类

   定义在方法内部：类比局部变量

   1.对外部完全隐藏，因此方法内部类不能有任何访问修饰符

   2.方法内部类没有访问形参是，这个形参是可以在方法中随意修改的，一旦方法内部类中使用了形参，这个形参必须被声明为final

    //局部内部类public void method(){class Inner{public void in(){}}}
   

4. 匿名内部类

   1.必须继承一个抽象类或者实现一个接口

   2.没有构造方法

   package com.oop.demo09;public class Test {public static void main(String[] args) {//没有名字初始化类,不用将实例保存到变量中new Apple().eat();UserService userService = new UserService() {@Overridepublic void hello() {}};}
   }class Apple{public void eat(){System.out.println("1");}
   }interface UserService{void hello();
   }

内部类的优点

1、每个内部类都能独立的继承一个接口的实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。内部类使得多继承的解决方案变得完整。
2、方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏。
3、方便编写事件驱动程序。
4、方便编写线程代码。

2.Object类

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

• getClass()方法

  public final native Class<?> getClass();
  返回 this 的运行时类。返回的对象是由所表示类的方法锁定的对象。ObjectClassstatic synchronized
  实际结果类型为 Class<？ 扩展|X|>|十|是调用 getClass 的表达式的静态类型的擦除。例如，此代码片段中不需要强制转换：Number n = 0;
  Class<? extends Number> c = n.getClass();返回：
  表示此对象的运行时类的对象。Class
  

  注：此处的native关键字

  使用native关键字修饰的函数(方法)，说明这个方法是原生函数，也就是这个方法是用C/C++语言实现的，并且被编译成了DLL，由java去调用。

  返回引用中存储的实际对象类型（返回一个class类型的值）

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

代码示例：

Student类：
package com.commonclass;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;}
}
Test类：package com.commonclass;public class Test {public static void main(String[] args) {Student s1 = new Student("aaa",20);Student s2 = new Student("bbb", 18);//判断s1和s2是不是同一个类型Class class1 = s1.getClass();Class class2 = s2.getClass();if (class1==class2){System.out.println("s1和s2属于同一类型");}else {System.out.println("s1和s2不属于同一类型");}}
}
运行结果：
s1和s2属于同一类型Process finished with exit code 0

• hashCode方法

  public int hashCode(){}
  

  返回对象的哈希代码值。支持此方法是为了使哈希表（如 HashMap 提供的哈希表）受益。

  总合同是：hashCode

  • 每当在执行 Java 应用程序期间在同一对象上多次调用该方法时，该方法都必须始终返回相同的整数，前提是不修改在对象比较中使用的任何信息。此整数不必从应用程序的一次执行到同一应用程序的另一次执行保持一致。hashCode``equals
  • 如果根据方法，两个对象相等，则在两个对象中的每个对象上调用该方法必须产生相同的整数结果。equals(Object)``hashCode
  • 如果根据 equals（java.lang.Object） 方法，如果两个对象不相等，则不需要在两个对象中的每一个上调用该方法必须生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同的整数结果可能会提高哈希表的性能。hashCode

  尽管合理实用，但类定义的 hashCode 方法确实为不同的对象返回不同的整数。（这通常是通过将对象的内部地址转换为整数来实现的，但 Java™ 编程语言不需要这种实现技术。Object

  • 返回：

    此对象的哈希代码值。

  • 另请参阅：

    equals（java.lang.Object）， System.identityHashCode（java.lang.Object）

小结：（可以当作地址来看但它本质上不是地址）

1. 提高具有哈希结构的容器的效率
2. 两个引用，如果指向的是同一个对象，则哈希值肯定一样
3. 两个引用，如果指向的是不同对象，则哈希值是不一样的
4. 哈希值主要根据地址号来！不能将哈希值完全等价于地址
5. 在后面的集合中hashCode如果需要的话，也会重写

代码示例：

package com.commonclass;public class Test {public static void main(String[] args) {Student s1 = new Student("aaa",20);Student s2 = new Student("bbb", 18);//hashCode方法System.out.println(s1.hashCode());System.out.println(s2.hashCode());Student s3=s1;System.out.println(s3.hashCode());}
}运行结果：
460141958
1163157884
460141958

• toString方法

  public String toString()
  

  返回对象的字符串表示形式。 一般来说， toString方法返回一个“textually代表”这个对象的字符串。 结果应该是一个简明扼要的表达，容易让人阅读。 建议所有子类覆盖此方法。

  该toString类方法Object返回一个由其中的对象是一个实例，该符号字符的类的名称的字符串@` ”和对象的哈希码的无符号的十六进制表示。 换句话说，这个方法返回一个等于下列值的字符串：

   getClass().getName() + '@' + Integer.toHexString(hashCode())
  

  • 结果

    对象的字符串表示形式。

基本介绍：

默认返回：全类名 + @ + 哈希值的十六进制

Object toString()原码//(1)getClass().getName() 类的全类名（包名+类名）//(2)Integer.toHexString(hashCode()) 将hashCode的值转成16进制字符串public String toString() {return getClass().getName() + "@" + Integer.toHexString(hashCode());}

代码示例：

子类往往重写toString方法，用于返回对象的属性信息（​​快捷键：alt + insert​​），当然我们也可以自己定制。
package com.commonclass;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;}@Overridepublic String toString() {return "Student [name=" + name +",age=" +age +"]";}}
测试类：package com.commonclass;public class Test {public static void main(String[] args) {Student s1 = new Student("aaa",20);Student s2 = new Student("bbb", 18);//hashCode方法
//        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());}
}
运行结果：
Student [name=aaa,age=20]
Student [name=bbb,age=18]Process finished with exit code 0

• equals方法

  public boolean equals(Object obj){}
  

  指示一些其他对象是否等于此。

  equals方法在非空对象引用上实现等价关系：

  • 自反性 ：对于任何非空的参考值x ， x.equals(x)应该返回true 。
  • 它是对称的 ：对于任何非空引用值x和y ， x.equals(y)应该返回true当且仅当y.equals(x)回报true 。
  • 传递性 ：对于任何非空引用值x ， y和z ，如果x.equals(y)回报true个y.equals(z)回报true ，然后x.equals(z)应该返回true 。
  • 它是一致的 ：对于任何非空引用值x和y ，多次调用x.equals(y)始终返回true或始终返回false ，没有设置中使用的信息equals比较上的对象被修改。
  • 对于任何非空的参考值x ， x.equals(null)应该返回false 。

  该equals类方法Object实现对象上差别可能性最大的相等关系; 也就是说，对于任何非空的参考值x和y ，当且仅当x和y引用相同的对象（ x == y具有值true ）时，该方法返回true 。

  请注意，无论何时覆盖该方法，通常需要覆盖hashCode方法，以便维护hashCode方法的通用合同，该方法规定相等的对象必须具有相等的哈希码。

  • 参数

    obj - 与之比较的参考对象。

  • 结果

    true如果此对象与obj参数相同; false否则。

  • 另请参见：

    hashCode() ， HashMap

代码示例：

默认判断的是地址是否相等，子类(Object类是所有类的父类)往往重写该方法，用于判断内容是否相等。Object类 equals()方法原码//默认判断地址是否一样public boolean equals(Object obj) {return (this == obj);}子类往往重写该方法，用于判断内容是否相等  String类中的equals()方法原码（重写了父类equals()方法）public boolean equals(Object anObject) {if (this == anObject) { // 如果是同一个对象(地址相同)return true; // 返回true}if (anObject instanceof String) { // 判断类型String anotherString = (String)anObject; // 向下转型int n = value.length;if (n == anotherString.value.length) { // 如果长度相同char v1[] = value;char v2[] = anotherString.value;int i = 0;while (n-- != 0) { // 比较每一个字符if (v1[i] != v2[i])return false;i++;}return true; // 如果两个字符串每一个字符都相同，则返回true}}return false;}

package com.commonclass;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;}@Overridepublic String toString() {return "Student [name=" + name +",age=" +age +"]";}@Overridepublic boolean equals(Object obj) {//1、判断两个对象是否是同一个引用if (this==obj){return true;}//2、判断obj是否为nullif (obj==null){return false;}//3、判断是否是同一类型//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;}
}
测试类：
package com.commonclass;public class Test {public static void main(String[] args) {Student s1 = new Student("aaa",20);Student s2 = new Student("bbb", 18);//hashCode方法
//        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));Student s4 = new Student("小明", 19);Student s5 = new Student("小明", 19);System.out.println(s4.equals(s5));}
}
运行结果：
false
trueProcess finished with exit code 0

• finalize()方法

  protected void finalize()throws Throwable
  

  当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。 一个子类覆盖了处理系统资源或执行其他清理的finalize方法。

  finalize的一般合同是，如果Java¢虚拟机已经确定不再有任何方法可以被任何尚未死亡的线程访问的方法被调用，除非是由于最后确定的其他对象或类的准备工作所采取的行动。 finalize方法可以采取任何行动，包括使此对象再次可用于其他线程; 然而， finalize的通常目的是在对象不可撤销地丢弃之前执行清除动作。 例如，表示输入/输出连接的对象的finalize方法可能会在对象被永久丢弃之前执行显式I / O事务来中断连接。

  所述finalize类的方法Object执行任何特殊操作; 它只是返回正常。 Object的Object可以覆盖此定义。

  Java编程语言不能保证哪个线程将为任何给定的对象调用finalize方法。 但是，确保调用finalize的线程在调用finalize时不会持有任何用户可见的同步锁。 如果finalize方法抛出未捕获的异常，则会忽略该异常，并终止该对象的定类。

  在为对象调用finalize方法之后，在Java虚拟机再次确定不再有任何方式可以通过任何尚未被死亡的线程访问此对象的任何方法的情况下，将采取进一步的操作，包括可能的操作由准备完成的其他对象或类别，此时可以丢弃对象。

  finalize方法从不被任何给定对象的Java虚拟机调用多次。

  finalize方法抛出的任何异常都会导致该对象的终止被停止，否则被忽略。

  • 异常

    Throwable - 这个方法提出的 异常

  • 另请参见：

    WeakReference ， PhantomReference

finzlize方法：当垃圾收集确定不再有对该对象的引用时，垃圾收集器在对象上调用该对象。

1. 当对象被回收时，系统自动调用该对象的finzlize方法。子类可以重写该方法，做一些释放资源的操作
2. 什么时候被回收：当某个对象没有任何引用时，则jvm就认为这个对象是一个垃圾对象，就会时候垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finzlize方法。
3. 垃圾回收机制的调用，是由系统来决定（即有自己的GC算法），也可以通过System.gc()主动触发垃圾回收机制。

注：在实际开发中，几乎不会用finzlize方法，更多的是为了应付面试

代码示例：

package com.commonclass;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;}@Overridepublic String toString() {return "Student [name=" + name +",age=" +age +"]";}@Overridepublic boolean equals(Object obj) {//1、判断两个对象是否是同一个引用if (this==obj){return true;}//2、判断obj是否为nullif (obj==null){return false;}//3、判断是否是同一类型//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;}@Overrideprotected void finalize() throws Throwable {System.out.println(this.name+"对象被回收了");}
}
测试类：
package com.commonclass;public class Test01 {public static void main(String[] args) {//        Student s1 = new Student("aaa", 29);
//        Student s2 = new Student("bbb", 29);
//        Student s3 = new Student("ccc", 29);
//        Student s4 = new Student("ddd", 29);
//        Student s5 = new Student("eee", 29);new Student("aaa", 29);new Student("bbb", 29);new Student("ccc", 29);new Student("ddd", 29);new Student("eee", 29);//回收垃圾System.gc();System.out.println("回收垃圾");}
}
运行结果：
回收垃圾
eee对象被回收了
ddd对象被回收了
ccc对象被回收了
bbb对象被回收了
aaa对象被回收了Process finished with exit code 0

3.包装类

什么是包装类？

• 基本数据类型所对应的引用数据类型。
• 基本类型存在栈空间里
• 包装类是一个引用类型，存放在堆中
• 包装类将基本数据类型包装在一个对象中

基本数据类型以及对应的包装类：

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

包装类的意义：

1. 让基本数据类型有面向对象的特征
2. 封装了字符串转化成基本数据类型的方法（重点）

包装类常用方法：

1. Integer.parseInt()
2. Long.paseLong()
3. Double.parseDouble()

代码示例：(类型转换——装箱与拆箱)

package com.commonclass.packageclass;public class Demo01 {public static void main(String[] args) {//类型转换：装箱，基本类型转换成引用类型的过程//基本类型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之后，Java中提供了自动装箱和拆箱int age = 20;//自动装箱Integer integer4 = age;System.out.println("自动装箱");System.out.println(integer4);//自动拆箱int age2 = integer4;System.out.println("自动拆箱");System.out.println(age2);}
}
运行结果:
装箱
18
18
拆箱
100
自动装箱
20
自动拆箱
20Process finished with exit code 0

代码示例：(类型转换——parseXXX()静态方法)

public class Common_Class {public static void main(String[] args) {//将基本类型转换成字符串//1.通过“+”号连接//2.通过toString()方法int num=10;String s1=num+"";String s2=Integer.toString(num);String s3=Integer.toString(num,16);   //toString()的重载方法，此处是将整型转换成16进制表示后，再变成字符串类型System.out.println(s1+" "+s2+" "+s3);//将字符串转换成基本类型//通过parseXXX()方法进行转换int num_a=Integer.parseInt(s1);      //将字符串s1转换成整型float num_b=Float.parseFloat(s1);    //将字符串s1转换成浮点类型}
}
运行结果：
10 10 aProcess finished with exit code 0

注：boolean类型的字符串转换成基本类型的时候，只有字符串"true"会转换成boolean类型的true,其他的boolean类型的字符串都会转换成false

代码示例：(Integer整数缓冲区)

public class Integer_Demo {public static void main(String[] args) {//通过实例化一个引用类型对象，没有缓冲区，所以输出falseInteger int1=new Integer(127);Integer int2=new Integer(127);System.out.println(int1==int2);  //等于号是比地址equals()方法比的是字符串的值/*Integer.java文件中的valueof()方法public static Integer valueOf(int i) {if (i >= Integer.IntegerCache.low && i <= Integer.IntegerCache.high)return Integer.IntegerCache.cache[i + (-Integer.IntegerCache.low)];return new Integer(i);}*///只有通过valueof()方法定义的引用类型才会有整型缓冲区//128不在整型缓冲区提供的区间内，输出falseInteger int3=Integer.valueOf(128);Integer int4=Integer.valueOf(128);System.out.println(int3==int4);//111在整型缓冲区提供的区间内，所以输出trueInteger int5=Integer.valueOf(111);Integer int6=Integer.valueOf(111);System.out.println(int5==int6);}
}
运行结果：
false
false
trueProcess finished with exit code 0

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

(缓冲区中的数为-128~127，如果新创建的引用类型数据在这个区间内，则直接在堆空间中取这个数映射到栈空间中，如果不在这个区间内则在堆空间中新开辟一个空间)

注：只有通过valueof()方法定义的整型引用类型才会有缓冲区

4.数学类(Math类)

数学类的方法都是静态方法，可以直接引用——Math.方法();

常用数学类的方法：

1. abs()：获取绝对值
2. max()：求最大值
3. min()：求最小值
4. pow()：求次幂
5. round()：四舍五入
6. sqrt()：求平方根

5.时间类

Java常用时间类:

1. Date 日期类
2. Calendar 日历类
3. SimpleDateFormat 格式化时间类

注意：Date和Calendar类 在java.util包中

SimpleDateFormat类 在java.text包

1、Date日期

• new Date() 可以获取到系统时间

• getTime() 能获取到时间的long形式，可以用来计算时间差

  注意：getTime()——获取计算机底层存储的数字，返回一个数字用来表示时间，这个数字的类型long，单位为毫秒。

代码示例：

import java.util.Date;
public class Test {public static void main(String[] args) {Date d = new Date();System.out.println(d); // 系统时间//get...()——获取年月日.....System.out.println(d.getYear()+1900); // 从1900年开始算的System.out.println(d.getMonth()+1); // 月份从0开始计算System.out.println(d.getDate()); // 天数System.out.println(d.getHours());// 小时//getTime()——获取到时间的毫秒形式 返回的是longSystem.out.println(d.getTime());}
}
运行结果：
Wed Aug 10 13:44:26 CST 2022
2022
8
10
13
1660110266878Process finished with exit code 0

2、Calendar日历

• get() 获取到时间的某一部分

• set() 设置时间 - -> 计算时间：系统已经帮我们设置好了，不用担心二月有多少天等问题，计算时间十分方便。

  注意：注：Calendar 日历类是抽象类，因此不可以去new对象。虽然抽象类不能创建对象，但是jdk官方提供了一个实例对象的操作：

  Calendar rightNow = Calendar.getInstance();

  我们通过这条代码就是直接造了一个Calender的对象

代码示例：

//get() 获取到时间的某一部分：
package date;
import java.util.Calendar;
public class TestCalendar {public static void main(String[] args) {Calendar cal = Calendar.getInstance();
//        System.out.println(cal);/*假设当天：2022810*/cal.set(Calendar.DATE,cal.get(Calendar.DATE)+31); // 计算时间(这里用天数计算的) // 获取Calendar创建的对象里的所有内容System.out.println(cal.get(Calendar.YEAR)); // 2022 年System.out.println(cal.get(Calendar.MONTH)); // 月份：从0开始的  结果：为8月System.out.println(cal.get(Calendar.DATE)); // 日System.out.println(cal.get(Calendar.HOUR_OF_DAY));// 小时System.out.println(cal.get(Calendar.MINUTE));System.out.println(cal.get(Calendar.SECOND));}
}
运行结果
2022
8
10
13
53
33Process finished with exit code 0

代码示例：(set() 设置时间 - -> 计算时间：)

注：cal.setTime(d); 把Date转化成Calendar

package date;
import java.util.Calendar;
import java.util.Date;
public class TestCalendar {public static void main(String[] args) {Date d = new Date();Calendar cal = Calendar.getInstance();cal.setTime(d);// 把Date转化成CalendarSystem.out.println(cal);System.out.println(cal.get(Calendar.YEAR)); //  年System.out.println(cal.get(Calendar.MONTH)+1); // 月份：从0开始的System.out.println(cal.get(Calendar.DATE)); // 日        }
}运行结果：
2022
8
10Process finished with exit code 0

3、SimpleDateFormat格式化时间

• Date，Calendar通过引用也可以进行时间的格式化，但比较繁琐，而SimpleDateFormat类是专门帮我们格式化时间的工具类，它在java.text包中。

• 【时间格式】：yyyy-MM-dd HH:mm:ss

• SimpleDateFormat类有两大常用方法：

  1. format(Date)：

  注意：format(Date) 帮我们把时间转成字符串，字符串的格式为SimpleDateFormat类定义对象时设置的时间格式

示例代码：

package com.commonclass.Dateclass;import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.SimpleFormatter;
public class Test {public static void main(String[] args) {Date d = new Date();System.out.println(d); //Wed Aug 10 13:57:22 CST 2022  不美观//                  设置格式化时间的模式，我们常用yyyy-MM-dd HH:mm:ss这个模式SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 时间格式String s = sdf.format(d); // 格式化时间System.out.println(s); // 2022-08-10 13:57:22}
}
运行结果：
Wed Aug 10 13:57:22 CST 2022
2022-08-10 13:57:22Process finished with exit code 0

1. parse(String)：

   注意：parse(String) 帮我们把字符串转化成时间

代码示例：

package com.commonclass.Dateclass;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;public class Test2 {public static void main(String[] args) throws ParseException {Scanner sc = new Scanner(System.in);System.out.println("请输入一个时间(yyyy-MM-dd HH:mm:ss)：");String s = sc.nextLine();SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");Date d =  sdf.parse(s); // 把字符串转成时间System.out.println(d);/*请输入一个时间(yyyy-MM-dd HH:mm:ss)：2022-08-10 14:00:21Wed Aug 10 14:00:21 CST 2022*/}
}
运行结果：
请输入一个时间(yyyy-MM-dd HH:mm:ss)：
2022-08-10 14:00:21
Wed Aug 10 14:00:21 CST 2022Process finished with exit code 0

注：由于用户输入的字符串不一定是我们要求的格式，可能是任何东西，想把它们转成时间是不可能的，你不可能把一个人转成时间 对吧，因此存在着很大的风险未处理(异常: java.text.ParseException)，为此我们需要处理异常。

4、计算时间差

计算思路：

1.格式化时间
2.先将字符串转化成long类型时间
3.计算毫秒级别时间差，取绝对值
4.毫秒级别时间差转成秒级别
5.秒级别时间差转成分钟级别
6.分钟级别时间差转化显示成xx小时xx分钟

示例代码：

package com.commonclass.Dateclass;import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;public class TestDiff {/*
计算思路：
1.格式化时间
2.先将字符串转化成long类型时间
3.计算毫秒级别时间差，取绝对值
4.毫秒级别时间差转成秒级别
5.秒级别时间差转成分钟级别
6.分钟级别时间差转化显示成xx小时xx分钟*/public static void main(String[] args) throws ParseException {String s1 = "2022-08-10 14:00:00";//开始时间String s2 = "2022-08-10 16:30:22";//结束时间//格式化时间SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd HH:mm:ss");//将字符串转换成时间形式Date d1 = sdf.parse(s1);Date d2 = sdf.parse(s2);//计算时间差：先要获取时间毫秒形式(long)类型再作差long long1 = d1.getTime();long long2 = d2.getTime();long diffTime = Math.abs(long1 - long2);//秒级别时间差long diffSec = diffTime / 1000;//分级别时间差long diffMin = diffSec / 60;//显示 xx小时xx分钟long displayHours = diffMin / 60;//小时long displayMin = diffMin % 60;//分钟System.out.println("您的学习时长为："+displayHours+"小时"+displayMin+"分钟"+"请继续保持努力！");}}
运行结果：
您的学习时长为：2小时30分钟请继续保持努力！Process finished with exit code 0

6.String类

字符串类常用方法汇总：

修饰符和返回值的类型	方法名	解释
char	charAt()	获取某个位置的字符
String	concat()	字符串的拼接。一般字符串拼接直接相加就好了
boolean	contains()	判断原字符串是否含有xxx字符串，常用于子串的判断
boolean	endsWith()	判断原字符串是否以xxx字符串结尾
boolean	startsWith()	判断原字符串是否以xxx字符串开头
boolean	equals()	判断两边字符串内容是否相同；==判断地址是否相同
boolean	equalsIgnoreCase()	忽略大小写判断两边字符串的内容是否一样
int	length()	计算字符串的长度
int	indexOf()	计算给出字符串第一个出现的位置
int	LastindexOf()	计算给出字符串最后一个出现的位置
String	replace()	字符串内容的替换
String	split()	字符串切割，最终结果是一个字符串数组
String	trim()	去掉字符串左右两边的空格，中间的不行
String	substring()	字符串截取，左闭右开：[ )
static String	valueOf()	官方：基本数据类型转为字符串操作；直接：变量 + “”

注：字符串是一个不可变的类型（final类），几乎所有的字符串操作都会返回一个新字符串而不是在原有基础上进行修改。

代码示例：

package com.commonclass.stringclass;public class Test {public static void main(String[] args) {String s = "今年夏天是真热";s.concat("要开空调。");//在字符串s上拼接，拼接要开空调System.out.println(s);//今年夏天是真热//字符串是不可变的数据类型//几乎所有的字符串操作都会返回一个新字符串String s1 = s.concat("要开空调。");//在字符串s上拼接，拼接要开空调。System.out.println(s1);//今年夏天是真热要开空调。System.out.println("==============================================");String str1 = "披金成王，伴坤远航";str1.replace("披金成王","不怕事不惹事");System.out.println(str1);//披金成王，伴坤远航  并没有替换 字符串是不变的str1还是str1String str2 = str1.replace("披金成王","不怕事不惹事");//几乎所有的字符串操作都会返回一个新字符串 新字符串要用新变量System.out.println(str2);//不怕事不惹事，伴坤远航}
}

package com.commonclass.stringclass;import java.util.Scanner;public class Test02 {public static void main(String[] args) {String s = "我是一名埃鲲";System.out.println(s.charAt(0));//获取第0个位置的字符s.concat("ikun");System.out.println(s);//我是一名埃鲲//字符串是不可变的数据类型//几乎所有的字符串操作都会返回一个新字符串String s1 = s.concat("ikun");System.out.println(s1);//我是一名埃鲲ikunSystem.out.println(s.contains("我是一名埃鲲"));//trueSystem.out.println(s.contains("吉尼太妹"));//falseSystem.out.println("邀请ikun参加演唱会".endsWith("演唱会"));//true 判断是否以xxx为结尾System.out.println("邀请ikun参加演唱会".endsWith("太妹"));//false 判断是否以xxx为结尾//        //equals字符串内容是否相同
//        //参加演唱会的ikun到现场后要查看门票防伪码
//        String yanchanghui = "1314IKUN";
//
//        Scanner sc = new Scanner(System.in);
//
//        System.out.println("请出示防伪码("+yanchanghui+")");
//
//        String ikunInput = sc.nextLine();
//
//        if (yanchanghui.equalsIgnoreCase("1314IKUN")){//忽略大小写判断两边的内容是否一样
//            System.out.println("欢迎来到坤坤演唱会！");
//        }else {//            System.out.println("您的门票是假的，请及时抢票！");
//        }String str = "唱，跳，rap，篮球！";System.out.println(str.indexOf("篮球！"));//计算出字符串第一个出现的位置String str1 = "唱，跳，rap，篮球,Music!";System.out.println(str1.length());//计算字符串的长度String str2 = "第一次_鸦片战争_养的我_你叫我怎么_去否认。";String[] ss = str2.split("_");//切割System.out.println(ss[0]);//第一次System.out.println(ss[1]);//鸦片战争System.out.println(ss[2]);//养的我System.out.println(ss[3]);//你叫我怎么String str3 = "吉尼太妹，贝贝";System.out.println(str3.substring(2,4));//尼妹 字符串截取 [ )左闭右开，右边取不到String str4 = "    干     嘛       ";System.out.println(str4.trim());//去掉左右两边的空格int i = 20;System.out.println(String.valueOf(i));//基本数据类型转为字符串System.out.println(i+" ");}
}

7.String Builder和StringBuffer

String类的缺点：

String 是一个不可变的数据类型，每每拼接都会产生一个新的字符串，那么内存迟早会被这些拼接的字符串塞满。

String类和StringBuilder和StringBuffer类的区别：

StringBuilder和StringBuffer：**可变的字符串，不产生新对象，比较省内存，**当进行大量的字符串拼接时建议使用StringBuffer和StringBuilder，但它们两个一些方法的实现几乎跟String一样。

StringBuffer和StringBuilder类：

【相似点】

两者用法一模一样，可以认为是一个类

【区别】

StringBuffer线程安全，StringBuilder非线程安全。
StringBuilder相比于StringBuffer有速度优势，多数情况下建议使用StringBuilder类，但当被要求线程安全时必须使用StringBuilder类。

注意：字符串拼接方法：append()方法

StringBuffer和StringBuilder 转成String类 ：

StringBuilder sb = new StringBuilder("猫喜欢吃鱼");
String s = sb.toString();

代码示例：

package com.commonclass.stringclass;public class TestStringBuilder {public static void main(String[] args) {StringBuilder sb = new StringBuilder();//一个空的字符串""StringBuilder sb1 = new StringBuilder("猫喜欢吃鱼");sb1.append(",狗喜欢吃骨头");System.out.println(sb1);//追加 猫喜欢吃鱼，狗喜欢吃骨头sb1.insert(1,"其实");System.out.println(sb1);//猫其实喜欢吃鱼,狗喜欢吃骨头// 上述的操作huan'c// 把StringBuilder转化成StringString s = sb1.toString();System.out.println(s); //猫其实喜欢吃鱼,狗喜欢吃骨头// 上述操作都可以将StringBuilder换成StringBuffer，结果一样}
}
运行结果：
猫喜欢吃鱼,狗喜欢吃骨头
猫其实喜欢吃鱼,狗喜欢吃骨头
猫其实喜欢吃鱼,狗喜欢吃骨头Process finished with exit code 0

8.DecimalFormat

DecimalFormat：对小数进行格式化，保留几位小数。与格式化时间联想记。

. 表示小数点

0和# 表示数位，保留几位就几个0或者#

代码示例：

package com.commonclass.stringclass;import java.text.DecimalFormat;
import java.util.Scanner;
public class Test01 {public static void main(String[] args) {double d = 10/3.0;System.out.println(d);;//3.3333333333333335// . 表示小数点// 0和#表示数字// 保留两位小数                        格式DecimalFormat df = new DecimalFormat(".00"); // 或者.##String s = df.format(d); // 把 d 转成上面设置的格式System.out.println(s);//3.33}
}
运行结果：
3.3333333333333335
3.33Process finished with exit code 0

很多实际应用中需要精确运算,而double是近似值存储,不再符合要求,需要借助BigDecimal。

代码示例：

public static void main(String[] args) {double num1=1.0;double num2=0.9;System.out.println(num1-num2);  //输出0.09999999999999998//原因是double类型在内存中近似存储//使用BigDecimal进行精确运算BigDecimal n1 = new BigDecimal("1.0");  //注意要用字符串,否则结果仍然有误差BigDecimal n2 = new BigDecimal("0.9");BigDecimal n3=n1.subtract(n2);      //进行减法运算System.out.println(n3);//注意：除法如果除不尽会报错，要使用除法的一个重载方法保留小数BigDecimal b1 = new BigDecimal("10");BigDecimal b2 = new BigDecimal("3");BigDecimal b3=b1.divide(b2,2,BigDecimal.ROUND_HALF_UP); //BigDecimal.ROUND_HALF_UP为四舍五入System.out.println(b3);
}

注意：

除法: divide (BigDecimal bd,int scal, RoundingMade mode) 参数scal
:指定精确到小数点后几位。 参数mode :
指定小数部分的取舍模式，通常采用四舍五入的模式,
取值为BigDecimal.ROUND_HALF_UP。

补充 System类

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

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

代码示例：

public static void main(String[] args) {//使用arraycopy()方法实现数组的复制// src:原数组、srcPos:从哪个位置开始复制//dest:目标数组 、destPos:目标数组的开始位置 、length:复制的长度int[] arr=new int[]{11,22,33,44,55};int[] dest=new int[5];System.arraycopy(arr,0,dest,0,arr.length);System.out.println(Arrays.toString(dest));//通过currentTimeMillis()方法实现计算代码的运行时间long start=System.currentTimeMillis();for (int i = 0; i < 9999; i++) {for (int j = 0; j < 999999; j++) {int result=i+j;}}long end=System.currentTimeMillis();System.out.println("运行时间为："+(end-start));
}

Java八大常用类小结相关推荐

1. Java并发包中常用类小结(一)

                                  Java并发包中常用类小结(一) 从JDK1.5以后,Java为我们引入了一个并发包,用于解决实际开发中经常用到的并发问题,那我们今天就来 ...

2. Java程序员从笨鸟到菜鸟之（五）java开发常用类（包装，数字处理集合等）（下）...

    本文来自:曹胜欢博客专栏.转载请注明出处:http://blog.csdn.net/csh624366188 写在前面:由于前天项目老师建设局的项目快到验收阶段,所以,前天晚上通宵,昨天睡了大半天, ...

3. Java程序员从笨鸟到菜鸟之（五）java开发常用类（包装，数字处理集合等）（下）

   写在前面:由于前天项目老师建设局的项目快到验收阶段,所以,前天晚上通宵,昨天睡了大半天,下午我们宿舍聚会,所以时间有点耽误,希望大家见谅 上接: Java程序员从笨鸟到菜鸟之(四)java开发常用类( ...

4. Java SE 常用类：枚举enum

   Java SE 常用类:枚举enum 1.enum 枚举 表示一种事物的所有可能|一种类型的所有情况. 软件包 java.lang 注意: 枚举类型不能自定义实例化,实例由程序猿|枚举类型自己提供,因 ...

5. Java程序员从笨鸟到菜鸟之（四）java开发常用类（包装，数字处理集合等）（上）

   本文来自:曹胜欢博客专栏.转载请注明出处:http://blog.csdn.NET/csh624366188 一:首谈Java中的包装类 Java为基本类型提供包装类,这使得任何接受对象的操作也可以用 ...

6. java map常用类及其方法_Day50.Map类常用的方法 -Java常用类、集合#、IO

   Day50.Map类常用的方法 -Java常用类.集合#.IO Day50.Map类常用的方法 -Java常用类.集合#.IO Map类常用的方法 . 总结: 常用方法 添加: put(Object ...

7. Java基础---常用类之Arrays工具类+基本类型的包装类

   常用类之Arrays工具类 1.binarySearch(int[] a,int key) 使用二分搜索法来搜索指定的 int 型数组 2.fill(int[] a,int val)将指定的 int ...

8. Java基础---常用类之Math类 and Syetem类

   常用类-Math类 Math类:关于数学的类 这个类中封装了一些关于数学的方法 可以完成一些常用的数学操作 特点:1.final修饰的类 所以Math类没有子类的 不可以继承2.Math类中的构造方法 ...

9. 菜鸟学JAVA之——常用类（StringBuffer、StringBuilder、Comparable、Comparator等）

   文章目录 常用类 字符串相关的类 一.String类及常用方法 二.StringBuffer.StringBuilder JDK 8 之前的日期时间API 一.System静态方法 二.Date类 三 ...

最新文章

1. Python __dict__属性详解
2. Redis进阶实践之三如何在Windows系统上安装安装Redis
3. parcelable 缺点_成都金牛区茶道炭优缺点-兴木华木炭
4. sql根据类别拆分上下级_运用SQL对黑五销售数据进行分析
5. BugkuCTF-MISC题旋转跳跃
6. 6月第二周中国五大顶级域名增2.4万 美国减6.8万
7. 未经处理的异常：System.Net.Sockets.SocketException: 以一种访问权限不允许的方式做了一个访问套接字的尝试...
8. 生命周期 用户可以操作dom_当面试官问：能否介绍下Vue生命周期时，该如何回答...
9. 【面试】iOS 开发面试题(二）
10. windows cmd 定义和使用变量
11. 稀疏矩阵的加，减，乘，转置
12. dns重定向_怎样理解DNS缓存投毒？
13. 基于RV1126平台imx291分析 --- media部件注册 mipi csi phy
14. 国内先进的光电转换器件设计和单光子检测成像技术 1DTof 3DTof 激光测距传感器
15. 【二十一】 H.266/VVC | 仿射运动估计AMVP候选列表的构建 | fillAffineMvpCand函数
16. 阐述清楚浮动的几种方法
17. 多传感器融合定位五-点云地图构建及定位
18. Error:Execution failed for task ':app:validateSigningDevDebug'. Keystore file E:\workspace\trunk\H
19. Python-opencv的指针检测、表盘识别算法案例分析
20. 目前最流畅的android手机,目前公认最流畅的4大手机系统，华为仅排第三，第一实至名归！...

热门文章

1. 写jsp遇到的两个问题及解决
2. echarts 导入地区.json文件生成地图
3. win10 IE11卸载了怎么重装
4. Android Instrumentation源码分析（附Activity启动流程）
5. 表格中复制粘贴到其他位置的数据会携带引号等不可见字符
6. QQ网页微信、QQ二维码登录原理分析（整理）
7. 有关DSP2812与SPI接口DA芯片的通信（AD5640，AD5682）
8. 垃圾邮件检测_如何在您的电子邮件中检测垃圾邮件
9. 2022 ICPC 亚洲区域赛（杭州）赛后总结
10. Head First Java: Chapter6 JavaCross7.0 答案整理