Java常用类

1.0 常用类

1.内部类

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

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

特点：

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

Outer$Inner.class` `Outer.class

//身体
public class Body {
    private String name;
    //头部
    class Header{
        public void show(){
            System.out.println(name);//内部类可以直接访问外部类的是有元素
        }
    }
}

1.1成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部，形如下面的形式:

class Circle {
  double radius = 0;
  
  public Circle(double radius) {
    this .radius = radius;
  }
  
  class Draw {   //内部类
    public void drawSahpe() {
      System.out.println("drawshape");
    }
  }
}

这样看起来，类Draw像是类Circle的一个成员，Circle称为外部类。成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）

class Circle {
    private double radius = 0;
    public static int count =1;
    public Circle(double radius) {
        this.radius = radius;
    }
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
            System.out.println(count);   //外部类的静态成员
        }
    }
}

不过要注意的是，当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。如果要访问外部类的同名成员，需要以下面的形式进行访问：

外部类.this.成员变量
外部类.this.成员方法

虽然成员内部类可以无条件地访问外部类的成员，而外部类想访问成员内部类的成员却不是这么随心所欲了。在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问：

class Circle {
    private double radius = 0;
 
    public Circle(double radius) {
        this.radius = radius;
        getDrawInstance().drawSahpe();   //必须先创建成员内部类的对象，再进行访问
    }
     
    private Draw getDrawInstance() {
        return new Draw();
    }
     
    class Draw {     //内部类
        public void drawSahpe() {
            System.out.println(radius);  //外部类的private成员
        }
    }
}

成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象。创建成员内部类对象的一般方式如下：

package com.class_class.usually_class.demo;

class Outter {
    private Inner inner = null;
    public Outter() {

    }

    public Inner getInnerInstance() {
        if(inner == null)
            inner = new Inner();
        return inner;
    }

    class Inner {
        public Inner() {
            System.out.println("1");
        }
        public void go(){
            System.out.println("走");
        }
    }
}

//测试类
package com.class_class.usually_class.demo;

public class Test {
    public static void main(String[] args)  {
        //第一种方式：
        Outter outter = new Outter();
        Outter.Inner inner = outter.new Inner();  //必须通过Outter对象来创建
        inner.go();

        //第二种方式：
        Outter.Inner inner1 = outter.getInnerInstance();
    }
}

内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰。

1.2静态内部类

静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法，这点很好理解，因为在没有外部类的对象的情况下，可以创建静态内部类的对象，如果允许访问外部类的非static成员就会产生矛盾，因为外部类的非static成员必须依附于具体的对象。

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

//外部类
public class Outter {
    private String name = "yujian";
    private int age = 19;

    public void shout(){
        System.out.println("不要叫");
    }
        //静态内部类，和外部类相同
     static class Inner {
        private String address = "北京";
        private String phone = "110";

        //静态属性
        private static int count = 1000;

        //方法
        public void show(){
            //打印外部类的属性(需要创建对象来访问外部类属性与方法)
            Outter outter = new Outter();
            System.out.println(outter.age);
            outter.shout();

            //调用内部类属性和方法
            System.out.println(address);
            System.out.println(phone);

            //调用静态内部类的静态属性(但都是静态时，可以直接使用里面的东西)
            System.out.println(count);
        }
    }
}

//测试类
public class TestOutter {
    public static void main(String[] args) {
        Outter.Inner inner = new Outter.Inner();
        inner.show();
    }
}

1.3局部内部类

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

限制类的使用范围

//外部类
public class Outter {
    private String name = "yujian";
    private int age = 19;
    private int id = 1;

    public void show(){
        //定义局部变量
        String address = "广州";

        //局部内部类(在方法里面):注意：不能加任何访问修饰符
        class Inner{
            //局部内部类的属性
            private String phone = "155088";
            private String email = "11111";

            public void show2(){
                //访问外部类的属性(3种方法都可以)
                Outter outter = new Outter();
                System.out.println(outter.id);

                System.out.println(Outter.this.name);
                System.out.println(age);

                //访问内部类的属性(2种方法都可以)
                System.out.println(phone);
                System.out.println(this.email);

                //访问局部变量(jdk1.7要求必须是常量final，jdk1.8自动添加final)
                System.out.println(address);

            }
        }
        //创建局部内部类对象
        Inner inner = new Inner();
        inner.show2(); 
    }
}
/*
    局部内部类不能包含静态的成员
    如：在class Inner中，添加private static int count = 2000;会报错
                        但(添加静态常量是没错)private final static int count = 2000;不会报错
 */

