day04 API

Array
01数组的排序

/**
 * 数组的排序:冒泡
 *   数组中的元素,进行排序,默认都是升序
 *   4 3 1 2  -->  1 2 3 4
 *   排序的方法非常多:
 *      冒泡,选择,插入,二分,希尔,快速
 *
 *   数组排序: 核心思想, 数组中的元素比较,换位置
 */
public class ArrayTest01数组的排序 {
    public static void main(String[] args) {
        int []arr={5,1,2,3,4,6,-1,0};
        bubbleSort(arr);
        iterator(arr);

    }
    /**
     * 定义方法: 对数组进行升序排列
     * 数组作为参数传递
     */
    public static void bubbleSort(int[]arr){
        //外循环,次数,长度-1
        for (int x = 0; x < arr.length-1; x++) {
            //内循环,每次循环的次数递减  长度-外循环的变量
            for (int y = 0; y < arr.length-x-1; y++) {
                //比较, y索引和y+1索引比较
                if(arr[y]>arr[y+1]){
                    //位置交换
                       int temp=arr[y];
                       arr[y]=arr[y+1];
                       arr[y+1]=temp;
                }
            }
        }
    }

    //定义方法遍历  迭代
    public static void iterator(int[]arr){
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

02数组的二分搜索

/**
 *  数组的二分搜索
 *    数组的搜索: 在一个数组,查找指定的一个元素
 *    如果在数组中找到了该元素,返回所在的索引
 *    如果找不到元素,返回负数
 *
 *  二分搜索,折半
 *  前提: 数组 必须有序
 */
public class ArrayTest02数组的二分搜索 {
    public static void main(String[] args) {
        int []arr={1,4,5,9,11,15,17,20};
       int index= binarySearch(arr,17);
        System.out.println(index);

    }
    /**
     * 实现数组二分搜索
     * 传递数组,传递要找的元素key
     * 返回元素出现的索引
     * 找不到返回负数
     */
    public static int binarySearch(int[]arr,int key){
        //定义变量,数组最小索引
        int min=0;
        //定义变量,数组的最大索引
        int max=arr.length-1;
        //定义变量,数组的中间索引
        int mid;
        //折半计算  (min+max)/2
        // min 不能大于max ,才能折半
        while(min<=max){
            //进行折半
            mid=(min+max)/2;
            //数组的中间索引元素,和关键词比较
            if(arr[mid]>key){
                //移动最大索引
                max=mid-1;
            }else if(arr[mid]<key){
                //移动最小索引
                min=mid+1;
            }else{
                //找到了返回索引
                return mid;
            }
        }
        //折半结束,没有找到
        return -1;
    }
}

03数组操作工具类

import java.util.Arrays;

/**
 *  数组操作工具类
 *    java.util.Arrays 专门用于操作数组的
 *    所有方法全部静态
 *    不需要创建对象,不能建立对象,构造方法私有
 */
public class ArrayTest03数组操作工具类 {
    public static void main(String[] args) {
        method03();
    }

    /**查索引
     * static int binarySearch(数组,关键字)
     * 数组的二分搜索法
     * 找不到, 返回 (-插入点-1)
     */
    public static void method03(){
        int []arr={1,6,9,11,17,20,33};
        int index = Arrays.binarySearch(arr, 33);
        System.out.println(index);
    }




    /**排序
     * static void sort(传递数组)
     * 对数组升序排列,快速排序法
     */
    public static void method02(){
        int []arr={1,0,2,5,8,9};
        Arrays.sort(arr);
        String str = Arrays.toString(arr);
        System.out.println(str);
    }





    /**
     *  数组变成字符串
     *  static String toString(传递数组)
     */
    public static void method01(){
        int []arr={1,4,6,2,0,6,8};
        String str = Arrays.toString(arr);
        System.out.println(str);
    }
}

-------------------------------------------------------

Calendar日历类

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

/*
* java.util.Calendar 表示日历对象类
* 是抽象类，无对象，使用他的子类GregorianCalendar
*
* 日历中的名词：  日历字段（Field）
* 表示日历的组成部分，包括 年，月，日，时，分....
* 日历字段数据，都是整数int
*
* Calendar类定义静态方法，不用new，通过调用
*    static Calendar getInstance()返回子类GregorianCalendar对象
* */
public class CalendarTest01 {
    public static void main(String[] args) {
        //父类的静态方法，获取子类对象
        Calendar calendar = Calendar.getInstance();

        //日历转日期
        Date date = calendar.getTime();
        System.out.println(date);

        //日历类方法，int get（int）获取日历字段中的值
        //传递日历字段，返回字段中对应的数据，例如：get（年）返回2019
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DAY_OF_MONTH)+"日");


    }
}

