JAVA常用类

一、内部类

• 在一个类的内部再完整地定义一个完整的类
• 编译后可生成独立的字节码文件
  • 
• 内部类可以直接访问外部类的私有成员，而不破坏封装

public class Demo01 {

    private String name;

    //内部类
    class Head {

        public void show() {
            //访问外部的private属性
            System.out.println(name);
        }
        
    }

• 可为外部类提供必要的内部功能组件

1. 成员内部类

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

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

  •     //先实例化外部类
    	Demo02 outer = new Demo02();
        //再用外部类对象去实例化内部类
        Demo02.Inner inner = outer.new Inner();
    

public  class Demo02 {

    //属性、实例变量
    private String name = "张三";
    private int age = 20;

    //内部类
    public  class Inner {
        private String address = "北京";
        private String phone = "110";

        //内部类的方法
        public void show(){
            //打印外部类中的属性
            System.out.println(name);
            System.out.println(age);
            //打印内部类中的属性
            System.out.println(address);
            System.out.println(phone);
        }
    }


    public static void main(String[] args) {
        //先实例化外部类
        Demo02 outer = new Demo02();
        //再用外部类对象去实例化内部类
        Demo02.Inner inner = outer.new Inner();

        inner.show();
    }


}

• 当外部类、内部类存在重名属性时，会优先访问内部类属性
  • 要想访问外部类用<外部类名>.<内部类名>.<属性名>

public  class Demo02 {

    //属性、实例变量
    private String name = "张三（外部类）";
    private int age = 20;

    //内部类
    class Inner {

        private String name = "李四（内部类）";
        private int age = 21;
        private String adress = "北京（内部类）";

        private static final String country = "中国";

        //内部类的方法
        public void show(){

            System.out.println(Demo02.this.name);
            System.out.println(name);
            //外部类属性和内部类崇明
            System.out.println(age);
            System.out.println(adress);

        }
    }
}

public class Test {

    public static void main(String[] args) {
        Demo02 outer = new Demo02();
        Demo02.Inner inner = outer.new Inner();
        //调用方法
        inner.show();

    }

}

• 成员类不能定义静态成员

  • private static String country = "中国";//报错
    

  • 但可以包括静态常量

  • private static final String country = "中国";
    

2. 静态内部类

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

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

  • 相当于一个外部类

    public class Demo03 {
        private String name = "xxx";
        private int age = 18;
    
        //静态内部类——和外部类相同
        static class Inner {
            private String adress = "上海";
            private String phone = "111";
            //静态成员
            private static int count = 1000;
    
            public void show() {
                //调用外部类的属性
    
                //1.先创建外部类对象
                Demo03 outer = new Demo03();
                //2.再调用外部类对象的属性
                System.out.println(outer.name);
                System.out.println(outer.age);
                //3.再调用静态内部类的属性
                System.out.println(adress);
                System.out.println(phone);
    
            }
    
        }
    
    }
    
    public class Test {
    
        public static void main(String[] args) {
            Demo03.Inner inner = new Demo03.Inner();
            //调用方法
            inner.show();
    
        }
    
    }
    /*
            xxx
            18
            上海
            111
     */
    

3. 局部内部类

• 和局部变量等级相同，所以可以访问外部类属性

• 局部内部类不能加任何访问修饰符

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

• 局部内部类必访问当前方法中的局部变量时，变量必须修饰为final

• 不能包含静态的成员（属性）

• 限制类的适用范围（只能在当前方法中使用）

//外部类
public class Demo04 {
    private String name = "张三";
    private int age = 25;

    //show方法
    public void show() {
        //定义一个局部变量

        final String address = "深圳";

        //局部内部类
        class Inner {

            private String phone = "1558888888";
            private String email = "1558888888@askdm.com";

            //局部内部类方法
            public void showin(){
                //访问外部类属性
                System.out.println(Demo04.this.name);
                System.out.println(Demo04.this.age);
                //访问内部类属性
                System.out.println(this.phone);
                System.out.println(this.email);
                //在showin中访问局部变量——常量jdk1.7
                //jdk1.8中引用会自动添加final——运行时变成常量
                System.out.println(address);
            }

        }

        Inner inner = new Inner();
        inner.showin();

    }

}

4. 匿名内部类

4.1 例1

• 创建一个类mouse调用usb接口，运行usb中的service方法

• 改写成局部内部类

• 改写成匿名内部类

二、object类

1. Object类常用方法

1. Getcalss

• 用于判断对象是否是同一个

1.1 例子

• 创建一个学生类，含有名字年龄属性
• 学生类对象引用，比较两者getClass的对象

public class Test {