//测试类
public class TestOutter {
    public static void main(String[] args) {
        Outter outter = new Outter();
        outter.show();
    }
}

运行outter.show(),然后运行inner.show2()

1.4匿名内部类

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

缺点可读性较差

// 使用匿名内部类优化（相当于创建了一个局部内部类）
Usb usb = new Usb(){ // Usb为一个接口
  @Override
  public void service(){
    sout("连接电脑成功，fan开始工作")
  }
};
usb.service();

2.Object类

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

2.1getClass()方法

public final Class<?> getClass(){}
返回引用中存储的实际对象类型

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

// 判断s1 和 s2是不是同一个类型
Class class1 = s1.getClass();
Class class2 = s2.getClass();
// getClass返回 class类型

完整代码

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("yujian",19);
        Student s2 = new Student("gao",20);
        
        //判断s1余s2是否为同一个类型
        Class class1 = s1.getClass();
        Class class2 = s2.getClass();
        if (class1 ==class2){
            System.out.println("类型相同");
        }
        else{
            System.out.println("不同类型");
        }

    }
}

2.2hashCode()方法

public int hashCode(){}
返回该对象的哈希码值
哈希值根据对象的地址或字符串或数字使用hash算法计算出来的int类型的值

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

s1.hashCode();
s2.hashCode();
// 自然不同
Student s3 = s1; // 此时s3的hashCode与s1相同

完整代码

public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("yujian",19);
        Student s2 = new Student("gao",20);

//        hashCode()方法
        System.out.println(s1.hashCode());//1013423070
        System.out.println(s2.hashCode());//380936215

        Student s3 = s1;//s3地址与s1相同
        System.out.println(s3.hashCode());//1013423070

    }
}

2.3 toString()方法

public String toSring(){}
返回该对象的字符串表示（表现形式）

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

sout(s1.toString()); // 直接打印包+类名+哈希值
// 在Eclipse重写 alt + enter + s
// 在idea中从写 Alt +Insert
@override
public String toString(){
  return "Student [name = " + name + ", age = " + age + "]";
}

完整代码

public class Student {
        private String name;
        private int age;

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

    @Override
    public String toString() {
        return name+" "+age;
    }

}


//测试类
public class TestStudent {
    public static void main(String[] args) {
        Student s1 = new Student("yujian",19);
        Student s2 = new Student("gao",20);
        
        //toString()方法
        System.out.println(s1.toString());
        System.out.println(s2.toString());

    }
}

2.4equals()方法

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

public class Student {
        private String name;
        private int age;


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


    @Override
    public boolean equals(Object obj) {
        //1.判断2个对象是否为同一个引用
        if (this ==obj){
            return true;
        }
        //2.判断object是否为null
        if (obj==null){
            return false;
        }
        //3.判断是否是同一个类型
//        if (this.getClass() ==obj.getClass()){
//            return true;
//        }
        //instanceof 可以判断对象是否是某种类型
        if (obj instanceof Student){
            //类型转换
            Student s = (Student) obj;
            //比较
            if (this.name.equals(s.getName())&&this.age==s.age){
                return true;
            }
        }
        return false;
    }
}

//测试类
public class TestStudent {
    public static void main(String[] args) {
        //1.getClass()方法
        Student s1 = new Student("yujian",19);
        Student s2 = new Student("gao",20);

        //4.equals()方法：判断2个对象是否相等
        System.out.println(s1.equals(s2));

        Student s4 = new Student("小明",17);
        Student s5 = new Student("小明",17);

        System.out.println(s4.equals(s5));

    }
}

2.5 finalize()方法

当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列
垃圾对象：没有有效引用指向此对象时，为垃圾对象
垃圾回收：由gc销毁垃圾对象，释放数据存储空间
自动回收机制：JVM的内存耗尽，一次性回收所有垃圾对象
手动回收机制：使用System.gc();通知JVM执行垃圾回收

@Override
protected void finalize() throws Throwable{
  sout(this.name + "对象被回收了");
}

psvm(String[] args){
  Student s1 = new Student("aaa", 29); // 不是垃圾
  new Student("bbb", 30); // 是辣鸡 会被回收
  //回收垃圾
  System.gc();
  sout("回收垃圾"); 
  // 打印出 “回收垃圾 
  //         aaa对象被回收了”
}

