8.从零开始学习Java-常用类

原创 于 2020-09-18 15:47:01 发布 · 287 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #jdk #内存泄漏

本文深入讲解Java中的核心类，包括内部类的特点与分类、Object类的功能与方法、包装类的应用、String类的操作与技巧、BigDecimal类的精确计算、时间相关的类如Date与Calendar的使用方法等。

常用类

一、内部类

1.1 概念：

在一个类的内部再定义一个完整的类。

例如：Outer$Inner.class//内部类

1.2 特点：

  • 编译之后可生成独立的字节码文件。
  • 内部类可直接访问外部类的私有成员，而不破坏封装。
  • 可为外部类提供必要的内部功能组件。
public class Outer {
    private int a;
     private class Inner{//为外部类提供必要的内部功能组件
        public void m1(){
            System.out.println("innter method - m1()" + a);//可访问外部类的私有成员
        }
    }
}

1.3 分类：

1.3.1 成员内部类（实例级别）

//实例级别

//实例变量又叫成员变量

在类的内部定义，与实例变量、实例方法同级别的类。
外部类的一个实例部分，创建内部类对象时，必须依赖外部类对象。

  • Outer out = new Outer();
  • Outer.Inner in = out.new Inner();
public class Outer {
    private int a;
    class Inner{//为外部类提供必要的内部功能组件
        int b;
        public void m1(){
            System.out.println("innter method - m1()" + a);//可访问外部类的私有成员,封装依旧在
        }
    }
}
public class TestMember {
    public static void main(String[] args){
//        Inner inner = new  Inner();//错误，不能脱离外部类对象而独立存在
        Outer outer = new Outer();
        //创建成员内部类的对象（必须依赖外部类对象）,静态内部类不需要此步，即不依赖外部类对象。
        Outer.Inner inner = outer.new Inner();
        System.out.println(inner.b);
        inner.m1();
//        System.out.println(outer.a);//错误，封装依然在，无法从外部获取，需要依赖成员内部类获取。
    }
}

当外部类、内部类存在重名属性时，会优先访问内部类属性。
成员内部类不能定义静态成员//内部类需要依赖外部类存在的

public class Outer {
    private int a = 10;
    class Inner{//为外部类提供必要的内部功能组件
        int a = 20;
        /*static*/ String field = "abc";//内部成员类不能定义静态成员
        public void m1(){
            int a = 30;
            System.out.println("innter method - m1()" + a);//内部类可以访问自身局部变量
            System.out.println("innter method - m1()" + this.a);//内部类可以直接访问内部类的实例变量
            System.out.println("innter method - m1()" + Outer.this.a);//内部类可以访问外部类实例变量
        }
    }
}
结果：
innter method - m1()20
innter method - m1()20
innter method - m1()10

1.3.2 静态内部类（静态级别）

//静态级别

//静态内部类需要有静态方法

• 不依赖外部类对象，可直接创建或通过类名访问，可声明静态成员。
• 只能直接访问外部类的静态成员（实例成员需实例化外部类对象）。

• Outer.Inner inner = new Outer.Inner();

• Outer.Inner.show();

public class TestStaticClass {

	public static void main(String[] args) {
		//外部类的静态属性
		System.out.println(Outer.a);	
		//外部类的静态方法
		Outer.m1();
		//创建静态内部类对象时，可以直接通过完整名称进行创建
		Outer.Inner in = new Outer.Inner();//静态内部类的创建，不依赖外部类的对象	
		//创建内部类对象后，访问实例属性和方法
		System.out.println(in.b);
		in.m2();
		//&&额外比成员内部类多了一个定义的内容（静态属性和静态方法）&&	
		//通过外部类类名.内部类类名.内部类的静态属性
		System.out.println(Outer.Inner.field);
		//通过外部类类名.内部类类名.内部类的静态方法
		Outer.Inner.m3();
	}
}

class Outer{
	static int a = 10;
	static class Inner{
		int b = 20;	
		static String field = "abc";	
		public void m2(){
			System.out.println("Inner m2()");
		}		
		public static void m3(){
			System.out.println(a);
		}		
	}	
	static void m1(){
		System.out.println("Outer m1()");
	}	
}

//逻辑代码不能写在类下，可以写在结构里，方法里。