02方法add和set

import java.util.Calendar;

/*
* Calendar的方法add，set
* */
public class CalendarTest02方法add和set {
    public static void main(String[] args) {
        method01();
    }


    /**
     * add方法设置日历偏移量
     * add(int field,int value)
     * field偏移的字段
     * value偏移的具体数据
     */

    public static void method02(){
        Calendar calendar = Calendar.getInstance();
        System.out.println( calendar.get(Calendar.YEAR)+"年"+ (calendar.get(Calendar.MONTH)+1)  +"月" +calendar.get(Calendar.DAY_OF_MONTH)+"日");
        //日历对象方法add偏移,现在开始向后偏移10天
        calendar.add(Calendar.DAY_OF_MONTH,10);
        System.out.println( calendar.get(Calendar.YEAR)+"年"+ (calendar.get(Calendar.MONTH)+1)  +"月" +calendar.get(Calendar.DAY_OF_MONTH)+"日");
    }





    /*
    * set 方法设置日历（默认跟随操作系统）
    * set(int field,int value)日历设置到指定的字段上
    * set(int year,int month,int day)设置到年月份
    * */

    public static void method01(){
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DAY_OF_MONTH)+"日");
        //设置日历，月份设置到3月份
        //calendar.set(Calendar.MONTH,2);

        //设置日历，2020年的5月1日
        calendar.set(2020,4,1);
        System.out.println(calendar.get(Calendar.YEAR)+"年"+(calendar.get(Calendar.MONTH)+1)+"月"+calendar.get(Calendar.DAY_OF_MONTH)+"日");

    }
}

03判断是否为闰年

import java.util.Calendar;

/*
*  指定年份,计算是否闰年
 *  计算方法.年份/4  /400
 *  年份已知,日历设定到指定年份的3月1日
 *  向前偏移1天,看这天是28还是29
* */
public class CalendarTest03判断是否为闰年 {
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        int year=2020;//设定年份
        //日历设置到该年份的3月1日
        calendar.set(year,2,1);
        //日历向前偏移1天
        calendar.add(Calendar.DAY_OF_MONTH,-1);
        //取出天数
        int day = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
    }
}

-------------------------------------------------------

Date日期类
01日期格式化
日期转字符串

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

/*
* 对日期进行格式化：符合中国阅读习惯
* java.text.DateFormat  日期进行格式化
* DateFormat是抽象类，没有对象
* 使用他的子类对象是SimpleDateFormat,其不是抽象的
* DateFormat是抽象方法，其子类SimpleDateFormat必然会重写，需要new
* 如果不是抽象方法，子类对象直接调用
*
*
* 自定义格式：2019年11月18日  10点50分20秒
*    y：年份
*    M：月份
*    d：月中天数
*    H：几点
*    m：分钟
*    s：秒
*
*    格式化步骤：
*       1：创建子类对象SimpleDateFormat，不是静态，直接创建
*          调用String类型的构造方法，传递日期格式
*       2：子类对象调用方法  format
*          String  format（Date data）传递日期对象，返回格式化后的字符串
*
* */
public class DateFormatTest01日期转字符串 {
    public static void main(String[] args) {
        //1：创建子类对象SimpleDateFormat
        //2019年11月18日  10点50分20秒
        SimpleDateFormat s = new SimpleDateFormat("yyyy年MM月dd日 HH点mm分ss秒");
       //2：子类对象调用方法  format,传递日期对象
        String str = s.format(new Date());
        System.out.println(str);
    }
}