3.包装类

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

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

3.1类型转换和封箱、拆箱

将基本类型转换为引用类型为封箱，将引用类型转换为基本类型为拆箱

8种包装类提供不用类型间的转换方式
1. Number父类中提供的6个共性方法
  \2. parseXXX( )静态方法
  \3. valueOf( )静态方法
注意：需保证类型兼容，否则抛出NumberFormatException异常

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+" "+integer2);
        System.out.println();
        //基本类型：拆箱：引用类型转换为基本类型
        System.out.println("拆箱");
        Integer integer3 = new Integer(100);
        int num2 = integer3.intValue();
        System.out.println(num2);
        System.out.println();

//        JDK1.5之后，提供自动装箱和拆箱
        int age = 20;
        //自动装箱
        System.out.println("自动装箱");
        Integer integer4 = age;
        System.out.println(integer4);
        //自动拆箱
        System.out.println("自动拆箱");
        int age2 = integer4;
        System.out.println(age2);
        System.out.println();
        //基本类型与字符串类型之间的转换

        System.out.println("=====基本类型与字符串类型之间的转换=====");
        //1.基本类型转换为字符串
        int n1 = 15;
        //1.1使用+号
        String s1 = n1+"";

        //1.2使用Interger中的toString()方法
        String s2 = Integer.toString(n1);
        String s3 = Integer.toString(n1,2);//radix表示想要转换为几进制的
        System.out.println(s1+" "+s2+" "+s3);
        System.out.println();
        //2.字符串类型转化为基本类型
        String str="155";
        //使用Interger.parseXXX();  XXX为你要转换为哪种基本类型
        int a1 = Integer.parseInt(str);
        System.out.println(a1);

        //boolean字符串形式转换为基本类型："true"--->true 非"true"--->false
        String str2 = "true";
        String str3 = "truaa";
        boolean a2 = Boolean.parseBoolean(str2);
        boolean a3 = Boolean.parseBoolean(str3);
        System.out.println(a2+" "+a3);
    }
}

3.2整数缓冲区

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

public class Demo02 {
    public static void main(String[] args) {

        Integer integer1 = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer1 == integer2);//比较的是地址 false

        Integer integer3 = Integer.valueOf(100);//自动装箱 //自动装箱调用的是Integer.ValueOf
        Integer integer4 = 100;
        System.out.println(integer3 == integer4);//true

        Integer integer5 = 200;//自动装箱
        Integer integer6 = 200;

        //Integer的范围在-128~127，当范围超出，会创建新的对象，所以integer5和interger6是2个对象，所以是false
        System.out.println(integer5 == integer6);

    }
}

4 String类

字符串是常量，创建之后不可改变
字符串字面值存储在字符串池中，可以共享
String s = "Hello";产生一个对象，字符串池中存储
String s = new String("Hello"); 产生两个对象，堆、池各一个

public class Demo03 {
    public static void main(String[] args) {
        //不可变性
        String name = "hello"; //"hello" 常量存储在字符串池当中
        name = "yujian"; //"yujian" 赋值给name变量，给字符串赋值时，没有修改原来数据，而是重新开辟一个空间

        //演示字符串的另一种创建方式 new String()
        String java = new String("java");
    }
}

4.1常用方法

// 1. length(); 返回字符串长度
// 2. charAt(int index); 返回某个位置的字符
// 3. contains(String str); 判断是否包含某个字符串

String content = "java是最好的语言, java no1";
sout(content.length()); // 10
sout(content.charAt(content.length() - 1)); // 言
sout(content.contains("java")); // true

// 4. toCharArray(); 返回字符串对应数组 
// 5. indexOf(); 返回子字符串首次出现的位置
// 6. lastIndexOf(); 返回字符串最后一次出现的位置

sout(content.toCharArray());
sout(content.indexOf"java")); // 0
sout(content.indexOf("java", 4)); // 从索引4开始找 返回12
sout(content.lastIndexOf("java")); // 12

// 7. trim(); //去掉字符串前后空格
// 8. toUpperCase(); toLowerCase(); 转换大小写
// 9. endWith(str); startWith(str);  判断是否以str 结尾、开头

String ct = " hello world ";
sout(ct.trim()); // "hello world"
sout(ct.toUpperCase()); // HELLO WORLD
sout(ct.toLowerCase()); // hello world
sout(ct.endWith("world")); // true
sout(ct.startWith("hello")) // true
  