    public static void main(String[] args) {
        Student s1 = new Student("小明",20);
        Student s2 = new Student("小红",22);

        Class class1 = s1.getClass();
        Class class2 = s1.getClass();

        if (class1==class2){
            System.out.println("1");
        }else {
            System.out.println("2");
        }

    }

}

2. hashCode()方法

• 判断两个对象是否是同一个

public class Test {

    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Teacher t2 = new Teacher();

        System.out.println(t1==t2);//false

        Teacher t3 = t1;
        //t3不是new的，没有创建新地址
        System.out.println(t3==t1);//true

    }

}

3. toString方法

• 重写toString方法

public class Test {

    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Teacher t2 = new Teacher();

        System.out.println(t1.hashCode());//460141958
        System.out.println(t1.toString());
        //com.classdemo.Teacher@1b6d3586
        //1b6d3586是460141958的十六进制数
    }

}

3. equals方法

• 用于判断两个对象是否相等

  • s1 = s2？
  • s1 = ”abc“ ,s2 ="abc"?
  • 和”==“的区别？s1.equals("abc")

• this可以指代对象

• 重写equals，改为比较两个对象的内容

  

4. finalize方法

• 重写finalize方法验证
  • 在其中写一个print，验证是否执行了

四、包装类

• 基本数据类型对应的引用数据类型
  • 栈中
    • 基本类型——没有任何属性和方法，只能通过运算符操作
    • 引用类型的地址
  • 堆中
    • 引用类型
• Object可同一所有数据，包装类默认值是null
  • 

1. 装箱与拆箱

• 拆箱

  • 引用类型---->基本类型——如Integer ------>int

• 装箱

  • 基本类型---->引用类型——如 int ------>Integer

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

        int age = 10;

        System.out.println("***********装箱************");
        //装箱——基本类型 to 引用类型

        //法1.调用构造器
        Integer integer = new Integer(age);
        System.out.println(integer);

        //法2.使用Interger类中的valueof方法
        Integer integer1 = Integer.valueOf(age);
        System.out.println(integer1);

        System.out.println("*********自动装箱**********");
        Integer integer4 = age;
        System.out.println(integer4);

        System.out.println("***********拆箱************");
        //拆箱——引用类型 to 基本类型
        Integer integer3 = new Integer(age);
        //使用Interger类中的intValue方法
        int num = integer3.intValue();
        System.out.println(num);

        System.out.println("*********自动拆箱**********");
        int num2 = integer4;
        System.out.println(num2);

    }

}
/*

***********装箱************
10
10
***********拆箱************
10
*********自动装箱**********
10
*********自动拆箱**********
10

*/

• JDK1.5以后可以自动装箱拆箱，在class文件中，系统会自动调用valueof方法

2. 8种包装类不同类型的转换方式

• 装箱
  • 基本类型 ----> String——valueof静态方法、parseXXX静态方法
• 拆箱
  • String ----> 基本类型——toString方法
• 需要保证类型兼容，否则抛出异常

public class Demo06 {

    public static void main(String[] args) {

        int phoneNum = 110;

        //装箱——基本类型 ---> String
        System.out.println("************装箱***********");
        String stringNum = Integer.toString(phoneNum);
        System.out.println(stringNum);

        //装箱——String ---> 基本类型
        System.out.println("************拆箱***********");
        int intNum = Integer.valueOf(stringNum);
        int intNum2 = Integer.parseInt(stringNum);
        System.out.println(intNum);
        System.out.println(intNum2);

    }

}
/*
        ************装箱***********
        110
        ************拆箱***********
        110
        110
 */

• valueof和parselnt都可以把string转换成int型，有什么区别？

  • 1. 返回值不同

       parseInt 返回值是int型
       valueof 返回值是Integer型

    2. valueof就是调用了parseInt方法的

    3. parseInt效率比valueof效率高