字符串转日期

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

/*
* 字符串转成日期对象使用
* String-->Date日期类
*  SimpleDateFormat对象的方法  parse
*
*  Date-->String
*   SimpleDateFormat对象的方法  format
*
*   实现步骤：
*      1：创建对象SimpleDateFormat
*         构造方法传递日期格式
*      2：调用对象的方法 parse
*         Date parse(String 日期)返回Date对象
* */
public class DateFormatTest02字符串转日期 {
    public static void main(String[] args) throws ParseException {
        //1：创建对象SimpleDateFormat
        SimpleDateFormat s = new SimpleDateFormat("yyyy-MM-dd");
        //注意：字符串日期格式，必须和构造方法中的日期格式一样
        String str="2019-11-18";
        // 2：调用对象的方法 parse
        Date date = s.parse(str);
        System.out.println(date);
    }
}

02日期与毫秒互转

import java.util.Date;

/*
* 日期对象：java.util.Date
* 表示日期对象类
* 毫秒（千分之一秒）  1000毫秒=1秒
*
* 构造方法：
*     无参数构造方法
*     有参数构造方法，参数传递的是毫秒
*
*  日期类Date：
*     重要应用：实现类日期和毫秒之间的互转
*     日期不能进行数学计算，但是毫秒可以，他是整数
*
*
*     日期转成毫秒：new Date().getTime()  获取毫秒
*     毫秒转成日期：第一种：new Date(毫秒)
 *                第二种：new Date().setTime(毫秒)设定日期
* */
public class DateTest日期与毫秒互转 {
    public static void main(String[] args) {
        method04();
    }




    /*
    * Date类的方法 long getTime（）
    * 日期转成毫秒
    * 返回当前日期对应的毫秒值
    * */
    public static void method03(){
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);//1574076660117此时此刻对应的毫秒值
    }






    /*
     * Date类的方法  void setTime（long time）
     * 第二种：毫秒转成日期
     * 传递毫秒，日期设定在毫秒上
     * */
    public static void method04(){
        Date date = new Date();
        date.setTime(1574076660117L);
        System.out.println(date);
    }




    /*
    * Date类有参构造方法
    * 第一种：毫秒转日期
    * Date（long time）传递的参数是毫秒，标准格林威治时间
    * 原点：1970-1-1：0：0：0   java日期的原始时间，是0毫秒
    * 现在是2019年
    *
    * 含义：日期设定到毫秒值上
    * */
    public static void method02(){
        Date date = new Date(15510000300303215L);
        System.out.println(date);
    }





    /*
    * Date类的无参构造方法
    * Mon Nov 18 10:14:44 CST 2019
    * 创建日期对象，输出的时间和日期跟随操作系统
    *
    * */
    public static void method01(){
        Date date = new Date();
        System.out.println(date.toString());
    }
}

-------------------------------------------------------

Object
01

/*
* java.lang.Object类，所有类的父类
*
*     private static native void registerNatives();
        static {
            registerNatives();
        }
          native: 本地修饰符,本地方法
        这样本地方法,不是由Java语言编写的,是C++语言编写
        JVM运行期间,对内存进行划分,独立内存位置 (本地方法栈  native stack)
        运行本地方法使用的内容
        本地方法的意义: 和当前的操作系统进行交互使用

        运行一个类的时候,Object先进入方法区,运行自己的静态成员,和本机的操作系统交互
* */
public class ObjectTest extends Object{
    public static void main(String[] args) {
        System.out.println("hello");
    }
}

02toString

public class Person {
  private String name;
    private int 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;
    }
    //需要做有意义事情，重写此方法，返回类中成员变量的值
    public String toString(){
        return name+"..."+age;
    }
}

import java.util.ArrayList;

