JAVA基础知识学习笔记——常用API

最新推荐文章于 2022-04-04 16:36:53 发布

奚敛锋

最新推荐文章于 2022-04-04 16:36:53 发布

阅读量184

点赞数

本文链接：https://blog.csdn.net/weixin_43544843/article/details/106154206

版权

一.Object类

1.Object类介绍(了解)

java.lang.Object 注意:lang包中的类无需导包可以直接使用
类 Object 是类层次结构的根类(最顶层的类祖宗类)。
每个类都使用 Object 作为超类。任何一个类都直接或者间接的继承了Object类
所有对象（包括数组）都实现这个Object类的方法。任何一个类都可以使用Object类中的方法

2.Object类的toString方法(重点)


import java.util.ArrayList;
import java.util.Random;

/*
    Object类中的常用方法:
        String toString() 返回该对象的字符串表示。
    Object类toString方法的底层源码:
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
        getClass().getName():使用反射技术获取类的全类名(包名+类名)
            com.itheima.demo01toString.Person
        "@" :字符串原样输出,分割的作用
        hashCode():Object类中的方法,可以获取对象的哈希值,哈希值是一个系统随机给出的十进制的整数 123123123
        Integer.toHexString(hashCode());把十进制的整数转换为十六进制 0-9 a-f
   组合在一起: com.itheima.demo01toString.Person@AC123(对象在堆内存中的地址值)
 */
public class Demo01ToString {
    public static void main(String[] args) {
        /*
            Person类默认继承了Object类,所以可以使用Object类中的toString方法
         */
        Person p = new Person("aa",18);
        String s = p.toString();
        System.out.println(s);//com.itheima.demo01toString.Person@4554617c  Person{name = 迪丽热巴 ,age = 18}

        //直接打印对象的名字,就是调用对象的toString方法
        System.out.println(p);//com.itheima.demo01toString.Person@4554617c  Person{name = 迪丽热巴 ,age = 18}

        /*
            注意:
                以后看一个类是否重写toString方法,打印名看看是否为地址值即可(默认调用toString方法)
                    是地址值:类没有重写toString方法
                    不是地址值:类重写了toString方法
         */
        String str = new String("aaa");
        System.out.println(str);//aaa 不是地址值String类重写了toString方法

        Random r =  new Random();
        System.out.println(r);//java.util.Random@74a14482 是地址值,Random类没有重写toString方法

        ArrayList<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        System.out.println(list);//[1, 2]  不是地址值,ArrayList集合重写toString方法
    }
}



//ctrl+鼠标左键点击一个类名或者方法名,就可以进入到类|方法中
public class Person extends Object {
    private String name;
    private int age;

    public Person() {
    }

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

    /*
        Obejct类中的toString方法,默认打印对象的地址值没有意义
        需要重写toString方法,打印对象的属性值(成员变量)
     */
    /*@Override
    public String toString() {
       return "Person{name = "+name+" ,age = "+age+"}";
    }*/

    //快捷键:alt+insert==>toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3.Object类中的equals方法(重点)



import java.util.Random;

/*
    Object类中的方法equals:
        boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。
    Object类中的equals方法的源码:
        public boolean equals(Object obj) {
            return (this == obj);
        }
        ==:比较运算符
            基本数据类型:比较的是值是否相等  10==20
            引用数据类型(数组,集合,类Person):比较的是地址值是否相等  @1ac1==@223
 */
public class Demo01Equals {
    public static void main(String[] args) {
        Student s1 = new Student("aa",35);
        Student s2 = new Student("式",22);
        //使用Object类的toString方法,打印对象的地址值
        System.out.println(s1.toString());//com.itheima.demo02equals.Student@4554617c
        System.out.println(s2.toString());//com.itheima.demo02equals.Student@74a14482
        //使用Object类的equals方法,比较两个对象的地址值是否相等
        boolean b = s1.equals(s2);
        System.out.println(b);//false

        s1=s2;//把s2的地址值赋值给s1
        System.out.println(s1);//com.itheima.demo02equals.Student@74a14482
        System.out.println(s2);//com.itheima.demo02equals.Student@74a14482
        boolean b2 = s1.equals(s2);
        System.out.println(b2);//true

        Student s3 =  new Student("式",18);
        Student s4 =  new Student("工",18);
        System.out.println(s3);//com.itheima.demo02equals.Student@1540e19d
        System.out.println(s4);//com.itheima.demo02equals.Student@677327b6
        Random r = new Random();

        //boolean b3 = s3.equals(s4);
        //boolean b3 = s3.equals(r);
        //boolean b3 = s3.equals(null);
        boolean b3 = s3.equals(s3);
        System.out.println(b3);
    }
}



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