public class Bank {//银行功能业务模块
    /*
    //User [] users = new User[5];//1.实例属性赋值
    static User[] users = new User[5];//对外不可见
    //static {} 2.静态代码块（第二选择方法）
    static {
        users[0] = new User();
        users[1] = new User();
    }

    {
        //3.动态代码块（第三选择方法）
    }

    public Bank(){//4.构造方法，靠前执行(但为了不是每次创建对象覆盖一次，不能写在这里)
        users[0] = new User("张三", 1);
    }
    public void login(){

    }
    */
    private static class Information {
        private static User[] users = new User[5];
        static {
            users[0] = new User();
            users[1] = new User();
        }
    }
}

1.3.3 局部内部类（局部级别）

//局限于当前方法

• 定义在外部类方法中，作用范围和创建对象范围仅限于当前方法。
• 局部内部类访问外部类当前方法中的局部变量时，因无法保障变量的生命周期与自身相同，变量必须修饰为final。
• 限制类的使用范围。

//对象在堆中，局部变量在栈中，两者回收时机不同，栈中内容立即回收，对象不会立即回收，伴随的垃圾收集器回收。

//局部变量的生命周期可能和局部内部类对象的生命周期不一致。加入fianl可以保证局部变量的生命周期大于内部类对象的声明周期。

public class Outer {
    int a = 10;//外部类的实例变量
    public void m1(){
        //外部类方法的局部变量
        final String local = "Hello";
        //局部内部类
        class Inner{
            int a = 20;//内部类的实例变量
            public void m2(){
                int a = 30;//局部变量
                System.out.println("Inner -- m2"+a);
                System.out.println("Inner -- m2"+local);//访问外部类的局部变量，
            }

        }

        Inner in = new Inner();//局部内部类，方法块结束后就没有了。
        in.m2();
    }
    public static void m2(){

    }
}

public class TestLocalClass {
    public static void main(String[] args){
        //m1
        Outer outer = new Outer();
        outer.m1();

        //m2
        Outer.m2();
    }
}

public class TestSchool {
    public static void main(String[] args){
//        Teacher t1 = new AdvencedTeacher();
//        t1.teach();

        Teacher t = School.randomChoose(1);
        t.teach();
    }
}
class School{
    public static Teacher randomChoose(int classNo){
        //隐藏类信息
        class BeginnerTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("初级老师在上课");
            }
        }
        class AdvencedTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("高级老师在上课");
            }
        }
        Teacher t = null;
        if (classNo % 2!=0){
            t = new AdvencedTeacher();
        }else {
            t = new BeginnerTeacher();
        }
        return t;
    }
}
abstract class Teacher{
    public abstract void teach();
}

1.3.4 匿名内部类

//不需要独立定义，定义类，实现类，创造对象，三步合一。

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

• 缺点：可读性较差。

 public class TestSchool {
    public static void main(String[] args){
//        Teacher t1 = new AdvencedTeacher();
//        t1.teach();

        Teacher t = School.randomChoose(1);
        t.teach();
    }
}
class School{
    public static Teacher randomChoose(int classNo){
        //隐藏类信息（局部内部类）
        class BeginnerTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("初级老师在上课");
            }
        }
        class AdvencedTeacher extends Teacher{
            @Override
            public void teach() {
                System.out.println("高级老师在上课");
            }
        }
        Teacher t = null;
        if (classNo % 2!=0){
            t = new AdvencedTeacher();
            //匿名内部类,符合程序员开发规则，书写习惯，但是需要频繁创建对象。
            t = new Teacher() {//想要xxx的实现类，直接用，然后在方法里面实现
                @Override
                public void teach() {
                    System.out.println("匿名内部类，注意后面的分号");
                }
            };
        }else {
            t = new BeginnerTeacher();
        }
        return t;
    }
}
abstract class Teacher{
    public abstract void teach();
}

二、Object类

2.1 特点：

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

  • 作为参数，可接受任何对象。
  • 作为返回值，可返回任何对象。
public class TestObject {
    public static void main(String[] args){
      Object o = new Object();//不是抽象类
        Object o2 = new Cat();
    }
    public static void method(Object object){

    }
    public void me(){

    }
    public static Object buyVehicle(int n){
        return null;//可返回任何对象
    }
}

class Dog{}
class Cat{}
class Student{}

使用API文档：

在这里插入图片描述

2.2 getClass()方法

• public final Class<?> getClass(){}
• 返回引用中存储的实际对象类型。
• 应用：通常用于判断两个引用中实际存储对象类型是否一致。

package java0807;