// 10. replace(char old, char new); 用心的字符或字符串替换旧的字符或字符串
// 11. split(); 对字符串拆分

sout(content.replace("java", "php")); // php是最好的语言, php no1

String say = "java is the best language";
String[] arr = arr.say.split(" "); // "[ ,]+" 表示空格 逗号切分 +号表示切分可以多个 比如多个空格
sout(arr.length); // 5
for(String string : arr){
  sout(string);
}
// 打印出 
//java
//is
//the 
//best
//language

// 补充两个equals/compareTo();比较大小
String s1 = "hello";
String s2 = "HELLO";
sout(s1.equalsIgnoreCase(s2));// 忽略大小写比较true

// compareTo(); 两字符不同时比较字符字典序的ascii码
// 字符相同时比较长度 返回差值

4.2案例演示

需求：

已知String str = "this is a text";
将str中的单词单独获取
将str中的text替换成practice
在text前面插入一个easy
将每个单词的首字母改为大写

package com.class_class.usually_class;

public class Test {
    public static void main(String[] args) {
        //1
        String str = "this is a text";

        //2
        String[] arrs = str.split(" ");
        for (String arr : arrs){
            System.out.println(arr);
        }
        //3
        str = str.replace("text","practice");
        System.out.println(str);

        // 4.
        String str3 = str.replace("text", "easy text");

        //5
        for(int i = 0; i < arrs.length; i ++){
            char first = arrs[i].charAt(0);
            char upperfirst = Character.toUpperCase(first);
            String newstr= upperfirst + arrs[i].substring(1);
            System.out.print(newstr+" ");
        }
    }
}

4.3可变字符串

StringBuffer : 可变长字符串，运行效率慢、线程安全
StringBuilder : 可边长字符串、运行快、线程不安全

效率都比String高且节省内存

package com.class_class.usually_class.demo;

import javax.swing.*;

/**
 * StringBuffer and StringBuilder 的使用
 * @author gyj
 */
public class Demo04 {
    public static void main(String[] args) {
//        StringBuffer sb = new StringBuffer();
        StringBuilder sb = new StringBuilder();

        //1 append();追加
        sb.append("java");
        sb.append("java天下");
        System.out.println(sb.toString());

        //insert() 添加(可在任意位置添加)
        sb.insert(0,"Start:");
        System.out.println(sb.toString());

        //replace(int Start,int End,str string) 替换
        sb.replace(6,10," Spring ");
        System.out.println(sb.toString());

        //delete 删除
        sb.delete(0,6);
        System.out.println(sb);

        //清空
        sb.delete(0,sb.length());
        System.out.println(sb.length());
    }
}

5 BigDecimal类

位置 java.math 包中
作用精确计算浮点数
创建方式 BigDecimal bd = new BigDecimal("1.0");
当除法除不尽的时候
除法：divide(BigDecimal bd, int scal, RoundingMode mode)
参数scal：指定精确到小数点后几位(保留几位小数)
参数mode：
- 指定小数部分的取舍模式，通常采用四舍五入的模式
- 四舍五入的取值为：BigDecimal.ROUND_HALF_UP

package com.class_class.usually_class.demo;

import java.math.BigDecimal;

public class Demo05 {
    public static void main(String[] args) {
        //bigDecimal,大的浮点数精确计算
        BigDecimal bd = new BigDecimal("1.0");
        BigDecimal bd1 = new BigDecimal("0.9");
        //减法
        System.out.println(bd.subtract(bd1));
        //加法  乘法
        System.out.println(bd.add(bd1));
        //除法 divvide(第一个参数:除以的数或变量，第二个参数:保留的位数,第三个参数:选用方法（如：BigDecimal.ROUND_HALF_UP四舍五入）)
        BigDecimal bd3 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println(bd3);


    }
}

6 Data类(现在基本不用了)

Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代

时间单位：1s = 1,000ms = 1,000,000 μs = 1,000,000,000 = ns