    public Student() {
    }

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

    /*
        比较两个对象的地址值没有意义,所以我们需要重写Object类的equals方法
        比较两个对象的属性(name和age)
     */
    @Override
    public boolean equals(Object obj) {
        /*
            如果obj就是this本身,那么就没有比较在强转进行属性的比较,直接返回true,可以提高效率
         */
        if(obj == this){
            return true;
        }

        /*
            如果obj的值是null,那么直接返回false,可以提高程序的效率
         */
        if(obj==null){
            return false;
        }

        /*
            ClassCastException: java.util.Random cannot be cast to com.itheima.demo02equals.Student
            为了防止类在转换异常,强转之前使用instanceof关键字进行判断
         */
        if(obj instanceof Student){
            /*
                问题:多态==>无法使用子类特有的成员==>需要向下转型
                Object obj = s2 = new Student("韦德",38);
             */
            Student s = (Student)obj;
            //比较this(s1)和s(obj=s2)两个对象的属性name和age
            //             詹姆斯          韦德         35           38
            boolean b = this.name.equals(s.name) && this.age == s.age;
            return b;
        }
        //obj不是Student,直接返回false
        return false;
    }

    //重点:快捷键 alt+insert 重写equals方法
    /*@Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        //getClass() != o.getClass() 使用反射技术判断对象的类型 相当于  obj instanceof Student
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Student student = (Student) o;

        if (this.age != student.age) {
            return false;
        }
        return name != null ? this.name.equals(student.name) : student.name == null;
    }*/


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

4.native本地方法

native修饰的方法:说明这个方法不是java语言编写的

调用的是其他语言编写的代码或者操作系统底层的代码,看不到具体的方法

Object:
public native int hashCode();
public final native Class<?> getClass();

5.Objects对象的工具类(了解)

import java.util.Objects;

/*
    java.util.Objects类:操作对象的工具类,里边的方法都是静态的
    Objects中的方法都是防止空指针异常的
    注意:
        工具类中的方法一般都是静态的,可以通过类名直接使用
    Obejcts工具类中的equals方法
        static boolean equals(Object a, Object b) :判断两个对象是否相等,相等返回true,不相等返回false
    底层源码:
        public static boolean equals(Object a, Object b) {
            return (a == b) || (a != null && a.equals(b));
        }
 */
public class Demo01Objects {
    public static void main(String[] args) {
        //String s1 = "aaa";
        String s1 = null;
        String s2 = "bbb";
        //boolean b1 = s1.equals(s2);// s1=null null是不能调用方法的,会抛出空指针异常NullPointerException
        boolean b1 = s1 != null ? s1.equals(s2) : s2 == null;
        System.out.println(b1);

        boolean b2 = Objects.equals(s1,s2);
        System.out.println(b2); //(s1 == s2) || (s1 != null && s1.equals(s2))
    }
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Student student = (Student) o;

    if (age != student.age) return false;
    return name != null ? name.equals(student.name) : student.name == null;
}

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age &&
            Objects.equals(name, student.name);
}

二.Date类

1.毫秒值的概念和作用(了解)

java.util.Date类:用于描述日期和时间的类
	类 Date 表示特定的瞬间，精确到毫秒。
	1秒=1000毫秒
	1 天 = 24 × 60 × 60 = 86400 秒 = 86400*1000 = 86400000毫秒
-----------------------------------------------
时间原点:0毫秒的时间点
	1970 年 1 月 1 日 00:00:00  英国格林威治时间(世界标准时间)
中国:东八区 时间+8个小时的时差
	1970 年 1 月 1 日 08:00:00
把日期和时间转换为毫秒值:就是时间原点和当前时间的一个差值
	当前时间(2020年4月27日11:26:33)-时间原点(1970年1月1日 00:00:00)=把当前时间转换为毫秒值(12312412514312)