3. 整数缓冲区

• Java预先创建了256个常用整数包装类型对象
• 在实际应用中对已创建的对象进行复用——因为这256个对象使用频率很高，避免浪费内存

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

        Integer integer = new Integer(100);
        Integer integer2 = new Integer(100);
        System.out.println(integer==integer2);//false
        //new对象，在堆中分别开辟了integer和integer2两个空间

        //integer cache
        //-128<=i<=127
        Integer integer3 = 100;//自动装箱
        Integer integer4 = 100;
        System.out.println(integer3==integer4);//true

        //i<-128 || i>127
        Integer integer5 = 200;//自动装箱
        Integer integer6 = 200;
        System.out.println(integer5==integer6);//flase

    }
}

• 在Integer缓冲区中-128~127的创建了一个数组，并且已经都实例化了
• 因此Integer类型的数-128~127地址相同

• 而不在-128~127的数，则会返回开辟一个新空间

五、String类

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

1. 创建一个字符串变量的两种方式

• 字面值创建

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

        //1.字面值创建
        String name = "hello";
        //张三赋值给name变量，给字符串赋值时，并没有修改数据，重新开辟一个空间
        name = "zhangsan";

    }
}

• 调用构造器去创建

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

        //2.调用构造器去创建
        //会创建在堆和常量池中各创建一个对象——浪费空间
        String str1 = new String("java");
        String str2 = new String("java");

        //str2和str3是两个对象，在堆中是两个地址，==比较的是地址
        System.out.println(str2==str3);//false
        //因此字符串比较使用equals
        System.out.println(str2.equals(str3));//true

    }
}

2.常用方法

2.1 length

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

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

        String str = "Hello，world!";

        //1.public int length();
        //一个字符算1个，空格也是一个字符
        System.out.println(str.length());//12
    }
}

2.2 charAt

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

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

        String str = "Hello，world!";

        //返回某个位置的字符,字符串位置从0开始，因此求角标要用长度要-1
        System.out.println(str.charAt(str.length()-1));
        //超出长度会抛出异常
//        System.out.println(str.charAt(str.length()));

    }
}

2.3 cotains

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

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

        String str = "Hello，world!";

        System.out.println(str.contains("hello"));//false
        System.out.println(str.contains("He"));//true

    }
}

2.4 CharArray

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

public class Demo07 {

    public static void main(String[] args) {

        String str = "Hello,world!加油学习java";

        //4.public char[] toCharArray()——返回字符串中对应的数组
        //toCharArray方法输出的是数组，Arrays.toString方法输出数组
        System.out.println(Arrays.toString(str.toCharArray()));
        //[H, e, l, l, o, ,, w, o, r, l, d, !, 加, 油, 学, 习, j, a, v, a]  
    }
}

2.5 indexOf

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

public class Demo07 {

    public static void main(String[] args) {

        String str = "Hello,world!加油学习java";

        //5.public in indexOf(String str)——返回字符串首次出现的位置
        System.out.println("toCharArray:"+str.indexOf("l"));//2——从0开始
        System.out.println("toCharArray:"+str.indexOf("l",4));//9——从4开始
       
    }

}

2.6 lastIndexOf

• 查找字符串在当前字符串中最后一次出现的下标索引
• public in lastIndexOf(String str)

public class Demo07 {

    public static void main(String[] args) {

        String str = "Hello,world!加油学习java";

        //6.public in lastIndexOf(String str)——返回字符串最后一次出现的位置
        System.out.println("lastIndexOf:"+str.lastIndexOf("学习"));//14
       
    }

}

2.7 trim

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

    public static void main(String[] args) {

        String str = "     Helloworld!       加油学习java     ";
        //startWith()——判断是否以str开始

        //trim()——去掉字符串后的空格
        System.out.println(str.trim());//Helloworld!       加油学习java
        //去掉中间空格可以用replace
	}