public class TestGetClass {
    public static void main(String[] args){
      Student1 s = new Student1();
      System.out.println(s.getClass());
      Object o = new Object();
      System.out.println(o.getClass());
      Anmial1 a = new Dog1();
      System.out.println(a.getClass());
      Anmial1 anmial1 = new Cat1();//当成什么看，其实还是Cat
//      if (anmial1 instanceof Dog1){
//          if (a instanceof Dog1){
//              System.out.println();
//          }
//      }else if (a instanceof Cat1){
//          if (anmial1 instanceof Cat1){
//
//          }
//      }
        if (anmial1.getClass() == a.getClass()){
            System.out.println("一样");
        }else {
            System.out.println("不一样");
        }
    }
}
class Student1{}
class Dog1 extends Anmial1{}
class Cat1 extends Anmial1{}
abstract class Anmial1{}
测试结果：
class java0807.Student1
class java.lang.Object
class java0807.Dog1
不一样

2.3 hashCode()方法

• public int hashCode(){}
• 返回该对象的十进制的哈希码值。
• 哈希算法根据对象的地址或字符串或数字计算出来的int类型的数值。
• 哈希码并不唯一，可保证相同对象返回相同哈希码，尽量保证不同对象返回 不同哈希码。

public class TestHashCode {
    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            Object o = new Object();
            System.out.println(o.hashCode() + "\t" + o);//o=o.toString
        }
    }
}
测试结果：
460141958	java.lang.Object@1b6d3586
1163157884	java.lang.Object@4554617c
1956725890	java.lang.Object@74a14482
356573597	java.lang.Object@1540e19d
1735600054	java.lang.Object@677327b6

2.4 toString()方法

• public String toString(){}
• 返回该对象的字符串表示（表现形式）。
• 可以根据程序需求覆盖该方法，如：展示对象各个属性值。

//官方的toString方法。

//存储的实际对象类型+“@”+哈希码的十六进制表示。

public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

//例如： java.lang.Object@1b6d3586

public class TestHashCode {
    public static void main(String[] args){
        for (int i = 0; i < 5; i++) {
            Object o = new Object();
//            System.out.println(o.hashCode() + "\t" + o);
//            System.out.println("  ");
//            System.out.println(o.hashCode() + "\t" + o.toString());
            Object o1 = new Teacher1("h1",11,"男");
            System.out.println(o1.toString());
            System.out.println(((Teacher1) o1).toString1());
        }
    }
}
class Teacher1{
    String name;
    int age;
    String sex;

