Object类、Date类、Calendar类、常用API、可变参数编程【学习笔记】

一、Object类
1.toString()方法
重写前：调用的是Object类中的方法。输出的是对象的全类名@十六进制的地址值
重写后：调用的是本类重写后的方法。输出的是属性或者内容

2.equals()方法
    重写前：调用的是Object类中的方法。依赖的是==号。比较是引用数据类型，那么就是比较地址值。
    重写后：调用的是本类重写后的方法。比较的就是对象的属性值是否一样。

3.Objects类中的equals()方法
    好处：加了一些健壮性和非空性的判断
    示例代码：

            public class Demo03Objects {
                public static void main(String[] args) {
                    String s1 = "abc";
                    //String s1 = null;
                    String s2 = "abc";
                    //boolean b = s1.equals(s2); // NullPointerException null是不能调用方法的,会抛出空指针异常
                    //System.out.println(b);
                    /*
                        Objects类的equals方法:对两个对象进行比较,防止空指针异常
                        public static boolean equals(Object a, Object b) {
                            return (a == b) || (a != null && a.equals(b));
                        }
                     */
                    boolean b2 = Objects.equals(s1, s2);
                    System.out.println(b2);
                }
            }

二、日期类
1.Date类
构造方法：
Date(); 根据当前的系统时间来创建一个日期对象
Date(long time);根据传入的毫秒值来创建一个日期对象
成员方法：
long getTime(); 获取当前对象的时间距元年经过了多少毫秒
示例代码：
public class Demo02Date {
public static void main(String[] args) {
demo03();
}

            /*
                    long getTime() 把日期转换为毫秒值(相当于System.currentTimeMillis()方法)
                      返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
                 */
                private static void demo03() {
                    Date date = new Date();
                    long time = date.getTime();
                    System.out.println(time);//3742777636267
                }

                /*
                    Date类的带参数构造方法
                    Date(long date) :传递毫秒值,把毫秒值转换为Date日期
                 */
                private static void demo02() {
                    Date date = new Date(0L);
                    System.out.println(date);// Thu Jan 01 08:00:00 CST 1970

                    date = new Date(3742767540068L);
                    System.out.println(date);// Sun Aug 08 09:39:00 CST 2088
                }

                /*
                    Date类的空参数构造方法
                    Date() 获取当前系统的日期和时间
                 */
                private static void demo01() {
                    Date date = new Date();
                    System.out.println(date);//Sun Aug 08 12:23:03 CST 2088
                }
            }