2.8 toUpperCase

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

    public static void main(String[] args) {

        String str = "     Helloworld!       加油学习java     ";

        //toUpperCase()——把小写转成大写
        System.out.println(str.toUpperCase());//     HELLOWORLD!       加油学习JAVA
        //str由final修饰，具有不可变性，因此不会改变str的值

        //toLowerCase()——把大写转成小写
        System.out.println(str.toLowerCase());//     helloworld!       加油学习java

    }
}

2.9 endWith

• 判断字符串是否是以str结尾的
• public boolean endWith(String str)

    public static void main(String[] args) {
        
        String filename = "hello.java";
        //endWith()——判断是否以str结尾
        System.out.println(filename.endsWith(".java"));
        System.out.println(filename.startsWith("hello"));

    }
}

2.10 replace

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

public class Demo09 {
    public static void main(String[] args){
        //replace(char old,char new) 用新的字符/字符串 替换 某个字符/字符串
        //split();对字符串进行拆分

        String str = "Helloworld!";
        str.replaceAll("world","kitty");
        System.out.println(str);//Helloworld!——字符串不可变性

        String str1 = str.replaceAll("world","kitty");
        System.out.println(str1);//Hellokitty!

    }
}

2.11 split

• public String[] split(String str)

• 根据str做拆分

public class Demo09 {

    public  static void main(String[] args) {

        String say = "java is the best programing language";
        String[] arr = say.split(" ");

        System.out.println(arr.length);//6——数组长度

        for (String s : arr) {
            System.out.println(s);
            //java
            //is
            //the
            //best
            //programing
            //language
        }

    }

}

• 如存在多个符号如何分割——[]

public class Demo09 {

    public static void main(String[] args) {

        String say = "java is the best programing language, Xiao ming";
        String[] arr = say.split("[ ,]+");
        //[]表示选择，这样” “和”，“就都可以分割
        //+表示前面的[ ,]可以同时出现多个，都作为分隔符

        System.out.println(arr.length);//9——数组长度

        for (String s : arr) {
            System.out.println(s);
            //java is the best programing
            // language
        }

    }

2.12 equals

• 比较两个字符串是否相等

public class Demo10 {

    public static void main(String[] args) {

        String s1 = "hello";
        String s2 = "HELLO";

        System.out.println(s1.equals(s2));//false
        System.out.println(s1.equalsIgnoreCase(s2));//true——忽略大小写

    }

}

2.13 compareTo

• 两个字符串比较大小（字典表的顺序——ascii码）

public class Demo10 {

    public static void main(String[] args) {

        String s1 = "abc";//a=97
        String s2 = "xyz";//y=120
        String s3 = "azz";//z=121

        //比较字符串第一个字符ascii码
        System.out.println(s1.compareTo(s2));//-23
        System.out.println(s1.compareTo(s3));//-24
        
    }

}

• 特殊的

public class Demo10 {

    public static void main(String[] args) {

        String s5 = "abc";//length = 3
        String s6 = "abcxyz";//length = 6

        //当abc都相同，一个字符串没有字符了，比较字符串长度
        System.out.println(s5.compareTo(s6));//-3

    }

}

3. 案例演示

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

        String str = "this is a text";
        //1.单词单独获取
        String[] array = str.split(" ");
        System.out.println(Arrays.toString(array));
        System.out.println("********************");
        //2.practice to text
        String str2 = str.replace("text","practice");
        System.out.println(str2);
        System.out.println("********************");
        //3.在text前插入easy
        String str3 = str.replace("text","easy text");
        System.out.println(str3);
        System.out.println("********************");
        //4.所有单词首字母大写
        for (int i = 0; i < array.length; i++) {
            char first = array[i].charAt(0);
            first = Character.toUpperCase(first);
            array[i] = first + array[i].substring(1);
        }
        System.out.println(Arrays.toString(array));

        //5.用数组实现功能3：在text前插入easy
        System.out.println("*********数组扩容初始化*******");
        String temp;
        String[] array2 = new String[array.length+1];
        for (int i = array.length-1; i >= 0; i--) {
            array2[i+1] = array[i];
        }
        array2[0] = "Practice";
        System.out.println(Arrays.toString(array2));

        for (int i = 0; i < array2.length-1; i++) {
            if (array2[i+1].equals("Text")) {
                break;
            }
            temp = array2[i+1];
            array2[i+1] = array2[i];
            array2[i] = temp;
        }
        System.out.println(Arrays.toString(array2));
    }
}