/*
* Object类的方法
*   public String toString（） 返回对象的字符串表现形式
*
*   定义的Person类，继承Object
*   拥有方法toString（）
*
*   结论:
*      调用父类的方法toString（）输出对象的地址
*      输出语句，直接打印对象，输出对象的地址
*
*      在输出语句中，默认调用对象的toString（）方法
*
*      toString（）方法的执行结果：分析Object类的定义方法
*
*       public String toString(){
 *          return getClass().getName()+"@"+ Integer.toHexString(  hashCode()  ) ;
 *      }
 *
 *      需求：看对象内存地址，没有意义，因此
 *           需要做有意义的事情，也就是需要重写此方法，返回类中成员的变量的值
 *           方便在对象输出的时候，看到成员变量的值
*
*
*
* */
public class ObjectTest {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("张三");
        person.setAge(30);
        //调用Person对象的方法toString
        String s = person.toString();
        System.out.println(s);
        //com.itheima.Object.object02toString.Person@6e0be858
        //出现地址值，说明这个子类没有重写toString，只是默认调用了，需要人工重写也就是需要以下操作，类似的有Random
        //  public String toString（）
        System.out.println(person);
        System.out.println(person.toString());

        //而 ArrayList默认调用了，并且默认重写了toString（），类似的还有Scanner
        ArrayList<String> list = new ArrayList<>();
        list.add("aa");
        list.add("cc");
        list.add("bb");
        System.out.println(list);

    }
}

03equals

public class Person {
    private String name;
    private int 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;
    }

    public Person(String name, int age) {

        this.name = name;
        this.age = age;
    }

    public Person() {

    }
    //需要做有意义事情,重写次方法,返回类中成员变量的值
    public String toString(){
        return name + "..." +age;
    }
    /*
    * 重写父类方法equals，建立自己的比较方式
    * 比较两个对象的年龄，年龄相同返回true
    *
    * public boolean equals（Object obj）
    * */
    public boolean equals(Object obj){
        //判断  obj对象是不是p1
        //this是调用者，谁调用我，我就是谁。调用者对象p1，如果this对象的内存地址和传递的对象obj相等（说明是一个对象,自己跟自己比）
        if(this==obj)
            return true;


        //非空判断，传递的对象obj如果是null，就不用比较了
            if(obj==null)
                return false;

            //比较的对象this和obj
           //age是Person的特有成员，obj对象强制转成Person
            //判断obj是不是Person的对象
        if(obj instanceof Person){
            Person p=(Person)obj;
            //比较对象this和p的年龄是否相同
            return this.age==p.age;
        }
        return false;
    }
}

/*
* Object类的方法  equals
* Java语言认为，所有的对象都具有比较性，方法的作用进行两个对象的比较
*
*
* public boolean equals（Object obj）
* Person类继承Object，拥有方法equals
* Object类中对象比较的方法，equals默认比较的对象是内存地址是否相同
*
* 两个对象都是new出来的，地址不一样
* 北清路  1号
* 建材城西路  2号
*
*
* 比较地址无意义，重写方法equals建立Person类自己的比较形式
* 不打算比较地址，比较两个对象的年龄
* */
public class ObjectTest {
    public static void main(String[] args) {
        Person p1 = new Person("张三",20);
        Person p2 = new Person("李四",21);
        //对象比较，p1对象调用方法equals传递p2对象,无意义，需要重写
        boolean b = p1.equals(p2);
        System.out.println(b);


        //扩展
        String s1=new String("aa");
        String s2=new String("aa");
        /**
         * String类继承Object
         * 重写父类的方法equals,比较的是字符串内容
         * 不是地址
         */
        System.out.println(s1.equals(s2));


    }


}

-------------------------------------------------------

Regex正则表达式

