学习java第13天

Date类的对象在java中代表的是当前所在的此刻日期时间

Date类记录时间的2种形式:

形式1:日期对象

创建一个日期对象代表了:当前系统的此刻日期时间对象

Date d=new Date();

System.out.println(d);

形式2:时间毫秒值

指的是从1970年1月1日 00:00:00走到此刻的总的毫秒数，应该是很大的

获取当前对象的毫秒值

long time=d.getTime();

System.out.println(time);

package com.itheima.d1_done;

import java.util.Date;

/*目标:学会使用Date类的时间，获取时间的信息*/
public class DateDemo1 {
    public static void main(String[] args) {
        //1.创建一个Date类的对象，代表系统此刻日期时间对象
        Date date = new Date();
        System.out.println(date);
        //2.获取时间毫秒值
        long time=date.getTime();
        System.out.println(time);
        /*long l = System.currentTimeMillis();
        System.out.println(l);*/
        System.out.println("-------------------");
        //1.得到当前时间
        Date date1 = new Date();
        System.out.println(date1);
        //2.当前时间万户侯走1小时121s
        long time1=System.currentTimeMillis();
        time1+=(60*60+121)*1000;
        //3.把时间毫秒值转换成对应的日期对象
        /*Date date2 = new Date(time1);
        System.out.println(date2);*/
        Date date2 = new Date();
        date2.setTime(time1);
        System.out.println(date2);
    }
}

 

 

package com.itheima.d1_done;

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

public class SimpleDateFormatTest2 {
    public static void main(String[] args) throws ParseException {
        //1.开始和结束时间
        String startTime="2021-11-11 00:00:00";
        String endTime="2021-11-11 00:00:00";
        //2.小贾 小贝
        String xiaoJia="2021-11-11 00:03:47";
        String xiaoPi="2021-11-11 00:10:11";
        //3.解析他们的时间
        SimpleDateFormat sim = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d1 = sim.parse(startTime);
        Date d2=sim.parse(endTime);
        Date d3 = sim.parse(xiaoJia);
        Date d4=sim.parse(xiaoPi);
        if(d3.after(d1)&&d3.before(d2)){
            System.out.println("小家秒杀成功,可以发货");
        }else{
            System.out.println("小贾秒杀失败");
        }
        if(d4.after(d1)&&d4.after(d2)){
            System.out.println("小皮秒杀成功,可以发货");
        }else{
            System.out.println("小皮秒杀失败");
        }
    }
}

Calendar概述:

Calendar代表了系统此刻日期对应的日历对象

Calendar是一个抽象类，不能直接创建对象

 

 

 

 

package com.itheima.d2_calendar;

public class Test {
    public static void main(String[] args) {
        int a=10;
        Integer a1=11;
        Integer a2=a;//自动转换
        System.out.println(a);
        System.out.println(a1);

        Integer it=100;
        int it1=it;//自动拆箱
        System.out.println(it1);

        double db=99.6;
        Double db1=db;//自动装箱
        Double db2=db1;//自动拆箱
        System.out.println(db2);

        //int age=null;
        Integer age1=null;
        Integer age2=0;
        System.out.println("-------------");
        //1.包装类可以把基本类型的数据转换成字符串形式
        Integer i1=23;
        String rs=i1.toString();
        System.out.println(rs);
        String number="29";
        int age=Integer.parseInt(number);
        System.out.println(age);
        String number1="99.7";
        //转换成小数
        double s=Double.parseDouble(number1);
        System.out.println(s);
    }
}

 正则表达式:

正则表达式可以用一些规定的字符来指定规则.并用来校验数据格式的合法性

可以网上搜一些资料，太繁琐

 

package com.itheima.ArrayDemo1;

import java.util.Arrays;
import java.util.Comparator;