毫秒值的作用:用于对时间进行计算
工作:计算两个时间的差值,把时间转换为毫秒值计算
	"2020年4月27日11:26:33" - "2019年3月5日12:26:33" = 没法计算
	把时间转换为毫秒值,使用毫秒值相减
	15888123123123 - 15734324324233 = 324324毫秒==>转换为时间(324324毫秒/1000/60/60/24)天

2.Date类的构造方法和成员方法(重点)



import java.util.Date;

/*
    java.uti.Date类
    构造方法:
        Date()  重点
        Date(long date) 参数传递毫秒值
    成员方法:
        long getTime() 重点
          返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
        void setTime(long time)
          设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
 */
public class Demo01Date {
    public static void main(String[] args) {
        show04();
    }

    /*
        void setTime(long time) 参数传递毫秒值,把毫秒值转换为Date日期
          设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
        此方法相当于Date类的带参构造方法的作用
           Date(long date) 参数传递毫秒值,把毫秒值转换为Date日期
     */
    private static void show04() {
        Date date = new Date();
        System.out.println(date);//Mon Apr 27 11:43:53 CST 2020

        date.setTime(0L);
        System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
    }

    /*
        long getTime()
          返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
          把当前日期转换为毫秒值(当前日期和时间原点之间共经历了多少毫秒)
     */
    private static void show03() {
        Date date = new Date();
        System.out.println(date);//Mon Apr 27 11:42:35 CST 2020
        long time = date.getTime();
        System.out.println(time);//1587958955907
    }

    /*
        Date类的带参数构造方法:
            Date(long date) 参数传递毫秒值,把毫秒值转换为Date日期
        注意:
            在时间和日期相关的类中,long类型的值传递的就是毫秒值
     */
    private static void show02() {
        Date d1 = new Date(0L);
        System.out.println(d1);//Thu Jan 01 08:00:00 CST 1970

        Date d2 = new Date(31124324324234L);
        System.out.println(d2);//Fri Apr 16 13:38:44 CST 2956
    }

    /*
        Date类的空参数构造方法:
            Date() 获取当前系统的时间和日期
            CST:中国标准时间(北京)
     */
    private static void show01() {
        Date date = new Date();
        System.out.println(date); //Mon Apr 27 11:37:07 CST 2020
    }
}

三.DateFormat类

1.DateFormat类介绍(了解)

java.text.DateFormat类
public abstract class DateFormat extends Format
DateFormat 是日期/时间格式化子类的抽象类==> DateFormat是Format类的子类,DateFormat本身还是一个抽象类
无法直接创建对象使用
作用:
	它以与语言无关的方式格式化并解析日期或时间。
	格式化（也就是日期 -> 文本）
	解析（文本-> 日期）
DateFormat类的成员方法:
	String format(Date date) 传递指定的日期,把日期格式化为符合模式的字符串 
	Date parse(String source) 把符合模式的字符串解析为Date日期
-----------------------------------------------------------------
DateFormat本身还是一个抽象类,无法直接创建对象使用,需要使用DateFormat类的子类创建对象使用
java.text.SimpleDateFormat类 extends DateFormat类
SimpleDateFormat类构造方法
	SimpleDateFormat(String pattern) 
          用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。
   参数:
	 String pattern:传递日期和时间的模式
	 	在模式中写y代表年
        在模式中写M代表月
        在模式中写d代表日
        在模式中写H代表时
        在模式中写m代表分
        在模式中写s代表秒
        在模式中写S代表毫秒
        "yyyy-MM-dd HH:mm:ss"  "2020-04-27 11:57:03"
        "yyyy/MM/dd HH:mm:ss" 
        "yyyy年MM月dd日 HH时mm分ss"
  注意:
	1.表示模式的字母不能改变(y,M...),字母的连接符号可以改变(-,/...)
    2.表示模式的字母严格区分大小写

2.DataFormat类的常用方法(重点)



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

/*
    使用DateFormat类中的常用方法
 */