2.SimpleDateFormat
    构造方法：
        SimpleDateFormat(String format);        根据指定模板格式来创建一个格式化对象
        yyyy年MM月dd日 HH:mm:ss
        2018年07月19日 10:45:00
        y   年
        M   月
        d   日
        H   时
        m   分
        s   秒
        S   毫秒
    成员方法：

        String format(Date d);      将日期对象按照指定格式转成字符串
            Date parse(String s);       将字符串类型的日期转成一个日期对象
        示例代码：
            public class Demo01DateFormat {
                public static void main(String[] args) throws ParseException {
                    demo02();
                }

                /*
                     使用DateFormat类中的方法parse,把文本解析为日期
                     使用步骤:
                        1.创建SimpleDateFormat对象,构造方法中传递指定的模式
                        2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
                        注意:
                            public Date parse(String source) throws ParseException
                            parse方法声明了一个异常叫ParseException
                            如果字符串和构造方法的模式不一样,那么程序就会抛出此异常
                            调用一个抛出了异常的方法,就必须的处理这个异常,要么throws继续抛出这个异常,要么try catch自己处理
                 */
                private static void demo02() throws ParseException {
                    //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
                    //2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期
                    //Date parse(String source)  把符合模式的字符串,解析为Date日期
                    Date date = sdf.parse("2088年08月08日 15时51分54秒");
                    System.out.println(date);
                }

                /*
                    使用DateFormat类中的方法format,把日期格式化为文本
                    使用步骤:
                        1.创建SimpleDateFormat对象,构造方法中传递指定的模式
                        2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
                 */
                private static void demo01() {
                    //1.创建SimpleDateFormat对象,构造方法中传递指定的模式
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
                    //2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本)
                    //String format(Date date)  按照指定的模式,把Date日期,格式化为符合模式的字符串
                    Date date = new Date();
                    String d = sdf.format(date);
                    System.out.println(date);//Sun Aug 08 15:51:54 CST 2088
                    System.out.println(d);//2088年08月08日 15时51分54秒
                }
            }

    3.计算出生了多少天

            public class Demo02Test {
                public static void main(String[] args) throws ParseException {
                    //1.使用Scanner类中的方法next,获取出生日期
                    Scanner sc = new Scanner(System.in);
                    System.out.println("请输入您的出生日期,格式:yyyy-MM-dd");
                    String birthdayDateString = sc.next();
                    //2.使用DateFormat类中的方法parse,把字符串的出生日期,解析为Date格式的出生日期
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                    Date birthdayDate = sdf.parse(birthdayDateString);
                    //3.把Date格式的出生日期转换为毫秒值
                    long birthdayDateTime = birthdayDate.getTime();
                    //4.获取当前的日期,转换为毫秒值
                    long todayTime = new Date().getTime();
                    //5.使用当前日期的毫秒值-出生日期的毫秒值
                    long time = todayTime-birthdayDateTime;
                    //6.把毫秒差值转换为天(s/1000/60/60/24)
                    System.out.println(time/1000/60/60/24);
                }
            }

    4.日历类
        获取对象格式：Calendar c = Calendar.getInstance();
        成员方法：
            public int get(int field)：返回给定日历字段的值。
            public void set(int field, int value)：将给定的日历字段设置为给定值。
            public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
            public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
        示例代码：

            public class Demo02Calendar {
                    public static void main(String[] args) {
                        demo01();
                    }

                    /*
                        public Date getTime()：返回一个表示此Calendar时间值（从历元到现在的毫秒偏移量）的Date对象。
                        把日历对象,转换为日期对象
                     */
                    private static void demo04() {
                        //使用getInstance方法获取Calendar对象
                        Calendar c = Calendar.getInstance();

                        Date date = c.getTime();
                        System.out.println(date);
                    }

                    /*
                        public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
                        把指定的字段增加/减少指定的值
                        参数:
                            int field:传递指定的日历字段(YEAR,MONTH...)
                            int amount:增加/减少指定的值
                                正数:增加
                                负数:减少
                     */
                    private static void demo03() {
                        //使用getInstance方法获取Calendar对象
                        Calendar c = Calendar.getInstance();

                        //把年增加2年
                        c.add(Calendar.YEAR,2);
                        //把月份减少3个月
                        c.add(Calendar.MONTH,-3);


                        int year = c.get(Calendar.YEAR);
                        System.out.println(year);

                        int month = c.get(Calendar.MONTH);
                        System.out.println(month);//西方的月份0-11 东方:1-12

                        //int date = c.get(Calendar.DAY_OF_MONTH);
                        int date = c.get(Calendar.DATE);
                        System.out.println(date);
                    }

                    /*
                        public void set(int field, int value)：将给定的日历字段设置为给定值。
                        参数:
                            int field:传递指定的日历字段(YEAR,MONTH...)
                            int value:给指定字段设置的值
                     */
                    private static void demo02() {
                        //使用getInstance方法获取Calendar对象
                        Calendar c = Calendar.getInstance();

                        //设置年为9999
                        c.set(Calendar.YEAR,9999);
                        //设置月为9月
                        c.set(Calendar.MONTH,9);
                        //设置日9日
                        c.set(Calendar.DATE,9);

                        //同时设置年月日,可以使用set的重载方法
                        c.set(8888,8,8);

                        int year = c.get(Calendar.YEAR);
                        System.out.println(year);

                        int month = c.get(Calendar.MONTH);
                        System.out.println(month);//西方的月份0-11 东方:1-12

                        int date = c.get(Calendar.DATE);
                        System.out.println(date);
                    }

                    /*
                        public int get(int field)：返回给定日历字段的值。
                        参数:传递指定的日历字段(YEAR,MONTH...)
                        返回值:日历字段代表的具体的值
                     */
                    private static void demo01() {
                        //使用getInstance方法获取Calendar对象
                        Calendar c = Calendar.getInstance();
                        int year = c.get(Calendar.YEAR);
                        System.out.println(year);

                        int month = c.get(Calendar.MONTH)+1;
                        System.out.println(month);//西方的月份0-11 东方:1-12

                        //int date = c.get(Calendar.DAY_OF_MONTH);
                        int date = c.get(Calendar.DATE);
                        System.out.println(date);

                        //获取星期
                        /*
                            1           2       3           4           5       6       7
                            星期日      星期一   星期二   星期三      星期四   星期五   星期六

                            查表法
                         */
                        int week = c.get(Calendar.DAY_OF_WEEK);
                        String s = getWeek(week);
                        System.out.println(s);
                    }

                    public static String getWeek(int index) {
                        String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
                        return arr[index];
                    }
                }

    5.日历类案例

            /*
                需求：通过键盘录入一个年月日：2015-10-20
                要求：
                    输出：2015年10月20号是星期二    10月20号是2015年的第XX天

                分析：
                    1.创建键盘录入对象。接收一个字符串类型的日期
                    2.创建日期格式化对象，将字符串类型的日期转成Date对象
                    3.创建一个日历类对象，将转换后的Date对象中的日期给赋值进去
                    4.获取年月日、星期、一年中的第几天
                    5.输出
             */
            public class Demo01 {
                public static void main(String[] args) throws ParseException {
                    //1.创建键盘录入对象。接收一个字符串类型的日期
                    Scanner sc = new Scanner(System.in);
                    System.out.println("请输入一个字符串类型的日期：");
                    String s = sc.nextLine();

                    //2.创建日期格式化对象，将字符串类型的日期转成Date对象
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                    Date date = sdf.parse(s);

                    //3.创建一个日历类对象，将转换后的Date对象中的日期给赋值进去
                    Calendar c = Calendar.getInstance();
                    c.setTime(date);

                    //4.获取年月日、星期、一年中的第几天
                    int year = c.get(Calendar.YEAR);
                    int month = c.get(Calendar.MONTH)+1;
                    int day = c.get(Calendar.DAY_OF_MONTH);
                    int dayOfYear = c.get(Calendar.DAY_OF_YEAR);
                    int week = c.get(Calendar.DAY_OF_WEEK); // 返回的星期数字就是1-7

                    System.out.println(year + "年"+month+"月"+day+"号是"+getWeek(week)+"    " +
                            ""+month+"月"+day+"号是"+year+"年的第"+dayOfYear+"天");
                }

                public static String getWeek(int index) {
                    String[] arr = {"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
                    return arr[index];
                }
            }

三、System类
1.成员方法：
long currentTimeMillis(); 获取当前系统的毫秒值时间
void arrayCopy(int[] src,int index,int[] dest,int index,int count); 复制数组元素
void exit(int i); 退出jvm
2.示例代码：

        public class Demo01System {
            public static void main(String[] args) {
                //demo02();

                //exit(int i)
                for (int i = 0; i < 100; i++) {
                    System.out.println(i);
                    if(i == 10) {
                        System.exit(0); // 正常终止虚拟机
                    }
                }

                System.out.println("1111111111111");
            }

            /*
                public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
                参数:
                    src - 源数组。
                    srcPos - 源数组中的起始位置(起始索引)。
                    dest - 目标数组。
                    destPos - 目标数据中的起始位置。
                    length - 要复制的数组元素的数量。
                练习:
                    将src数组中前3个元素，复制到dest数组的前3个位置上
                        复制元素前：
                        src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10]
                        复制元素后：
                        src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10]
             */
            private static void demo02() {
                //定义源数组
                int[] src = {1,2,3,4,5};
                //定义目标数组
                int[] dest = {6,7,8,9,10};
                System.out.println("复制前:"+ Arrays.toString(dest));
                //使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上
                System.arraycopy(src,3,dest,3,2);
                System.out.println("复制后:"+ Arrays.toString(dest));
            }

            /*
                public static long currentTimeMillis()：返回以毫秒为单位的当前时间。
                用来程序的效率
                验证for循环打印数字1-9999所需要使用的时间（毫秒）
             */
            private static void demo01() {
                //程序执行前,获取一次毫秒值
                long s = System.currentTimeMillis();
                //执行for循环
                for (int i = 1; i <=9999 ; i++) {
                    System.out.println(i);
                }
                //程序执行后,获取一次毫秒值
                long e = System.currentTimeMillis();
                System.out.println("程序共耗时:"+(e-s)+"毫秒");//程序共耗时:106毫秒
            }
        }

四、字符串缓冲区类

    1.StringBuilder
        构造方法：
            StringBuilder();                创建一个字符串缓冲区对象
            StringBuilder(String str);      根据传入的字符串来创建一个字符串缓冲区对象

        成员方法：
            StringBuilder append(Object obj);   向缓冲区中追加内容
            StringBuilder reverse();            将缓冲区的内容反转
            String toString();                  将缓冲区的内容转成字符串

        示例代码：
            public class Demo02StringBuilder {
                public static void main(String[] args) {
                    //创建StringBuilder对象
                    StringBuilder bu = new StringBuilder();
                    //使用append方法往StringBuilder中添加数据
                    //append方法返回的是this,调用方法的对象bu,this==bu
                    //StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2
                    //System.out.println(bu);//"abc"
                    //System.out.println(bu2);//"abc"
                    //System.out.println(bu==bu2);//比较的是地址 true

                    /*
                        链式编程:方法返回值是一个对象,可以继续调用方法
                     */
                    bu.append("abc").append(1).append(true).append(8.8).append('中');
                    System.out.println(bu);//abc1true8.8中

                    StringBuilder sb = new StringBuilder();
                    sb.append("马黑爱我");
                    //将缓冲区内容反转
                    sb.reverse();
                    System.out.println(sb);
                }
            }

2.StringBuilder和String的区别
    String是不可变的字符序列、操作字符串效率较低、JDK1.0版本出现
    StringBuilder是可变的字符序列、操作字符串效率较高、JDK1.5版本出现

3.String和StringBuilder相互转换
    String转成StringBuilder：
        A：通过StringBuilder有参构造
        B：创建一个空的StringBuilder对象，调用append()方法将字符串添加进去
    StringBuilder转成String：
        调用toString()方法即可

4.StringBuilder类案例-判断字符串是否是对称的

        public class Demo02 {
            public static void main(String[] args) {
                String[] arr = {"123","121","232","456","787","789"};

                //遍历数组，拿到每一个字符串
                for (int i = 0; i < arr.length; i++) {
                    String src = arr[i];        // 本来的字符串
                    StringBuilder sb = new StringBuilder(src);
                    //将src字符串进行反转
                    sb.reverse();
                    //将反转后的字符串和原来的字符串进行比较
                    String dest = sb.toString();
                    //判断反转后的和本来的是不是完全一样
                    if(src.equals(dest)) {
                        System.out.println(src + "是对称的");
                    }else {
                        System.out.println(src + "不是对称的");
                    }
                }
            }
        }

5.StringBuilder类案例-拼接完全不重复的数字

        public class Demo03 {
            public static void main(String[] args) {
                StringBuilder sb = new StringBuilder();

                for(int i = 789; i <= 987; i++) {
                    String number = i+"";
                    if(number.contains("7") &&  number.contains("8") && number.contains("9")) {
                        sb.append(number).append(" ");
                    }
                }

                System.out.println(sb);
            }
        }

五、包装类
1.基本数据类型对应的包装类
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
2.每种包装类中都有对应的parseXXX()方法

六、可变参数

    /*
        可变参数:
               数据类型...变量名
        注意事项：
            可变参数后面不能再有其他的参数
     */
    public class Demo05 {
        public static void main(String[] args) {
           int result = getSum(10,20,30,40);
            System.out.println(result);
        }

        public static int getSum(int...num) {
            int sum = 0;
            for (int i = 0; i < num.length; i++) {
                sum += num[i];
            }
            return sum;
        }

Object类、Date类、Calendar类、常用API、可变参数编程 【学习笔记】

猜你喜欢

Object类、Date类、Calendar类、常用API、可变参数编程【学习笔记】