    public Teacher1(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String toString1(){
        //自己可以重写tostring方法
       // return this.getClass().getName() + "@" +Integer.toHexString(this.hashCode());
        return this.name + "\t" + this.age + "\t" + this.sex;
    }
    @Override
    public String toString() {
        return "Teacher1{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
}
测试结果 ：
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男
Teacher1{name='h1', age=11, sex='男'}
h1	11	男

2.5 equals()方法覆盖步骤

• 比较两个引用是否指向同一个对象。（地址相同，直接true，无需比较）
• 判断obj是否为null。（空的直接false）
• 判断两个引用指向的实际对象类型是否一致。（比较类型，getclass或instanceof，不一致就false）
• 强制类型转换。
• 依次比较各个属性值是否相同。（最后再依次比较属性值）

//==比较的是地址。

public class TestEquals {

	public static void main(String[] args) {
		/*
		Object o = new Object();
		
		Object o2 = new Object();
		
		System.out.println(o.equals(o2));
		
		System.out.println(o == o2);//无法人为干预
		*/				
		//两个地址不同，而内容相同的对象（可以进行比较）
		Object s1 = new Student("tom",20,"男",99D);
		
		Object s2 = new Student(new String("tom"),20,"男",99D);
		
		System.out.println(s1 == s2);//false 表示两个对象的地址不同		
		System.out.println(s1.equals(s2));//true 表示两个地址不同而内容相同的对象属于重复对象				
		//情况1（自己和自己比）
		//s1.equals(s1);		
		//情况2（自己和null比）
		//s1.equals(null);		
		//情况3（自己和公交车比）
		//s1.equals(new Bus());		
	}
}
//this ---> s1
class Student{
	String name;
	int age;
	String sex;
	double score;
	public Student(String name, int age, String sex, double score) {
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.score = score;
	}
	
	@Override
	public boolean equals(Object obj){		
		System.out.println("Executed");		
		if(this == obj){
			 return true;
		}
		if(obj == null){
			return false;
		}		
		
		if(this.getClass() != obj.getClass()){
			return false;
		}		
		Student s = (Student)obj;				
		//使用this的各个属性值与o的各个属性值一一进行比较，如果所有属性都全完相同，则代表二者相同
		if(this.name.equals(s.name)  && this.age.equals(s.age) && this.sex.equals(s.sex) && this.score.equals(s.score)){//源码中八种包装类型+String都覆盖了equals方法
			return true;
		}		
		return false;
	}
}

//覆盖加@override，避免出错。

2.6 equals()方法

• public boolean equals(Object obj){}
• 默认实现为(this == obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。

2.7 finalize()方法

//一个对象的遗言。

//java有自动回收垃圾机制。目前交由jvm自动管理。

//用以标记垃圾对象。

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象， 进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。（必须要为有效引用）（可达性分析算法引用为引用）
• 垃圾回收： 由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象。
• 手动回收机制：使用System.gc(); 通知JVM执行垃圾回收。（不是立即执行，只是通知，会有延迟。）

三、包装类

3.1 概念：

• 基本数据类型所对应的引用数据类型。
• Object可统一所有数据，包装类的默认值是null。

3.2 包装类对应：

基本数据类型包装类型
byteByte
shortShort
intInteger
longLong
floatFloat
doubleDouble
booleanBoolean
charCharacter

3.3 类型转换与装箱、拆箱:

//基本类型和包装类型对象之间的转型，基本类型转换为包装类型为装箱，包装类型转换为基本类型为拆箱。

//有自动装箱和自动拆箱以后，两者的使用基本没有差别，只是包装类型对象有方法，而基本类型没有。

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

  • • Number父类中提供的6个共性方法。
  • • parseXXX()静态方法（除了Character）。
  • • valueOf()静态方法。

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

public class TestEncapasulate {
    public static void main(String[] args){
//Byte Short Integer Long Float Double 都具有将自身类
// 型的对象，转换成其他6中基本类型的方法
        //将包装类型转换为基本类型
        Short s = new Short("10");
        byte v1 = s.byteValue();
        short v2 = s.shortValue();
        int v3 = s.intValue();
        long v4 = s.longValue();
        float v5 = s.floatValue();
        double v6 = s.doubleValue();

        System.out.println(v1);
        System.out.println(v2);
        System.out.println(v3);
        System.out.println(v4);
        System.out.println(v5);
        System.out.println(v6);

        //将字符串转换成byte
        byte b1 = Byte.parseByte("123");
        byte b2 = new Byte("123").byteValue();
        //将字符串转换成int
        int i1 = Integer.parseInt("234");
        int i2 = new Integer("345").intValue();

        //valueOf
        Byte b3 = Byte.valueOf((byte)123);

    }
}

• JDK 5.0之后，自动装箱、拆箱。基本数据类型和包装类自动转换。

3.4 整数缓冲区

• Java预先创建了256个常用的整数包装类型对象。
• 在实际应用当中，对已创建的对象进行复用。

源码实现：

    private static class ShortCache {
        private ShortCache(){}

        static final Short cache[] = new Short[-(-128) + 127 + 1];

        static {
            for(int i = 0; i < cache.length; i++)
                cache[i] = new Short((short)(i - 128));
        }
    }

测试：

public class TestAutoEncap {
    public static void main(String[] args){
        //语法糖（Java语言规范）
        Byte b = 10;//自动装箱 调用valueOf（byte b）
        Byte b3 = 20;
        byte b2 = b;//自动拆箱 调用byteValue(); shortValue()  intValue() BooleanValue()
        Object o = 10;
        m(20);
        Short s1 = 100;//从长度为256的数组中，取出预先创建好的一个Short对象（此对象代表整数100）0x7777
        //常量缓存，高频内容进行复用
        Short s2 = 100;

        Short s3 = 200;//0x1234
        Short s4 = 200;//0x6789

        System.out.println(s1 == s2);//true
        System.out.println(s3 == s4);//false

    }
    public static void m(Object o){
    }
}

四、String

4.1 特点

  • Java程序中的所有字符串文本（例如“abc”）都是此类的实例。
    字符串字面值是常量，创建之后不可改变。
//源码实现：
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];
   ...
  • 字符串字面值存储再字符串池中，可以共享。
  • 常用创建方式：
    • String str1 = “Hello”;//产生一个对象，字符串池中存储。
    • String str2 = new String(“World”);//产生两个对象，堆、池各存储一个。
public class TestString {
    public static void main(String[] args){
        System.out.println("abc");
        String s = "abc";
        s+="d";//地址不同,存储在字符串池中
        System.out.println(s);
    }
}

public class TestString2 {
    public static void main(String[] args){
      String s1 = "abc";//产生1个对象
      String s2 = "abc";//没有产生对象
      String s3 = new String("abc");//再新创建一个对象
      System.out.println(s1 == s2);//true
      System.out.println(s1 == s3);//false
    }
}
class TestString3{
    public static void main(String[] args){
        String s3 = new String("abc");//池中创建一个对象，堆中创建一个对象
        String s1 = "abc";//0
        String s2 = "abc";//0
        System.out.println(s1 == s2);//true
        System.out.println(s1 == s3);//false
    }
}

4.2 常用方法：

String(byte[] bytes, Charset charset) 
构造一个新的String由指定用指定的字节的数组解码charset 。

• public char charAt(int index)：根据下标获取字符。

• public boolean contains(String str)：判断当前字符串中是否包含str。

• public char[] toCharArray()：将字符串转换成数组。

//源码实现：
public char[] toCharArray() {
    // Cannot use Arrays.copyOf because of class initialization order issues
    char result[] = new char[value.length];
    System.arraycopy(value, 0, result, 0, value.length);//复制一份
    return result;
}

• public int indexOf(String str)：查找str首次出现的下标，存在，则返回该下标；不存在，则返回-1。

• public int length()：返回字符串的长度。

//源码实现：
    public int length() {
        return value.length;
    }

• public String trim()：去掉字符串前后的空格。

• public String toUpperCase()：将小写转成大写。

• public boolean endsWith(String str)：判断字符串是否以str结尾。

• public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串

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

• public String subString(int beginIndex,int endIndex)：在字符串中截取出一个子字符串。

public class TestStringMethods {
   public static void main(String[] args){
     String s1 = "HelloMyWorld";


     System.out.println(s1.charAt(6));//y

     System.out.println(s1.contains("lo"));//true

       char[] chs = s1.toCharArray();
       for (int i = 0; i < chs.length; i++) {
           chs[i] = 'A';//全部变成A，但是s1并没有变化啊。
           System.out.println(chs[i]);//输出为数组
       }

       System.out.println(s1.indexOf("W"));//可以为AS码，也可以为“字符”。//通过字符拿下标
       System.out.println(s1.indexOf("lo"));//可以为AS码，也可以为“字符”。//通过字符拿下标
       System.out.println(s1.indexOf("o",5 ));

       s1.length();

       String s2 = "                   he        llo           ";//                   he        llo
       System.out.println(s2.trim());//he        llo

       String s3 = s1.toUpperCase();
       String s4 = s1.toLowerCase();

       System.out.println(s3.equals(s4));//false
       System.out.println(s3.equalsIgnoreCase(s4));//true

       String fileName = "HelloWorld.java";
       System.out.println(fileName.endsWith(".java"));//true
       System.out.println(fileName.startsWith("Hello"));//true

       System.out.println(s1.replace('o', '0'));//Hell0MyW0rld

       String s5 = "你好，大家好，都挺好";
//        String[] strings = s5.split("，");//注意符号的中英文
       String[] strings1 = s5.split("好");//注意符号的中英文
       for (String string : strings1) {
           System.out.println(string);
       }

       String s6 = s1.substring(3,7);//只截取3，4，5，6//loMy
       System.out.println(s6);

   }
}

4.3 可变字符串：

//可变的特性，可变的话和String比，应该用StringBuffer，初始容量为16

• 概念：可在内存中创建可变的缓冲空间，存储频繁改变的字符串。
• 常用方法：

​ • public StringBuilder append(String str)
• StringBuilder：可变长字符串，JDK5.0提供，运行效率快、线程不安全。
• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全。

public class TestStringBuffer {
    public static void main(String[] args){
      String s1 = "abc";
      String s2 = "abc";//s1和s2对应常量池同一地址。可共享的内容
        StringBuffer stringBuffer = new StringBuffer();
        stringBuffer.append("abc");//追加，存储在堆中
    }
}

public class TestStringBuffer2 {
    public static void main(String[] args){
      String empName = "lmc";
      String email = appendEnds(empName);
      System.out.println(email);
    }
    public static  String appendEnds(String emailName){
        //百度公司 @baidu.com.cn
        StringBuffer buffer = new StringBuffer();
        buffer.append("@baidu.com.cn");
        return buffer.toString();
    }
}

public class TestStringBuilder {
    public static void main(String[] args){
      String str = "Hello";//定义字符串Hello
        str += "World";
        //1.创建StringBuilder对象
        //2.调用append追加的方法
        //3.调用toString转换回String
        System.out.println(str);//打印追加后的str
    }
}

五、BigDecimal类

//double是近似值存储

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

位置：

java.math包中。

作用：

精确计算浮点数。

创建方式：

BigDecimal bd=new BigDecimal(“1.0”);

方法：

• BigDecimal add(BigDecimal bd) 加

• BigDecimal subtract(BigDecimal bd) 减

• BigDecimal multiply(BigDecimal bd) 乘

• BigDecimal divide(BigDecimal bd) 除

利用BigDecimal可以进行数值计算：

• 除法：divide(BigDecimal bd,int scal,RoundingMode mode)
• 参数scale ：指定精确到小数点后几位。
• 参数mode ：

  • 指定小数部分的取舍模式，通常采用四舍五入的模式，
  • 取值为BigDecimal.ROUND_HALF_UP。
public class TestBigDecimal {
    public static void main(String[] args){
        BigDecimal bigDecimal1 = new BigDecimal("2.2");//字符串构建
        BigDecimal bigDecimal2 = new BigDecimal("2.2");//字符串构建
        System.out.println(bigDecimal1);
        BigDecimal add = bigDecimal1.add(bigDecimal2);//ctil+alt+v
        System.out.println(add);//add.sout
        BigDecimal subtract = bigDecimal1.subtract(bigDecimal2);
        System.out.println(subtract);
        BigDecimal multiply = bigDecimal1.multiply(bigDecimal2);
        System.out.println(multiply);
        BigDecimal divide = bigDecimal1.divide(bigDecimal2, 2, BigDecimal.ROUND_UP);
        System.out.println(divide);
    }
}

六、时间类型

6.1 Date

• Date表示特定的瞬间，精确到毫秒。

• Date类中的大部分方法都已经被Calendar类中的方法所取代。
• 时间单位

  • 1秒=1000毫秒
  • 1毫秒=1000微秒
  • 1微秒=1000纳秒

6.2 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表示此日历的时间。Calendat-Date
void add(int field,int amount)按照日历的规则，给指定字段添加或减少时间量
long getTimeInMillis()毫秒为单位返回该日历的时间值

6.3 SimpleDateFormat

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

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

• 常用的时间模式字母

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

七、Math

Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

方法名说明
static int abs(int a)复制数组
static double pow(double a,double b)返回第一个参数的第二个参数次幂的值
static double random()返回带正号的double值，该值大于等于0.0且小于1.0
static long round(double a)返回最接近参数的long
static double sqrt(double a)返回正确舍入的double值的正平方根
static double cbrt(double a)返回double值的立方根

八、Random

• 此类的实例用于生成伪随机数流。

• 此类使用 48 位的种子，使用线性同余公式 (linear congruential form) 对其进行了修改所得。

方法名说明
int nextInt()返回下一个伪随即数
double nextDouble()返回0.0和1.0之间均匀分布的double值

若long种子确定，则在不同程序中，相同次数产生的随机数是相同的。

九、System类

System系统类，主要用于获取系统的属性数据和其他操作。

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

十、Runtime类

每个 Java 应用程序都有一个Runtime类实例，使应用程序能够与其运行的 环境相连接。可以通过getRuntime方法获取当前运行时。

方法名说明
Process exec(String command)在单独的进程中执行指定的字符串命令。
void exit(int status)终止当前正在运行的 Java 虚拟机。
void gc()建议JVM赶快启动垃圾回收器回收垃圾
long totalMemory()返回 Java 虚拟机中的内存总量
long freeMemory()返回 Java 虚拟机中的空闲内存量
maxMemory()返回 Java 虚拟机试图使用的最大内存量

修改JVM运行内存

  • 修改堆初始内存大小：-Xms300m
  • 修改堆最大内存大小：-Xmx4000m
  • 修改栈空间大小：-Xss2m jdk1.5之前256k jdk1.5之后1m

总结：

内部类：

• 在一个类的内部再定义一个完整的类。包含：成员内部类、静态内部类、局部内部类、匿名内部类。

Object类：

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

包装类：

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

String类：

• Java程序中的所有字符串文本（例如“abc”）都是此类的实例。字符串字面值是常量，创建之后不可改变。

BigDecimal：

• 可精确计算浮点数。

时间相关类：Date、Calendar、SimpleDateFormat、System

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值