public class Demo01DateFormat {
    public static void main(String[] args) {
        /*
            String format(Date date) 传递指定的日期,把日期格式化为符合模式的字符串
            使用步骤:
                1.创建SimpleDateFormat对象,构造方法中传递执行的模式
                2.调用SimpleDateFormat对象中的方法format把日期格式化为符合模式的字符串
         */
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");
        Date date = new Date();
        System.out.println(date);//Mon Apr 27 14:05:38 CST 2020
        String s = sdf.format(date);
        System.out.println(s);//2020-04-27 14:05:38  2020年04月27日 14时06分37
    }
}



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

public class Demo02DateFormat {
    public static void main(String[] args) throws ParseException {
        /*
            Date parse(String source) 把符合模式的字符串解析为Date日期
            实现步骤:
                1.创建SimpleDateFormat对象,构造方法中传递执行的模式
                2.调用SimpleDateFormat对象中的方法parse,把符合模式的字符串解析为Date日期
         */
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        /*
            public Date parse(String source) throws ParseException
            parse方法抛出了解析异常ParseException
            当传递的字符串参数"2000-1-11"和构造方法中的模式"yyyy-MM-dd"不匹配的时候,就会抛出ParseException解析异常
            调用了一个抛出异常的方法,有两种处理方式:
                1.使用throws关键字继续把异常抛出给方法的调用者处理,最终抛出给JVM
                2.使用try...catch自己手动的处理异常
            快捷键: 把鼠标放在报异常的位置 alt+回车
         */
        Date date = sdf.parse("2000-1-11");
        System.out.println(date);
    }
}

四.Calendar类

1.Calendar类介绍&创建对象的方式(重点)



import java.util.Calendar;

/*
    java.util.Calendar类:日历类
        我们可以使用Calendar类中的方法获取日历上的字段(年,月,日,时,分,秒...)
        我们可以使用Calendar类中的方法修改日历上的字段的值  2020-->2030  4月-->6月
        我们可以使用Calendar类中的方法把日历上字段的值增加|减少  2020-5=2015  4月+3月=7月
        我们可以使用Calendar类中的方法把日历对象转换为Date日期对象
    Calendar 类是一个抽象类,无法直接创建对象使用,在Calendar类中有一个静态方法叫getInstance
        获取Calendar类的子类对象
        static Calendar getInstance() 使用默认时区和语言环境获得一个日历。
    注意:
        西方的月份:0-11月
        东方的月份:1-12月
        西方的星期:星期日-星期六
        东方的星期:星期一-星期日
 */
public class Demo01Calendar {
    public static void main(String[] args) {
        /*
            多态
                Calendar cal = null;
                cal = new GregorianCalendar(zone, aLocale);
           -------------------------------
                Animal a = getAnimal(); new Cat() new Dog():
         */
        //父类     =  子类对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);
    }
}

输出结果:

java.util.GregorianCalendar[time=1587968983189,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2020,MONTH=3,WEEK_OF_YEAR=18,WEEK_OF_MONTH=5,DAY_OF_MONTH=27,DAY_OF_YEAR=118,DAY_OF_WEEK=2,DAY_OF_WEEK_IN_MONTH=4,AM_PM=1,HOUR=2,HOUR_OF_DAY=14,MINUTE=29,SECOND=43,MILLISECOND=189,ZONE_OFFSET=28800000,DST_OFFSET=0]

2.Calendar类中的常用成员方法(重点)



import java.util.Calendar;
import java.util.Date;

/*
    Calendar类的常用方法
        int get(int field) 获取给定日历字段的值。
        void set(int field, int value) 将给定的日历字段设置为给定值。
        void add(int field, int amount)  把日历字段增加|减少指定的值
        Date getTime()  把日历转换为日期对象
    注意:
        以上方法的参数(int field),让我们传递指定的日历字段,这些日历字段在Calendar类中被定义为了常量
            年:public final static int YEAR = 1;
            月:public final static int MONTH = 2;
            日:public final static int DATE = 5;
            日:public final static int DAY_OF_MONTH = 5;
            时:public final static int HOUR = 10;
            分:public final static int MINUTE = 12;
            秒:public final static int SECOND = 13;
            毫秒:public final static int MILLISECOND = 14;
 */
public class Demo02Calendar {
    public static void main(String[] args) {
        show05();
    }