/*
* 正则表达式
*      正则技术专门用于处理（复杂）字符串的功能
*      String，StringBuilder不够用
*
*  正则表达式：本质上就是一种规则，使用字符串和规则进行匹配
*
*  字符规则：
*      [abc]  :这个字符必须abc
*      [^abc]  :这个字符不能是abc
*      [a-zA-Z]  :这个字符可以是所有的字母
*      [^a-zA-Z]  :这个字符不可以是所有的字母
*      [0-9]  :这个字符必须是数字
*      [^0-9] :    这个字符不能是数字
*      [a-zA-Z0-9] : 这个字符可以是字母或者数字
*      [^a-zA-Z0-9] : 这个字符不可以是字母或者数字
*
*
*  预定义字符：
*        . : 匹配任意字符
*        \d : 这个字符必须是数字[0-9]
*        \D : 这个字符不能是数字[^0-9]
*        \w : 这个字符只能是单词字符 [a-zA-Z0-9_]
*         \W : 这个字符不能是单词字符 [^a-zA-Z0-9_]
*
*   数量词
*       X* :  X这个字符出现0次或者多次
*       X? :  X这个字符出现一次或者一次也没有
*       X+ :  X这个字符出现一次或者多次
*       X{m}: X这个字符出现正好m次
*       X{m,}:X这个字符出现至少m次
*       X{m,n}:X这个字符出现至少m次,但是不超过n次
*
*   * */
public class RegexTest {
    public static void main(String[] args) {
        method03();

        System.out.println("\"hello\"");//扩展
    }

    /*
     * 定义正则表达式,检测电子邮件
     */

    public static void method03(){
        String email="mys2s@sina.com.cn.asia";
          /* @前 字母小写 数字 _  长度不固定 +
           @后 域名小写字母数字  +
           .后面  字母小写  +
         *
         */
          String regex="[a-z0-9]+@[a-z0-9]+(\\.[a-z]+)+";
        boolean b = email.matches(regex);
        System.out.println(b);
    }




    /*
     * 定义正则表达式,检测手机号码 格式
     */
    public static void method02(){
        String tel="18000000000";
        //手机规则: 全数字 必须1开头 必须11位  第二位可以是 3456789
        String regex="1[3459678][\\d]{9}";
        boolean b = tel.matches(regex);
        System.out.println(b);
    }




    /*
     * 定义正则表达式,检测QQ号码
     * String类方法 boolean matches(String 正则规则)
     * 字符串和规则进行匹配,完全一致,返回true
     */
    public static void method01(){
        String qq="123123132";
        //检测,号码是否合法
        //全数字,0 不能开头 长度5-12
        String regex="[1-9][0-9]{4,11}";
        //字符串对象调用方法matches(传递规则)
        boolean b = qq.matches(regex);
        System.out.println(b);
    }


}

-------------------------------------------------------

System

public class Person {
    protected void finalize() throws Throwable {
        System.out.println("垃圾回收");
    }
}

/*
* java.lang.System类
* System类包含一些有用的类字段和方法。他不能被实例化
* System类不能创建对象，里面的成员全部静态修饰，直接类名.调用即可
* 无需对象，System类私有修饰了构造方法
* 方法介绍：
*      static void exit(int )结束JVM
 *     static long currentTimeMillis()获取当前时间的毫秒值
 *     static void arraycopy() 复制数组中的元素
 *     static void gc() 开启垃圾回收器
 *
 *
 *     String   不变对象  "abc"  ['a','b','c']
 *     StringBuilder  可变对象
 */

public class SystemTest {
    public static void main(String[] args) {
        method04();
    }

    /**
     * static void arraycopy(Object src,int srcPos,Object desc,int descPos,int length) 复制数组中的元素
     * Object src: 要复制的源数组
     * int srcPos : 源数组的开始索引
     * Object desc : 要复制到的目的数组
     * int descPos : 目的数组开始索引
     * int length : 复制的数组元素的个数
     */
    public static void method04(){
        int[]src={1,2,3,4,5};
        int[]desc={6,7,8,9,0};
        System.arraycopy(src,1,desc,2,2);
        for (int i = 0; i < desc.length; i++) {
            System.out.println(desc[i]);
        }
    }






    //static void gc() 开启垃圾回收器
    //使用完毕的对象,在堆内存中,成为垃圾,JVM会不定时收取垃圾
    public static void method03(){
        //Person person = new Person();person=null
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        System.gc();

    }




    // static long currentTimeMillis()获取当前时间的毫秒值
    public static void method02(){
        long start = System.currentTimeMillis();
        for (int i = 0; i < 1000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end-start);
    }



    //static void exit(int 状态码)结束JVM
    public static void method01(){
        while(true){//死循环
            System.exit(0);
        }
    }
}