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 Demo15 {
    public static void main(String[] args) {
        Test1 t1 = new Test1();
        Test1 t2 = new Test1();

        int a = t1.hashCode();
        int b = t2.hashCode();
        System.out.println(a==b?"1":"0");//0
    }
}

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

    }

}

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地址相同

2020-09-25_154133

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

2020-09-25_154134

五、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("这条语句执行了");
        //没输出

    }
}

posted @ 2020-10-15 17:47 球球z 阅读(78) 评论(0) 编辑收藏举报

刷新页面返回顶部

球球z

JAVA常用类

一、内部类

1. 成员内部类

2. 静态内部类

3. 局部内部类

4. 匿名内部类

4.1 例1

二、object类

1. Object类常用方法

1. Getcalss

1.1 例子

2. hashCode()方法

3. equals方法

4. finalize方法

四、包装类

1. 装箱与拆箱

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

3. 整数缓冲区

五、String类

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

2.常用方法

2.1 length

2.2 charAt

2.3 cotains

2.4 CharArray

2.5 indexOf

2.6 lastIndexOf

2.7 trim

2.8 toUpperCase

2.9 endWith

2.10 replace

2.11 split

2.12 equals

2.13 compareTo

3. 案例演示

六、bigDecimal类

七、Date类

1.构造方法

2. 方法

八、Calendar类

1. 构造方法

2. 方法

九、SimpleDateFormat

1. 方法

十、System类

公告