psvm(String[] args){
  // 1 创建Date对象
  Date date1 = new Date();
  sout(date1.toString()); //WED Sept 02 22:25:23 CST 2020
  sout(date1.toLocaleString()); // 已过时 但也能用 2020-9-2
  
  // 创建昨天的
  Date date2 = new Date(date1.getTime() - (60*60*24*1000));
  sout(date2.toLocaleString());
  
  // 2 方法after before
  boolean b1 = date.after(date2);
  sout(b1); //true
  boolean b2 = date1.before(date2);
  sout(b2); //false
  
  // 比较compareTo();
  int d = date1.compareTo(date1);
  sout(d); // 多的为1 少的为 -1 
  
  // 比较是否相等 equals()
  boolean b3 = date1.equals(date2);
  sout(b3); // false
}

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

package com.class_class.usually_class.demo;

import java.util.Calendar;

public class Demo06 {
    public static void main(String[] args) {
        //1.创建Calendar对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance.getTime()); //Wed Aug 11 14:48:07 CST 2021

        //2.获取时间信息
        //获取年
        int year = instance.get(Calendar.YEAR);
        System.out.println(year); //2021
        //获取月
        int month = instance.get(Calendar.MONTH);
        System.out.println(month);
        //获取日
        int day = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
        //小时
        int hour = instance.get(Calendar.HOUR_OF_DAY);//24小时
        int hour1 = instance.get(Calendar.HOUR);//12小时
        System.out.println(hour+" "+hour1);
        //分钟
        int minute = instance.get(Calendar.MINUTE);
        System.out.println(minute);
        //秒
        int second = instance.get(Calendar.SECOND);
        System.out.println(second);

        //修改时间
        Calendar instance1 = Calendar.getInstance();
        instance1.set(Calendar.DAY_OF_MONTH,10);
        System.out.println(instance1.getTime());

        // add 方法修改时间  instance1.add(Calendar.HOUR, x); // x为正就加 负就减
        instance1.add(Calendar.HOUR,1);
        System.out.println(instance1.getTime());

        //补充方法
        int max = instance1.getActualMaximum(Calendar.DAY_OF_MONTH);
        int min = instance1.getActualMinimum(Calendar.DAY_OF_MONTH);
        System.out.println(max+" "+min);
    }
}

8 SimpleDateFormat类

SimpleDateFormat是一个以与语言环境有关的方式来格式化和解析日期的具体类
进行格式化（日期→文本）、解析（文本→日期）
常用的时间模式字母

字母	日期或时间	示例
y	年	2021
08	年中月份	08
d	月中天数	11
H	一天中小时（0-23）	17
m	分钟	16
s	秒	59
S	毫秒	356

package com.class_class.usually_class.demo;

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对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        //2.创建一个Date
        Date date = new Date();
        //3.格式化date（把日期转成字符串）
        String str = sdf.format(date);
        System.out.println(str);
        //解析（把字符串转成日期）
        Date date2 = sdf.parse("1990年05月01日07:07:07");
        System.out.println(date2);
    }
}

9 System类

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

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

package com.class_class.usually_class.demo;

public class Demo08 {
    public static void main(String[] args) {
        //1.arraycopy:数组复制
        //arraycopy(src,srcPos,dest,destPos,length)
        //src:原数组，srcPos：从哪个位置开始复制(0),dest:目标数组,destPos:目标数组的位置，length:复制的长度
        int[] arr = {20,18,38,19,26,8,11,90};
        int[] dests = new int[8];
        System.arraycopy(arr,4,dests,4,arr.length-4);
        for (int dest:dests){
            System.out.print(dest+" ");
        }
        System.out.println("======================");
        //2.获取毫秒数
        System.out.println(System.currentTimeMillis());

        long start = System.currentTimeMillis();
        for (int i =-999999;i<99999999;i++){
            for (int j = -999999;j<99999999;j++){
                int result = i+j;
            }
        }
        long end = System.currentTimeMillis();
        System.out.println("用时："+(end-start));

        //System.gc();

        //4.退出jvm
        System.exit(0);

        System.out.println("000");

    }
}

posted @ 2021-08-09 22:16 GD1_1DG 阅读(36) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

GD1_1DG

Java常用类

1.0 常用类

1.内部类

1.1成员内部类

1.2静态内部类

1.3局部内部类

1.4匿名内部类

2.Object类

2.1getClass()方法

2.2hashCode()方法

2.3 toString()方法

2.4equals()方法

2.5 finalize()方法

3.包装类

3.1类型转换和封箱、拆箱

3.2整数缓冲区

4 String类

4.1常用方法

4.2案例演示

4.3可变字符串

5 BigDecimal类

6 Data类(现在基本不用了)

7 Calendar类

8 SimpleDateFormat类

9 System类

公告