    /*
        void setTime(Date date) 把Date日期转换为日历对象
     */
    private static void show05() {
        Calendar c = Calendar.getInstance();
        System.out.println(c.get(Calendar.YEAR)+"年"+c.get(Calendar.MONTH)+"月"+c.get(Calendar.DATE)+"日");//2020年3月27日
        c.setTime(new Date(0L));
        System.out.println(c.get(Calendar.YEAR)+"年"+c.get(Calendar.MONTH)+"月"+c.get(Calendar.DATE)+"日");//1970年0月1日
    }

    /*
        Date getTime()  把日历转换为日期对象
     */
    private static void show04() {
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        System.out.println(date);//Mon Apr 27 14:58:05 CST 2020
    }

    /*
        void add(int field, int amount)  把日历字段增加|减少指定的值
        参数:
            int field:指定的日历字段
            int amount:给字段增加|减少的值
                传递正数:增加
                传递负数:减少
     */
    private static void show03() {
        //获取Calendar对象
        Calendar c = Calendar.getInstance();
        //把年-5年
        c.add(Calendar.YEAR,-5);
        //把月份+3月
        c.add(Calendar.MONTH,3);
        //把日-10天
        //c.add(Calendar.DATE,-10);//17号
        c.add(Calendar.DATE,10);//8月6日

        //获取年
        int year = c.get(Calendar.YEAR);
        System.out.println(year+"年");//2015年
        //获取月
        int month = c.get(Calendar.MONTH);
        System.out.println((month+1)+"月");//7月
        //获取日
        int date = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date+"日");//17日
    }

    /*
        void set(int field, int value) 将给定的日历字段设置为给定值。
        参数:
            int field:指定的字段
            int value:设置指定的值
       同时设置年月日,建议使用以下方法
            public final void set(int year, int month, int date)
     */
    private static void show02() {
        //获取Calendar对象
        Calendar c = Calendar.getInstance();
        //把年设置8888年
        c.set(Calendar.YEAR,8888);
        //把月份设置为8月
        c.set(Calendar.MONTH,7);
        //把日设置为8日
        c.set(Calendar.DATE,8);
        //同时设置年月日
        c.set(9999,8,9);

        //获取年
        int year = c.get(Calendar.YEAR);
        System.out.println(year+"年");
        //获取月
        int month = c.get(Calendar.MONTH);
        System.out.println((month+1)+"月");
        //获取日
        int date = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date+"日");
    }

    /*
        int get(int field) 获取给定日历字段的值。
        参数:
            int field:传递指定的日历字段
     */
    private static void show01() {
        //获取Calendar对象
        Calendar c = Calendar.getInstance();
        //获取年
        //int year = c.get(1);
        int year = c.get(Calendar.YEAR);
        System.out.println(year+"年");
        //获取月
        int month = c.get(Calendar.MONTH);
        System.out.println((month+1)+"月");
        //获取日
        //int date = c.get(Calendar.DATE);
        int date = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(date+"日");
    }
}

五.Math类(重点)



/*
    java.lang.Math类:数学工具类
        Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
        Math类中的方法都是静态方法,通过类名.方法名(参数)可以直接使用
        Math类中私有了构造方法,不让我们直接创建对象使用  private Math() {}
    成员方法:
        public static int abs(int a) 获取参数a的绝对值：
        public static double ceil(double a) 向上取整  1.1 2.0  1.9  2.0
        public static double floor(double a) 向下取整 1.1 1.0  1.99999 1.0
        public static long round(double a) 四舍五入取整  5.5 6   5.49999 5
        public static double pow(double a, double b) 获取a的b次幂  2^3  2^4
 */