六、bigDecimal类

• double近似存储，不能准确地用于计算
• 用BigDecimal可代替double类型的数值进行精确计算
  • java.math包中
  • 可进行加减乘除运算
• 使用在除法时若结果为除不尽的数使用ROUND_HALF_UP进行四舍五入

package com.classdemo;

import java.math.BigDecimal;

public class Demo10 {
    public static void main(String[] args) {
        //计算1.0-0.9的值
        double a = 1.0;
        double b = 0.9;
        double result = a-b;//0.09999999999999998
        System.out.println(result);

        //因为double是近似值，不要用浮点数比较
        //用构造器初始化m的值
        BigDecimal m = new BigDecimal("1.0");
        BigDecimal n = new BigDecimal("0.9");

        //1.0-0.9
        BigDecimal result1 = m.subtract(n);
        System.out.println("1.0-0.9="+result1);//0.1

        //1.0+0.9
        BigDecimal result2 = m.add(n);
        System.out.println("1.0+0.9="+result2);

        //1.0*0.9
        BigDecimal result3 = m.multiply(n);
        System.out.println("1.0*0.9="+result3);

        //1.0/0.9
        //不能直接这么比较，因为除不尽，用四舍五入的方法
//        BigDecimal result4 = m.divide(n);
        //2是保留精度，ROUND_HALF_UP为四舍五入
        BigDecimal result4 = m.divide(n,2,BigDecimal.ROUND_HALF_UP);
        System.out.println("1.0/0.9="+result4);

        //(1.6-0.4)/0.7
        //不实例化对象
        BigDecimal result5 = new BigDecimal("1.6")
                .subtract(new BigDecimal("0.4"))
                .divide(new BigDecimal("0.7"),2,BigDecimal.ROUND_HALF_UP);
        System.out.println("(1.6-0.4)/0.7="+result5);
    }
}

七、Date类

1.构造方法

• Date()
  • 无参构造，显示当前时间

import java.util.Date;

public class Demo11 {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println(date);
    }
}
/*
    Tue Oct 13 16:43:05 CST 2020
 */

• Date(long date)
  • 有参构造，从Unix诞生时间1970.1.1为起始时间
  • 因为中国处于东八区，所以时间会比标准时间早8小时，而标准时间应该是1970-01-01 00:00:00。

public class Demo11 {
    public static void main(String[] args) {
        long a = 1;
        Date date = new Date(a);
        System.out.println(date);
    }
}
/*
    Thu Jan 01 08:00:00 CST 1970
 */

2. 方法

• toString

  • toLocaleString 已过时

• getTime

• after、before 返回布尔值

• compareTo 比较

• equals

import java.util.Date;

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

        //今天
        Date today = new Date();
        System.out.println(today);
        //Tue Oct 13 17:18:34 CST 2020
        System.out.println(today.toString());
        //Tue Oct 13 17:08:58 CST 2020
        System.out.println(today.toLocaleString());
        //2020-10-13 17:11:35


        //昨天
        Date yesterady = new Date(today.getTime()-1000*60*60*24);
        System.out.println(yesterady.toLocaleString());
        //2020-10-12 17:18:34

        //after
        boolean a = today.after(yesterady);
        System.out.println(a);//true

        //before
        boolean b = today.before(yesterady);
        System.out.println(b);//false

        //compareTo
        System.out.println(today.compareTo(yesterady));//1
        System.out.println(today.compareTo(today));//0
        System.out.println(yesterady.compareTo(today));//-1

        //equals
        System.out.println(today.equals(yesterady));//false
        System.out.println(today.equals(today));//true

    }
}

八、Calendar类

1. 构造方法

• protected修饰 不能直接用构造器创建对象
  • 用getInstance()代替

2. 方法

• getInstance() 代替Calendar构造器
• getTime() 获取时间信息
• getTimeMillies() 获取时间毫秒
• toString()
• get(int field)
• add(int field,int account) 修改Calendar中的属性，加上account
• set(int field,int account) 修改Calendar中的属性，改为account