public class ArrayDemo2 {
    public static void main(String[] args) {
        //目标:自定义数组的排序规则,Comparator比较器对象
        //1。Arrays的sort方法对于有值得特性的数组时默认升序排序
        int[] ages={34,54,12,43,89};
        Arrays.sort(ages);
        System.out.println(Arrays.toString(ages));
        //2需求:降序排序(自定义比较器对象，只能支持引用类型的排序)
        Integer[] ages1={34,43,23,54,12,321,65};
        //需求:排序升序的数组  必须是引用类型的元素
        //参数一:被排序的数组，必须时引用类型的元素
        //参数二:匿名内部类对象，代表了一个比较器对象
        Arrays.sort(ages1, new Comparator<Integer>() {
                    @Override
                    public int compare(Integer o1, Integer o2) {
                       // return o1-o2;
                       // return o2-o1;
                        return 0;
                    }
                });
        System.out.println(Arrays.toString(ages1));
        System.out.println("-----------------");
        Student[] students=new Student[3];
        students[0]=new Student("吴磊",23,175.5);
        students[1]=new Student("谢鑫",18,185.5);
        students[2]=new Student("王亮",19,173.9);
        Arrays.sort(students, new Comparator<Student>() {
            @Override
            public int compare(Student o1, Student o2) {
                //自己制定
                //return o1.getAge()-o2.getAge();
                //return o2.getAge()-o1.getAge();
                return Double.compare(o1.getHeight(),o2.getHeight());
            }
        });
        System.out.println(Arrays.toString(students));
    }
}

常见

算法:

package com.itheima.ArrayDemo1;

import java.util.Arrays;

public class Test1 {
    public static void main(String[] args) {
        //1.定义数组
        int[] arr={5,1,2,3};
        for (int i = 0; i < arr.length; i++) {
            for (int j = i+1; j < arr.length; j++) {
                //当前位
                //如果有比当前位数更小的，则交换
                if(arr[i]>arr[j]){
                    int temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

package com.itheima.ArrayDemo1;
public class Test2 {
    public static void main(String[] args) {
        int[] arr={30,20,12,43,65,67,45};
        System.out.println(binarySearch(arr,33));
        System.out.println(binarySearch(arr,20));
    }
    /**
     * 二分查找算法的实现
     * @param arr 排序的数组
     * @param data 要找的数据
     * @return 索引，如果元素不存在，直接返回-1
     */
    public static int binarySearch(int[] arr,int data){
        //1.定义左边位置 和右边位置
        int left=0;
        int right=arr.length-1;
        //2.开始循环，折半查找
        while(left<=right){
            //取中间索引
            int middleIndex=(left+right)/2;
            //3.判断当前中间位置的元素和要找的元素的大小情况
            if(data>arr[middleIndex]){
                 //往右边找，左位置更新为=中间索引+1
                left=middleIndex+1;
            }else if(data<arr[middleIndex]){
                right=middleIndex-1;
            }else{
                return middleIndex;
            }
        }
        return -1;//查无此元素
    }
}

数组的二分查找的实现步骤是什么样的?

定义变量记录左边和右边位置

使用while循环控制查询(条件时左边位置<=右边位置)

循环内部获取中间元素索引

判断当前要找的元素如果大于中间元素，左边位置=中间索引+1

判断当前要找的元素如果小于中间元素，右边位置=中间索引-1

判断当前要找的元素如果等于中间元素，返回当前中间元素索引

Lambda表达式

Lambda表达式是JDK8开始后的一种新语法形式

作用:简化匿名内部类的代码写法

Lambda表达式的简化格式:

(匿名内部类被重写方法的形参列表)->{

        被重写方法的方法代码

}

注:-->是语法形式，无实际含义

注意:Lambda表达式只能简化函数时接口的匿名内部类的写法形式

什么是函数式接口?

首先是接口，其次接口中有且仅有一个抽象方法的形式

package com.itheima.ArrayDemo1;

public class LambdaDemo1 {
    public static void main(String[] args) {
        //目标:学会使用Lamdba的标准格式简化匿名内部类的代码形式
        //Lambda只能简化接口中只有一个抽象方法的匿名内部类形式
        /*Swimming s1=new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师有用贼溜---");
            }
        };*/
        Swimming s1=()->{
              System.out.println("老师游泳贼溜--");
        };
        go(s1);
    }
    public static void go(Swimming s){
        System.out.println("开始...");
        s.swim();
        System.out.println("结束...");
    }
}
@FunctionalInterface
interface Swimming{
    void swim();
}

Lambda表达式的基本作用?

简化函数时接口的匿名内部类的写法

Lambda表达式有什么使用前提?

必须是接口的匿名内部类，接口中只能有一个抽象方法

Lambda的好处?

Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码,它可以写出更简洁，更灵活的代码，作为一种更紧凑的代码风格，使java语言表达能力得到了提升