public class Demo01Math {
    public static void main(String[] args) {
        //public static int abs(int a) 获取参数a的绝对值：
        System.out.println(Math.abs(10));//10
        System.out.println(Math.abs(-10));//10
        System.out.println(Math.abs(0.1));//0.1
        System.out.println(Math.abs(-0.1));//0.1
        System.out.println("--------------------------------");
        //public static double ceil(double a) 向上取整
        System.out.println(Math.ceil(5.1));//6.0
        System.out.println(Math.ceil(5.9));//6.0
        System.out.println(Math.ceil(-5.1));//-5.0
        System.out.println(Math.ceil(-5.9));//-5.0
        System.out.println("--------------------------------");
        //public static double floor(double a) 向下取整
        System.out.println(Math.floor(5.1));//5.0
        System.out.println(Math.floor(5.9));//5.0
        System.out.println(Math.floor(-5.1));//-6.0
        System.out.println(Math.floor(-5.9));//-6.0
        System.out.println("---------------------------");
        //public static long round(double a) 四舍五入取整
        System.out.println(Math.round(5.5));//6
        System.out.println(Math.round(5.499999999));//5
        System.out.println("--------------------------");
        //public static double pow(double a, double b) 获取a的b次幂
        System.out.println(Math.pow(2.0,3.0));//8.0
        System.out.println(Math.pow(2.0,-3.0));//0.125
        System.out.println(Math.pow(-2.0,3.0));//-8.0
        System.out.println(Math.pow(-2.0,-3.0));//-0.125
        System.out.println("--------------------------");
        /*
            static double random() 获取一个随机的小数,该值大于等于 0.0 且小于 1.0。 [0.0,1.0)
            0.6974873607317376
            0.44954296961350837
            0.07532574147331605
            0.4034629488590904
            0.7121695638217205
            0.26027976396027486
            0.6562874871560727
            0.3795562141362999
            0.7662793537891729
            0.2813382012117768
         */
        for (int i = 0; i < 10; i++) {
            System.out.println(Math.random());
        }
    }
}

六.System类(重点)



import java.util.Date;

/*
    java.lang.System类
        System 类包含一些有用的类字段和方法。它不能被实例化(私有了构造方法)。
        里边的方法都是静态的,通过类名.方法名(参数)可以直接使用
    成员方法:
        public static void exit(int status) 终止当前运行的 Java 虚拟机，非零表示异常终止
        public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  数组复制
 */
public class Demo01System {
    public static void main(String[] args) {
        show03();
    }

    /*
        static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)  数组复制(了解)
        参数:
            src - 源数组。
            srcPos - 源数组中的起始位置。
            dest - 目标数组。
            destPos - 目标数据中的起始位置。
            length - 要复制的数组元素的数量。
       需求:
         把原数组[1,2,3,4,5]的前3个元素复制到目标数组中的前3个索引处[6,7,8,9,10]
            复制前:目标数组[6,7,8,9,10]
            复制后:目标数组[1,2,3,9,10]
     */
    private static void show03() {
        int[] src = {1,2,3,4,5};
        int[] dest = {6,7,8,9,10};
        System.out.println("复制前遍历数组目标数组dest");
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
        //数组复制
        System.arraycopy(src,0,dest,0,3);
        System.out.println("复制后遍历数组目标数组dest");
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }

    /*
        public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
        返回的当前时间到1970 年 1 月 1 日00:00:00所经历的毫秒值
        和new Date().getTime()是等价的
        作用:
            可以测试程序的效率
        需求:
            在控制台输出1-10000，计算这段代码执行了多少毫秒
     */
    private static void show02() {
        long s = System.currentTimeMillis();
        //System.out.println(s);//1587973244384

        for (int i = 1; i <=10000 ; i++) {
            System.out.println(i);
        }

        long e = new Date().getTime();
        //System.out.println(e);//1587973244386

        System.out.println("程序执行共耗时:"+(e-s)+"毫秒值!");//程序执行共耗时:267毫秒值!

    }

    /*
        public static void exit(int status) 终止当前运行的 Java 虚拟机，非零表示异常终止
        参数:
            int status:状体码  0:正常终止  非0:表示异常终止
     */
    private static void show01() {
        while (true){
            System.out.println("我想有一个女同桌!");
            //break;
            System.exit(1);//终止JVM
        }
        //System.out.println("后续代码!");
    }
}

奚敛锋

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础知识学习笔记——常用API

一、Object1.1 概述java.lang.Object ,注意:lang包中的类无需导包可以直接使用类 Object 是类层次结构的根类(最顶层的类，基类)。每个类都使用 Object 作为超类。任何一个类都直接或者间接的继承了Object类所有对象（包括数组）都实现这个Object类的方法。任何一个类都可以使用Object类中的方法如果一个类没有特别指定父类，那么默认则继承自Object类（Object类可以省略）。例如：public class Demo/*extends
复制链接

扫一扫