import java.util.Calendar;

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

        //1.获取日历时间
        //由于Calendar类的构造器由protected修饰，不知直接new对象
        //用getInstance()方法代替
        Calendar calendar = Calendar.getInstance();

        //2.输出日历
//        System.out.println(calendar);//直接输出信息过多
        System.out.println(calendar.getTime());//只获取时间信息
        //Tue Oct 13 19:14:36 CST 2020
        System.out.println(calendar.getTime().toString());//此日期的字符串表示形式。
        //Tue Oct 13 19:14:36 CST 2020
        System.out.println(calendar.getTime().toLocaleString());//此方法已过时
        //2020-10-13 19:15:32
        System.out.println(calendar.getTimeInMillis());//从1970年至今的毫秒值
        //1602579104777

        //3.设置时间
        //不能直接int year = calendar.YEAR;
        //因为Calendar类YEAR这个属性值为1，直接赋值year就为1了
        int year =  calendar.get(Calendar.YEAR);
        int month =  calendar.get(Calendar.MONTH);//获取的Month值为0-11
        int day =  calendar.get(Calendar.DATE); //等价于DAY_OF_MONTH
        int hour =  calendar.get(Calendar.HOUR);
        int minute =  calendar.get(Calendar.MINUTE);
        int second =  calendar.get(Calendar.SECOND);
//        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
        //2020年10月13日7时34分57秒

        //4.修改时间
        calendar.add(calendar.HOUR,-3);//程序顺序执行，并不会修改hour的值
        System.out.println(calendar.getTime().toLocaleString());
        //2020-10-13 16:48:58
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+hour+"时"+minute+"分"+second+"秒");
        //2020年10月13日7时48分58秒

        //5.获取属性的最大值与最小值
        int max = calendar.getActualMaximum(Calendar.MONTH);
        int min = calendar.getActualMinimum(calendar.MONTH);
        System.out.println(min+" "+max);

    }
}

九、SimpleDAteFormat

1. 方法

• format
• parse

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo13 {
    public static void main(String[] args) {
        SimpleDateFormat a = new SimpleDateFormat("yyyy/MM/dd");

        Date date = new Date();
        System.out.println(date.toLocaleString());

        //format方法——将对象转换为自定义格式的字符串
        String str = a.format(date);
        System.out.println(str);

        //parse方法——yyyy/mm/dd格式的将字符串转换为日期
        try {
            //只能这种格式，否则会抛出异常
            Date date1 = a.parse("1990/11/10");
        } catch (ParseException e) {
            System.out.println("异常");
        }
    }

}

十、System类

• 其中都是静态的方法

• arraycopy——复制数组
  • Arrays.copyof
  • native方法，和接口一样没有方法体，是调用底层jvm用C/C++实现
• currentTimeMillis——可以用来实现计时
• gc——告诉垃圾回收器回收
• exit——退出jvm

import java.util.Arrays;

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

        //1.arraycopy
        int[] array = {1,2,5,6,5,4,7,3,7};
        int[] array1 = new int[array.length+5];
        //scr 原数组    scrPos开始复制的位置    dest目标数组    destPos目标数组的位置    length复制的长度
        //arraycopy(scr,scrPos,dest,destPos,length);
        System.arraycopy(array,0,array1,0,array.length);
        System.out.println(Arrays.toString(array1));
        //[1, 2, 5, 6, 5, 4, 7, 3, 7, 0, 0, 0, 0, 0]
        array1 = Arrays.copyOf(array,array.length);
        System.out.println(Arrays.toString(array1));
        //[1, 2, 5, 6, 5, 4, 7, 3, 7]

        //2.currentTimeMillis
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1e5; i++) {
            int result = 2*i;
        }
        long end = System.currentTimeMillis();
        System.out.println("运行时长："+(end-start)+"ms");
        //运行时长：7ms

        //3.gc
        new Test1("李四");
        new Test1("张三");
        new Test1("小明");

        System.gc();//建议垃圾回收器回收，但垃圾执行器不一定会回收

        //4.exit
        System.out.println("****************");
        System.exit(0);
        System.out.println("这条语句执行了");
        //没输出

    }
}

JAVA常用类

原文：https://www.cnblogs.com/Sheltonz/p/13821963.html