Java 复习整理day06

Java api 章节除了一下列的常用类别的用时候查文档

 

 

 

package com.it.demo01_api;

import java.util.Scanner;

/*
    案例: 演示API帮助文档的使用.

    API简介:
        概述:
            API全称是Application Programming Interface(叫: 应用程序编程接口), 本意值的是: JDK提供的类和接口,
            但是我们常说的API其实指的是: API帮助文档(就是API的说明书, 介绍API咋用的.)
        记忆:
            1.API本意指的是JDK中提供的各种功能的Java类和接口.
            2.但实际开发中, 我们常说的打开API指的不是JDK提供的Java类, 而是API 帮助文档.
            3.API 帮助文档就相当于说明书, 是用来介绍JDK提供的各个接口类的功能的, 从而帮助我们快速上手使用.
        使用步骤:
            1. 打开API.
            2. 点击左上角的"显示" -> "索引" ->  输入你要找的类名 -> 敲回车键即可找到该类的说明(如果有重名类, 你就自己多试几次)
            3. 看类所在的包.
                java.lang包下的内容可以直接用, 其他包下的类和接口在使用之前需要先导包.
            4. 大概的看下类的继承体系, 知道它有哪些父类, 哪些子类.
            5. 大概的看下类的说明, 知道这个类是干嘛的即可, 一般只读第一句话.
            6. 看类有无构造方法.
                有: 说明该类的成员方法基本都是非静态的, 需要通过 对象名. 的形式调用.
                无: 说明该类的成员方法基本都是静态的, 需要通过 类名. 的形式调用.
            7. 具体调用方法的步骤.
                1. 写方法名.   用谁写谁, 注意大小写, 不要写错了.
                2. 传参.       方法要什么类型的数据, 我们就传入什么类型的值.
                3. 接收返回值. 方法返回什么类型的值, 我们就用对应的变量来接收.
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求: 通过Scanner接收用户录入的字符串
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入您的姓名: ");
        String line = sc.nextLine();
        System.out.println(line);
    }
}

 

package com.it.demo01_api;

import java.util.Scanner;

/*
    补充案例: 关于Scanner使用时的小问题.

    问题描述:
        先用nextInt()接收整数, 在用nextLine()接收字符串, 导致nextLine()方法无效.
    产生原因:
        1. nextInt() 和  nextLine()方法的结束标记都是  回车换行符\r\n
        2. nextInt()方法只接受用户录入的整数, 不接收 \r\n
        3. \r\n遗留下来之后, 被nextLine()方法识别到了, 导致nextLine()方法直接结束.
    解决方案:
        方式一: 采用next()方法接收字符串.       弊端: next()方法的结束标记是 空格, 空格之后的数据它接收不到.
        方式二: 重新调用一次nextLine()方法.
        方式三: 重新创建Scanner对象.
        方式四: 都用字符串接收, 然后字符串数字, 转成int数字即可.       //实际开发写法.
            int num = Integer.parseInt("123");
 */
public class Demo02 {
    public static void main(String[] args) {
        //method01();

        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数:");
        String str = sc.nextLine();             //"123"
        int num = Integer.parseInt(str);        //123
        System.out.println(num + 0);

        System.out.println("请录入一个字符串: ");
        String line = sc.nextLine();
        System.out.println(line);
    }

    public static void method01() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个整数:");
        int num = sc.nextInt();         // 10  +  \r\n
        System.out.println(num);

        System.out.println("请录入一个字符串: ");


        //方式一: 采用next()方法接收字符串.
        //String line = sc.next();            //结束标记是: 空格.

        //方式二: 重新调用一次nextLine()方法.
        /*String line = sc.nextLine();
        line = sc.nextLine();*/

        //方式三: 重新创建Scanner对象.
        sc = new Scanner(System.in);
        String line = sc.nextLine();


        System.out.println(line);
    }
}

 

object类常用的方法tostring   equals

package cn.it.demo01;

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;
    }
    /*
     * 重写父类的方法toString()
     * 没有必要让调用者看到内存地址
     * 要求: 方法中,返回类中所有成员变量的值
     */
    public String toString(){
        return name + age;
    }
    
    
    /*
     * 将父类的equals方法写过来,重写父类的方法
     * 但是,不改变父类方法的源代码, 方法equals 比较两个对象的内存地址
     * 
     * 两个对象,比较地址,没有意义
     * 比较两个对象的成员变量,age
     * 两个对象变量age相同,返回true,不同返回false
     * 
     * 重写父类的equals,自己定义自己对象的比较方式
     */
    public boolean equals(Object obj){
        if( this == obj){
            return true;
        }
        
        //对参数obj,非null判断
        if( obj == null){
            return false;
        }
        
        if( obj instanceof Person){
            // 参数obj接受到是Person对象,才能转型
            // 对obj参数进行类型的向下转型,obj转成Person类型
            Person p = (Person)obj;
            return this.age ==  p.age;
        }
        return false;
    }
    
    
    
    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;
    }
    
     
}


package cn.it.demo01;

public class TestEquals {
    public static void main(String[] args) {
        //Person类继承Object类,继承下来了父类的方法equals
        Person p1 = new Person("李四",20);
        Person p2 = new Person("张三",20);
        
      
        //Person对象p1,调用父类的方法equals,进行对象的比较
        boolean b = p1.equals(p1);
        System.out.println(b);
        boolean bo  = p1.equals(p2);
    }
}


package cn.it.demo01;


public class TestToString {
    public static void main(String[] args) {
        //调用Person类的方法toString()
        //输出语句中,写的是一个对象,默认调用对象的toString方法
        Person p = new Person("张三",20);
        String s = p.toString();
        System.out.println(p);
        System.out.println(s);
        /*
         * System.out.println(p);
         * System.out.println(p.toString());
         */
        
        /*Random r = new Random();
        System.out.println(r.toString());
        
        Scanner sc = new Scanner(System.in);
        System.out.println(sc.toString());*/
    }
}

 

 

package com.it.demo02_object;

//学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.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;
    }


    //手动方式重写: Object#toString()
   /* @Override
    public String toString() {
        return name + "..." + age;
    }*/

   //实际开发写法: 快捷键自动生成.

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    //重写Object#equals()方法, 改为比较对象的各个属性值是否相同.
    @Override
    public boolean equals(Object o) {       //s1.equals(s2)
        /*
            s1:   this
            s2:    o     student
         */

        //1. 提高代码的效率, 有可能要比较的两个对象是同一个对象.
        if (this == o) return true;

        //2. 提高代码的健壮性, 有可能要比较的两个对象不是同一个类型的对象
        if (o == null || getClass() != o.getClass()) return false;

        //3. 向下转型, 然后比较两个对象的各个属性是否相同.
        Student student = (Student) o;
        //比较年龄
        if (age != student.age) return false;
        //比较姓名, 因为姓名是String类型, 所以调用的是String#equals()
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

package com.it.demo02_object;

public class Teacher {
}


package com.it.demo02_object;

/*
    案例: Object类的toString()方法详解.

    Object类简介:
        概述:
            它是所有类的父类, 所有的类(包括数组类型)都直接或者间接继承自Object类.
        构造方法:
            public Object();        Object类只有一个空参构造, 这也是为啥所有子类构造方法第一行默认都是super(), 而不是带参构造的原因.
        成员方法:
            public String toString();              返回该对象的字符串形式(地址值), 地址值的组成: 全类名, @标记符, 该对象的哈希码的无符号的十六进制形式组成.
                                                   无意义, 子类一般都会重写该方法, 改为打印: 各个属性值.

            public boolean equals(Object obj);     比较两个对象是否相等, 默认比较的是地址值, 无意义, 子类一般都会重写该方法, 改为比较两个对象的各个属性值.
                                                   细节: 实际开发中, 我们认为 如果两个对象的各个属性值都相同, 那么它们就是同一个对象.

     细节(记忆):
        输出语句直接打印对象, 默认调用了对象的 toString()方法.
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求1: 创建学生类的对象, 并打印.
        Student s1 = new Student("刘亦菲", 33);
        System.out.println(s1.toString());              //这里的toString()方法是从 Object类继承过来的.
        System.out.println(s1);                         //输出语句直接打印对象, 默认调用了对象的 toString()方法.
    }
}


package com.it.demo02_object;

/*
    案例: Object类的equals()方法详解.

    Object类简介:
        概述:
            它是所有类的父类, 所有的类(包括数组类型)都直接或者间接继承自Object类.
        构造方法:
            public Object();        Object类只有一个空参构造, 这也是为啥所有子类构造方法第一行默认都是super(), 而不是带参构造的原因.
        成员方法:
            public String toString();              返回该对象的字符串形式(地址值), 地址值的组成: 全类名, @标记符, 该对象的哈希码的无符号的十六进制形式组成.
                                                   无意义, 子类一般都会重写该方法, 改为打印: 各个属性值.

            public boolean equals(Object obj);     比较两个对象是否相等, 默认比较的是地址值, 无意义, 子类一般都会重写该方法, 改为比较两个对象的各个属性值.
                                                   细节: 实际开发中, 我们认为 如果两个对象的各个属性值都相同, 那么它们就是同一个对象.

     细节(记忆):
        输出语句直接打印对象, 默认调用了对象的 toString()方法.

     面试题:
        == 和 equals()方法的区别是什么?

 */

public class Demo02 {
    public static void main(String[] args) {
        //需求1: 创建两个学生对象, 姓名和年龄都是 23, 比较他们是否相同.
        Student s1 = new Student("刘亦菲", 33);
        Student s2 = new Student("刘亦菲", 33);
        Student s3 = new Student("赵丽颖", 31);
        //比较s1和s2是否相同
        System.out.println(s1.equals(s2));      //true
        System.out.println(s1.equals(s3));      //false

        //有没有可能出现这种情况: s1 和 s1比较
        System.out.println(s1.equals(s1));      //true
        System.out.println("----------------");

        //有没有可能出现这种情况: 要比较的两个对象不是同一个类型的对象.
        Teacher t1 = new Teacher();
        System.out.println(s1.equals(t1));
    }
}


package com.it.demo02_object;

/*
    案例: 演示面试题之  == 和 equals()方法的区别是什么?

    答案:
        1. 功能不同.
            ==既能比较基本类型, 也能比较引用类型.
                比较基本类型时比较的是: 数值,
                比较引用类型时比较的是: 地址值.
            equals()方法, 只能比较引用类型, 默认比较的是地址值, 无意义, 子类一般都会重写该方法.
        2. 本质不同.
            == 是比较(关系)运算符.
            equals() 是方法.
 */
public class Demo03 {
    public static void main(String[] args) {
        //需求: 演示==的用法.
        int a = 10;
        int b = 20;
        System.out.println(a == b);     //false, 比较数值

        Student s1 = new Student("刘亦菲", 33);
        Student s2 = new Student("刘亦菲", 33);
        System.out.println(s1 == s2);           //false, 比较的是地址值.


        //需求: 演示equals()方法 只能比较引用类型
        System.out.println(s1.equals(s2));      //不报错

        //System.out.println(a.equals(b));        //报错, 因为a,b都是基本类型的数据.
    }
}

 

 

下面介绍string类

 

package com.it.demo03_string;

/*
    案例: String类快速入门

    String简介:
        概述:
            表示字符串, 字符串的本质就是一个: 字符数组.
            例如: String s = "abc"; 它的底层就是一个字符数组, 即:  char[] chs = {'a', 'b', 'c'};
        构造方法:
            public String();                                    根据空参, 创建字符串对象.
            public String(String s);                            根据传入的字符串值, 创建字符串对象.
            public String(char[] chs);                          根据传入的字符数组, 创建其对应的字符串对象.
            public String(char[] chs, int start, int len);      根据传入的字符数组的一部分内容, 创建其对应的字符串对象.
            public String(byte[] bys);                          根据传入的字节数组, 创建其对应的字符串对象.
            public String(byte[] bys, int start, int len);      根据传入的字节数组的一部分内容, 创建其对应的字符串对象.
    需求:
        1.分别通过上述的三种方式创建字符串对象.
        2.在main方法中, 通过输出语句, 直接打印创建好的字符串对象.
         提示: 输出语句直接打印对象, 默认调用了对象的toString()方法.
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求1: 测试空参
        String s1 = new String();
        System.out.println("s1: " + s1);

        //需求2: 测试 public String(String s);
        String s2 = new String("abc");
        System.out.println("s2: " + s2);        //这里打印结果不是地址值,而是字符串值, 原因是因为: String类已经重写了Object类的toString()方法.

        //需求3: 测试   public String(char[] chs);
        char[] chs = {'a', 'b', 'c', 'd', 'e', 'f'};
        String s3 = new String(chs);
        System.out.println("s3: " + s3);

        //需求4: 测试 public String(char[] chs, int start, int len);   start:起始索引, len: 长度
        //目标: 获取cde
        String s4 = new String(chs, 2, 3);
        System.out.println("s4: " + s4);

        //需求5: 测试 public String(byte[] bys);
        byte[] bys = {65, 66, 67, 68, 69};
        String s5 = new String(bys);
        System.out.println("s5: " + s5);        //ABCDE

        //需求6: 测试 public String(byte[] bys, int start, int len);
        //目标: CD
        String s6 = new String(bys, 2, 2);
        System.out.println("s6: " + s6);

        /*
            补充:
                 因为String类型在实际开发中非常常用, 如果每次让我们通过new的方式创建对象的话, 是非常繁琐的.
                 针对于这种情况, sun公司提供了针对于String类型的语法糖, 即: 免new.
         */
        //实际开发中创建字符串对象的方式如下:
        String s7 = "abc";
        s7 = "bcd";         //字符串是常量；它们的值在创建之后不能更改   这句话的意思是; 字符串值不能变化, 例如: "abc"永远都是"abc"
        System.out.println("s7: " + s7);
    }
}

package com.it.demo03_string;

/*
    案例: 演示String类的特点.

    结论(记忆):
        1. 如果是通过new的方式创建字符串对象, 则每个对象的地址值都不同, 且对象存储在堆区.
        2, 如果是通过 免new 的方式创建字符串对象, 如果内容相同, 它们地址值也相同, 且对象存储在 方法区的常量池中.
 */
public class Demo02 {
    public static void main(String[] args) {
        //1.定义字符数组chs, 初始化值为: 'a, 'b', 'c', 这三个字符 .
        char[] chs = {'a', 'b', 'c'};
        //2.将其分别封装成s1, s2这两个字符串对象.
        String s1 = new String(chs);
        String s2 = new String(chs);
        //3.通过==判断s1和s2这两个字符串对象是否相同.
        System.out.println(s1 == s2);           //false, 原因有两点: 1. 这里的==比较的是地址值.  2. new了两次, 有两个地址值.

        //4.直接通过""的方式创建两个字符串对象s3和s4.
        String s3 = "abc";
        String s4 = "abc";
        //5.通过==判断s3和s4这两个字符串对象是否相同.
        System.out.println(s3 == s4);           //true, 原因是:  如果是通过 免new 的方式创建字符串对象, 如果内容相同, 它们地址值也相同.
    }
}

 

package com.it.demo03_string;

/*
    案例: 演示String的常量池问题.

    Java中针对于byte和String类型, 有常量优化机制.
        针对于byte类型:
            如果是常量相加: 会直接运算, 然后看结果在不在左边的数据类型范围内, 在不报错, 否则就报错.
            如果是变量相加; 会提升类型, 然后再运算, 提升顺序是: byte, short, char -> int -> long -> float -> double
        针对于String类型:
            如果是常量拼接: 会直接拼接, 不会(在堆区)创建新空间, 而是在常量池直接拼接的.
            如果是变量拼接: 会在堆区创建新对象.
        相同点是:
            如果同时有变量和常量参与, 按照"变量的处理方案"走.
 */
public class Demo03 {
    public static void main(String[] args) {
        byte b1 = 3;
        byte b2 = 4;
        byte b3 = 3 + 4;
        //byte b4 = b1 + b2;        //报错, 因为会提升数据类型.
        //byte b5 = b1 + 4;         //报错, 因为会提升数据类型
        System.out.println("---------------------------------------------");


        String s1 = "ab";
        String s2 = "c";
        String s3 = "abc";

        //它的底层代码是: s3 == new StringBuilder().append(s1).append(s2).toString();
        System.out.println(s3 == s1 + s2);      //false
        System.out.println(s3 == s1 + "c");     //false
        System.out.println(s3 == "ab" + "c");   //true


        //实际开发中, 我们用equals()方法比较内容.
        //System.out.println(s3.equals(s1 + s2));
    }
}

package com.it.demo03_string;

/*
    案例: 演示字符串的比较.

    涉及到的String类中的成员方法:
        public boolean equals(Object obj);          //比较两个字符串的内容是否相同, 区分大小写.
                                                    //这个方法是重写的Object#equals()方法, 所以形参类型是Object.

        public boolean equalsIgnoreCase(String s);  //比较两个字符串的内容是否相同, 不区分大小写.
                                                    //这个方法是String类独有的方法, 所以形参类型具体是啥类型, String说了算.
 */
public class Demo04 {
    public static void main(String[] args) {
        //1.定义字符数组chs, 初始化值为: 'a, 'b', 'c', 这三个字符 .
        char[] chs = {'a', 'b', 'c'};
        //2.将其分别封装成s1, s2这两个字符串对象.
        String s1 = new String(chs);
        String s2 = new String(chs);

        //3.直接通过""的方式创建两个字符串对象s3和s4.
        String s3 = "abc";
        String s4 = "abc";

        //4.通过==分别判断s1和s2, s1和s3, s3和s4是否相同.
        System.out.println(s1 == s2);           //false
        System.out.println(s1 == s3);           //false
        System.out.println(s3 == s4);           //true
        System.out.println("-----------------------");

        //5.通过equals()分别判断s1和s2, s1和s3, s3和s4是否相同.
        System.out.println(s1.equals(s2));      //true
        System.out.println(s1.equals(s3));      //true
        System.out.println(s3.equals(s4));      //true
        System.out.println("-----------------------");

        //6.通过equalsIgnoreCase()判断字符串abc和ABC是否相同.
        System.out.println("abc".equalsIgnoreCase("ABC"));      //true, 忽略大小写
        System.out.println("ABC".equalsIgnoreCase("ABC"));      //true
        System.out.println("-----------------------");

        System.out.println("abc".equals("ABC"));                //false, 区分大小写.
    }
}

 

package cn.it.demo02;
/*
 *   String类特点:
 *     一切都是对象,字符串事物 "" 也是对象
 *     类是描述事物,String类,描述字符串对象的类
 *     所有的 "" 都是String类的对象
 *     
 *     字符串是一个常量,一旦创建,不能改变
 */
public class StringDemo {
    public static void main(String[] args) {
        //引用变量str执行内存变化
        //定义好的字符串对象,不变
        String str = "it";
        System.out.println(str);
        str = "it";
        System.out.println(str);
        
        
    }
}

package cn.it.demo02;

public class StringDemo2 {
    public static void main(String[] args) {
        //字符串定义方式2个, 直接=  使用String类的构造方法
        String str1 = new String("abc");
        String str2 = "abc";
        System.out.println(str1);
        System.out.println(str2);
        
        System.out.println(str1==str2);//引用数据类型,比较对象的地址 false
        System.out.println(str1.equals(str2));//true
    }
}

package cn.it.demo02;
 /*
  *  String类构造方法
  *  String类的构造方法,重载形式
  * 
  */
public class StringDemo3 {
    public static void main(String[] args) {
        function_1();
    }
    /*
     * String(char[] value) 传递字符数组
     * 将字符数组,转成字符串, 字符数组的参数,不查询编码表
     * 
     * String(char[] value, int offset, int count) 传递字符数组
     * 将字符数组的一部分转成字符串
     * offset  数组开始索引
     * count   个数
     */
    public static void function_1(){
        char[] ch = {'a','b','c','d','e','f'};
        //调用String构造方法,传递字符数组
        String s = new String(ch);
        System.out.println(s);
        
        String s1 = new String(ch,1,4);
        System.out.println(s1);
    }
    
    
    /*
     *  定义方法,String类的构造方法
     *  String(byte[] bytes)  传递字节数组
     *  字节数组转成字符串
     *  通过使用平台的默认字符集解码指定的 byte 数组，构造一个新的 String。
     *  平台 : 机器操作系统
     *  默认字符集: 操作系统中的默认编码表, 默认编码表GBK
     *  将字节数组中的每个字节,查询了编码表,得到的结果
     *  字节是负数,汉字的字节编码就是负数, 默认编码表 ,一个汉字采用2个字节表示
     *  
     *  String(byte[] bytes, int offset, int length) 传递字节数组
     *  字节数组的一部分转成字符串
     *  offset 数组的起始的索引
     *  length 个数,转几个   , 不是结束的索引
     */
    public static void function(){
        byte[] bytes = {97,98,99,100};
        //调用String类的构造方法,传递字节数组
        String s = new String(bytes);
        System.out.println(s);
        
        byte[] bytes1 ={65,66,67,68,69};
        //调用String构造方法,传递数组,传递2个int值
        String s1 = new String(bytes1,1,3);
        System.out.println(s1);
    }
}

 

package cn.it.demo02;
/*
 *  String类的查找功能
 */
public class StringDemo4 {
    public static void main(String[] args) {
        function_9();
    }
    /*
     *  boolean equals(Object obj)
     *  方法传递字符串,判断字符串中的字符是否完全相同,如果完全相同返回true
     *  
     *  boolean equalsIgnoreCase(String s)
     *  传递字符串,判断字符串中的字符是否相同,忽略大小写
     */
    public static void function_9(){
        String str1 = "Abc";
        String str2 = "abc";
        //分别调用equals和equalsIgnoreCase
        boolean b1 = str1.equals(str2);
        boolean b2 = str1.equalsIgnoreCase(str2);
        System.out.println(b1);
        System.out.println(b2);
    }
    
    /*
     * char[] toCharArray() 将字符串转成字符数组
     * 功能和构造方法相反
     */
    public static void function_8(){
        String str = "itcast";
        //调用String类的方法toCharArray()
        char[] ch = str.toCharArray();
        for(int i = 0 ; i < ch.length ; i++){
            System.out.println(ch[i]);
        }
    }
    
    /*
     *  byte[] getBytes() 将字符串转成字节数组
     *  此功能和String构造方法相反
     *  byte数组相关的功能,查询编码表
     */
    public static void function_7(){
        String str = "abc";
        //调用String类方法getBytes字符串转成字节数组
        byte[] bytes = str.getBytes();
        for(int i = 0 ; i < bytes.length ; i++){
            System.out.println(bytes[i]);
        }
    }
    
    /*
     *  int indexOf(char ch)
     *  查找一个字符,在字符串中第一次出现的索引
     *  被查找的字符不存在,返回-1
     */
    public static void function_6(){
        String str = "itcast.cn";
        //调用String类的方法indexOf
        int index = str.indexOf('x');
        System.out.println(index);
    }
    
    /*
     *  boolean contains (String s)
     *  判断一个字符串中,是否包含另一个字符串
     */
    public static void function_5(){
        String str = "itcast.cn";
        //调用String类的方法contains
        boolean b =str.contains("ac");
        System.out.println(b);
    }
    
    /*
     * boolean endsWith(String prefix)
     * 判断一个字符串是不是另一个字符串的后缀,结尾
     * Demo.java
     *     .java
     */
    public static void function_4(){
        String str = "Demo.java";
        //调用String类方法endsWith
        boolean b = str.endsWith(".java");
        System.out.println(b);
    }
    
    /*
     * boolean startsWith(String prefix)  
     * 判断一个字符串是不是另一个字符串的前缀,开头
     * howareyou
     * hOw
     */
      public static void function_3(){
          String str = "howareyou";
          //调用String类的方法startsWith
          boolean b = str.startsWith("hOw");
          System.out.println(b);
      }
    
    /*
     *  String substring(int beginIndex,int endIndex) 获取字符串的一部分
     *  返回新的字符串
     *  包含头,不包含尾巴
     *  
     *  String substring(int beginIndex)获取字符串的一部分
     *  包含头,后面的字符全要
     */
    public static void function_2(){
        String str = "howareyou";
        //调用String类方法substring获取字符串一部分
        str= str.substring(1, 5);
        System.out.println(str);
        
        String str2 = "HelloWorld";
        str2 = str2.substring(1);
        System.out.println(str2);
    }
    
    /*
     *  int length() 返回字符串的长度
     *  包含多少个字符
     */
    public static void function(){
        String str = "cfxdf#$REFewfrt54GT";
        //调用String类方法length,获取字符串长度
        int length = str.length();
        System.out.println(length);
    }
}

 

package cn.it.demo02;

public class StringTest {
    public static void main(String[] args) {
        getCount("A%A3eBr1FFy");
        System.out.println(toConvert("aBc5%4dEF"));
        System.out.println(getStringCount("hellojava,nijavahaojava,javazhenbang", "java"));
    }
    /*
     *  获取一个字符串中,另一个字符串出现的次数
     *  思想:
     *    1. indexOf到字符串中到第一次出现的索引
     *    2. 找到的索引+被找字符串长度,截取字符串
     *    3. 计数器++
     */
    public static int getStringCount(String str, String key){
        //定义计数器
        int count = 0;
        //定义变量,保存indexOf查找后的索引的结果
        int index = 0;
        //开始循环找,条件,indexOf==-1 字符串没有了
        while(( index = str.indexOf(key) )!= -1){
            count++;
            //获取到的索引,和字符串长度求和,截取字符串
            str = str.substring(index+key.length());
        }
        return count;
    }
    
    /*
     *  将字符串的首字母转成大写,其他内容转成小写
     *  思想:
     *    获取首字母, charAt(0)  substring(0,1)
     *    转成大写 toUpperCase()
     *    
     *    获取剩余字符串, substring(1)  toLowerCase()
     */
    public static String toConvert(String str){
        //定义变量,保存首字母,和剩余字符
        String first = str.substring(0,1);
        String after = str.substring(1);
        //调用String类方法,大写,小写转换
        first = first.toUpperCase();
        after = after.toLowerCase();
        return first+after;
    }
    
    /*
     * 获取指定字符串中，大写字母、小写字母、数字的个数。
     * 思想:
     *   1. 计数器,就是int变量,满足一个条件 ++
     *   2. 遍历字符串, 长度方法length() + charAt() 遍历
     *   3. 字符判断是大写,是小写,还是数字
     */
    public static void getCount(String str){
        //定义三个变量,计数
        int upper = 0;
        int lower = 0;
        int digit = 0;
        //对字符串遍历
        for(int i = 0 ; i < str.length() ; i++){
            //String方法charAt,索引,获取字符
            char c = str.charAt(i);
            //利用编码表 65-90  97-122  48-57
            if(c >='A' && c <=90){
                upper++;
            }else if( c >= 97 && c <= 122){
                lower++;
            }else if( c >= 48 && c <='9'){
                digit++;
            }
        }
        System.out.println(upper);
        System.out.println(lower);
        System.out.println(digit);
    }
}

package com.it.demo04_exercise;

import java.util.Scanner;

/*
    案例: 模拟用户登录

    需求:
        1.模拟用户登录, 只给3次机会, 登录成功则提示"欢迎您, ***".
        2.登录失败则判断是否还有登录机会, 有则提示剩余登录次数, 没有则提示"您的账号已被锁定".
        3.假设初始化账号和密码分别为: "传智播客", "黑马程序员".
 */
public class Demo01 {
    public static void main(String[] args) {
        //实际开发小技巧演示:
        //method01();

        //1. 定义两个字符串变量, 分别表示用户名和密码.
        String username = "传智播客", password = "黑马程序员";

        //2. 创建键盘录入对象, 用于接收用户录入的数据.
        Scanner sc = new Scanner(System.in);

        //3. 提示用户录入并接收, 因为有3次机会, 所以我们用for循环.
        for (int i = 0; i < 3; i++) {   //i的值的变化: 0, 1, 2
            //4. 接收用户录入的数据
            System.out.println("请录入账号:");
            String uname = sc.nextLine();
            System.out.println("请录入密码:");
            String pw = sc.nextLine();
            //5. 判断用户录入的数据是否合法
            if (username.equals(uname) && password.equals(pw)) {
                //6. 如果合法, 则提示 欢迎您, ***   然后结束循环
                System.out.println("欢迎您, " + username);
                break;
            } else {
                //7. 如果不合法, 说用用户录入有误, 则判断是否还有登陆机会
                if (i != 2) {
                    //8. 如果有, 则提示: 用户名或者密码错误, 您还有*次登陆机会
                    System.out.println("用户名或者密码错误, 您还有"+ (2-i) +"次登陆机会");
                } else {
                    //9. 如果没有, 则提示: 账号被锁定, 请于管理员联系.
                    System.out.println("账号被锁定, 请于管理员联系.");
                }
            }
        }
    }


    public static void method01() {
    /*
        细节(实际开发小技巧):
            如果是变量和常量调用方法进行操作, 在不影响代码运行结果的情况下, 一般常量在前, 变量在后.
            这样做能规避: 空指针异常.
     */
        String s1 = null;
        System.out.println("ab".equals(s1));
        System.out.println(s1.equals("ab"));
    }
}

package com.it.demo04_exercise;

import java.util.Scanner;

/*
    案例: 演示如何 遍历字符串, 即: 逐个获取字符串中的字符并打印.

    涉及到的String类中的成员方法:
        public int length();            获取字符串的长度.
        public char charAt(int index);  根据索引, 获取其对应的字符

    细节:
        因为字符串的底层其实就一个字符数组, 所以字符串中的每个字符都是有索引的, 且索引是从0开始的.

    需求: 键盘录入一个字符串, 然后并遍历.
 */
public class Demo02 {
    public static void main(String[] args) {
        //1. 创建键盘录入对象.
        Scanner sc = new Scanner(System.in);
        //2. 提示用户录入字符串, 并接收.
        System.out.println("请录入一个字符串: ");
        String str = sc.nextLine();         //abcd

        //3. 遍历字符串.
        //方式一: 最Low版本
        /*System.out.println(str.charAt(0));
        System.out.println(str.charAt(1));
        System.out.println(str.charAt(2));
        System.out.println(str.charAt(3));*/

        //方式二: 推荐使用版本.
        for (int i = 0; i < str.length(); i++) {
            //根据索引, 获取对应的字符
            char ch = str.charAt(i);
            //打印
            System.out.println(ch);
        }
    }
}

package com.it.demo04_exercise;

import java.util.Scanner;

/*
    案例: 演示统计字符的个数.

    需求:
        键盘录入一个字符串, 统计该字符串中大写字母字符, 小写字母字符, 数字字符出现的次数.
        注意: 不考虑其他字符, 例如@, !, \, /等
 */
public class Demo03 {
    public static void main(String[] args) {
        //1. 创建键盘录入对象.
        Scanner sc = new Scanner(System.in);

        //2. 提示用户录入字符串, 并接收.
        System.out.println("请录入一个字符串: ");
        String str = sc.nextLine();         //ABCab123

        //3. 定义三个统计变量, 分别记录大写字母字符, 小写字母字符, 以及数字字符出现的次数.
        int bigCount = 0, smallCount = 0, numberCount = 0;

        //4. 遍历字符串, 获取到每一个字符.
        for (int i = 0; i < str.length(); i++) {
            //ch: 就是字符串中的每一个字符.
            char ch = str.charAt(i);
            //5. 判断当前字符属于哪种字符, 是哪种, 对应的计数器就++

            //最Low版, 自己手动写 范围
            //if (ch >= 97 && ch <= 122)    //判断是否是小写字母
            if (ch >= 'a' && ch <= 'z')     //判断是否是小写字母
                smallCount++;
            else if (ch >= 'A' && ch <= 'Z')
                bigCount++;
            else if (ch >= '0' && ch <= '9')
                numberCount++;
        }
        //6. for循环结束后, 计数器记录的就是我们要的结果, 打印即可.
        System.out.println("大写字母字符出现的次数是: " + bigCount);
        System.out.println("小写字母字符出现的次数是: " + smallCount);
        System.out.println("数字字符出现的次数是: " + numberCount);
    }
}

package com.it.demo04_exercise;

/*
    案例: 演示字符串的拼接.

    需求:
        1.定义方法arrayToString(), 把int数组的元素按照指定的格式拼接成一个字符串, 并返回.
        2.在main方法中, 调用上述的方法.
        3.例如: 数组为int[] arr = {1, 2, 3}, 则拼接后, 结果为: [1, 2, 3]f
 */
public class Demo05 {
    public static void main(String[] args) {
        //需求: 调用array2String()方法
        int[] arr = {1, 2, 3};
        System.out.println(array2String(arr));
    }

    /*
        分析: 定义方法arrayToString(), 把int数组的元素按照指定的格式拼接成一个字符串, 并返回.
            1. 明确方法名.               array2String
            2. 明确参数列表.             int[]
            3. 明确返回值的数据类型.     String
     */

    /**
     * 定义方法, 用来打印数组元素
     * @param arr   要遍历的数组
     * @return  按照指定格式拼接后的数组.
     */
    public static String array2String(int[] arr) {
        //1. 判断数组元素是否合法.
        if (arr == null || arr.length == 0)
            return "[]";

        //2. 定义字符串变量, 用来记录拼接的结果.
        String s = "[";
        //3. 正常的拼接逻辑.
        for (int i = 0; i < arr.length; i++) {
            //arr[i] 记录的就是数组中的每个元素.
            //分解版
            //判断是否是最后一个元素
            /*if (i == arr.length - 1)
                s += (arr[i] + "]");
            else
                s += (arr[i] + ", ");*/

            //合并版
            s += (arr[i] + (i == arr.length - 1 ? "]" : ", "));

        }
        //4. 返回结果
        return s;
    }
}

 

package com.it.demo04_exercise;


import java.util.Scanner;

/*
    案例: 演示字符串内容的反转.

    需求:
        1.定义方法reverse(), 实现字符串的反转.
        2.在main方法中键盘录入一个字符串, 调用上述的方法后, 在控制台输出结果.
        3.例如: 键盘录入abc, 输出结果cba.
        提示: 用for循环, 倒序遍历数组, 然后拼接每一个元素即可.
 */
public class Demo06 {
    public static void main(String[] args) {
        //需求: 调用reverse(), 实现字符串的反转
        Scanner sc = new Scanner(System.in);
        System.out.println("请录入一个字符串, 我来帮你反转它的内容: ");
        String line = sc.nextLine();

        //类似于面向过程编程思想, 即: 每一步都需要我们亲力亲为, 自己做.
        String result = reverse(line);
        System.out.println(result);
        System.out.println("-----------------------------------");

        //类似于面向对象编程思想, 找对象做.
        //思路: String -> StringBuilder -> StringBuilder#reverse()反转 -> String
        String result2 = new StringBuilder(line).reverse().toString();
        System.out.println(result2);
    }

    //需求: 定义方法reverse(), 实现字符串的反转

    /**
     *  用来实现字符串内容的反转.
     * @param s 要操作的字符串.
     * @return 反转后的内容.
     */
    public static String reverse(String s) {
        //1. 判断s是否合法
        if (s == null || s.length() == 0)
            return "";

        //2. 定义字符串 reverseStr, 用来记录反转后的内容.
        String reverseStr = "";

        //3. 倒序遍历字符串, 获取到每一个字符.
        for (int i = s.length() - 1; i >= 0; i--) {
            //ch就是字符串中的 每个字符.
            char ch = s.charAt(i);
            //4. 将获取到的字符拼接给: reverseStr遍历.
            reverseStr += ch;
        }

        //5. 返回结果 reverseStr.
        return reverseStr;
    }
}

 

package com.it.demo04_exercise;

/*
    案例: 演示把数组元素拼接成指定的字符串数据.

    需求:
        1.定义方法arrayToString(), 把int数组的元素按照指定的格式拼接成一个字符串, 并返回.
        2.在main方法中, 调用上述的方法.
        3.例如: 数组为int[] arr = {1, 2, 3}, 则拼接后, 结果为: [1, 2, 3]f
 */
public class Demo07 {
    public static void main(String[] args) {
        //需求: 调用array2String()方法
        int[] arr = {1, 2, 3};
        System.out.println(array2String(arr));
    }

     /*
        分析: 定义方法arrayToString(), 把int数组的元素按照指定的格式拼接成一个字符串, 并返回.
            1. 明确方法名.               array2String
            2. 明确参数列表.             int[]
            3. 明确返回值的数据类型.     String
     */

    /**
     * 定义方法, 用来打印数组元素
     *
     * @param arr 要遍历的数组
     * @return 按照指定格式拼接后的数组.
     */
    public static String array2String(int[] arr) {
        //1. 判断数组是否合法.
        if (arr == null || arr.length == 0)
            return "[]";

        //走到这里, 说明数组是合法的, 且有元素.
        //2. 定义StringBuilder,用来记录拼接字符串的结果.
        StringBuilder sb = new StringBuilder("[");

        //3. 遍历int[]数组, 获取每一个元素.
        for (int i = 0; i < arr.length; i++) {
            //arr[i]: 记录的就是数组中的当前元素.
            //4. 拼接元素.
            //Low版本, if判断实现.
            /*if (i == arr.length - 1)
                sb.append(arr[i]).append("]");
            else
                sb.append(arr[i]).append(", ");*/

            //推荐版本: 三元运算符实现
            sb.append(arr[i]).append(i == arr.length - 1 ? "]" : ", ");
        }
        //5. 返回结果.
        return sb.toString();
    }
}

package com.it.demo04_exercise;

import javax.sound.sampled.ReverbType;
import java.util.Scanner;

/*
    案例: 通过StringBuilder对象, 反转字符串中的内容.

    需求:
        1.定义方法reverse(), 实现字符串的反转.
        2.在main方法中键盘录入一个字符串, 调用上述的方法后, 在控制台输出结果.
        3.例如: 键盘录入abc, 输出结果cba.

     思路:
        1. String -> StringBuilder
        2. StringBuilder#reverse()  可以反转数据.
        3. StringBuilder#toString() 将StringBuilder对象转成对应的字符串形式.
 */
public class Demo08 {
    public static void main(String[] args) {
        //1. 创建键盘录入对象.
        Scanner sc = new Scanner(System.in);
        //2. 接收用户录入的内容.
        System.out.println("请录入一个字符串: ");
        String str = sc.nextLine();

        //反转字符串, 分解版.
        //3. 将用户录入的内容, 封装成StringBuilder类型的对象.
        StringBuilder sb = new StringBuilder(str);
        //4. 调用StringBuilder#reverse()方法, 反转数据.
        sb.reverse();       //返回自身
        //5. 将反转之后的数据重新变成String类型的数据.
        //6. 打印结果.
        System.out.println(sb.toString());
        System.out.println("---------------------------");

        //反转字符串, 合并版, 目前能看懂即可.
        //思路: String -> StringBuilder -> StringBuilder#reverse(), 反转元素 -> StringBuilder#toString(), 将其转成字符串数据.
        /*String newStr = new StringBuilder(str).reverse().toString();
        System.out.println(newStr);*/
        System.out.println(new StringBuilder(str).reverse().toString());
    }
}

 

package com.it.demo04_exercise;

import com.sun.org.apache.regexp.internal.REUtil;

import java.util.Arrays;

/*
    案例: 关于包装类的 练习题.

    需求:
        1.已知字符串String s = "91 27 45 38 50";
        2.请通过代码实现最终输出结果是: "27, 38, 45, 50, 91"
 */
public class Demo09 {
    public static void main(String[] args) {
        //1. 定义变量, 记录要操作的字符串.       "91 27 45 38 50"
        String s = "91 27 45 38 50";
        //2. 将其转成 字符串数组.
        //扩展: String#split("分隔符");    按照指定的分隔符进行切割, 把字符串对象变成字符串数组形式.
        String[] arrStr = s.split(" ");         //"91", "27", "45", "38", "50"

        //3. 定义一个长度和上述字符串数组长度一模一样的 int类型的数组.
        int[] arr = new int[arrStr.length];     //0, 0, 0, 0, 0

        //4. 遍历第二步获取到的字符串数组, 获取到每个值, 并将其转成数字后存入int[]中.  91, 27, 45, 38, 50
        for (int i = 0; i < arrStr.length; i++) {
            //arrStr[i] 就是字符串数组中的每个值, 例如: "91", "27", "45"
            arr[i] = Integer.parseInt(arrStr[i]);
        }

        //5. 对上一步获取到的int数组元素进行升序排列.         27, 38, 45, 50, 91
        Arrays.sort(arr);

        //6. 把排序后的数组元素, 按照指定格式, 拼接成字符串.  "27, 38, 45, 50, 91"
        //方式一: 自己写代码拼接.

        //方式二: 采用String#substring()方法的功能实现,
        //String#substring(int start, int end)   按照索引截取该段的元素, 包左不包右.
        String str = Arrays.toString(arr);          //"[27, 38, 45, 50, 91]"
        String result = str.substring(1, str.length() - 1);

        //合并版
        //String result = Arrays.toString(arr).substring(1, Arrays.toString(arr).length() - 1);

        //7. 打印结果.
        System.out.println(result);
    }
}

 

package cn.it.demo03;

public class StringBufferDemo {
    public static void main(String[] args) {
        function_5();
    }
    /*
     *  StringBuffer类的方法
     *   String toString() 继承Object,重写toString()
     *   将缓冲区中的所有字符,变成字符串
     */
    public static void function_5(){
        StringBuffer buffer = new StringBuffer();
        buffer.append("abcdef");
        buffer.append(12345);
        
        //将可变的字符串缓冲区对象,变成了不可变String对象
        String s = buffer.toString();
        System.out.println(s);
    }
    
    /*
     *  StringBuffer类的方法
     *    reverse() 将缓冲区中的字符反转
     */
    public static void function_4(){
        StringBuffer buffer = new StringBuffer();
        buffer.append("abcdef");
        
        buffer.reverse();
        
        System.out.println(buffer);
    }
    
    /*
     *  StringBuffer类方法
     *    replace(int start,int end, String str)
     *    将指定的索引范围内的所有字符,替换成新的字符串
     */
    public static void function_3(){
        StringBuffer buffer = new StringBuffer();
        buffer.append("abcdef");
        
        buffer.replace(1, 4, "Q");
        
        System.out.println(buffer);
    }
    
    /*
     *  StringBuffer类方法 insert
     *    insert(int index, 任意类型)
     *  将任意类型数据,插入到缓冲区的指定索引上
     */
     public static void function_2(){
         StringBuffer buffer = new StringBuffer();
         buffer.append("abcdef");     
         
         buffer.insert(3, 9.5);
         System.out.println(buffer);
     }
    
    /*
     * StringBuffer类方法
     *   delete(int start,int end) 删除缓冲区中字符
     *   开始索引包含,结尾索引不包含
     */
    public static void function_1(){
        StringBuffer buffer = new StringBuffer();
        buffer.append("abcdef");
        
        buffer.delete(1,5);
        System.out.println(buffer);
    }
    
    /*
     *  StringBuffer类方法
     *   StringBuffer append, 将任意类型的数据,添加缓冲区
     *   append 返回值,写return this
     *   调用者是谁,返回值就是谁
     */
    public static void function(){
        StringBuffer buffer = new StringBuffer();
        //调用StringBuffer方法append向缓冲区追加内容
        buffer.append(6).append(false).append('a').append(1.5);
        System.out.println(buffer);
    }
}

 

 

package cn.it.demo03;

public class StringBufferTest {
    public static void main(String[] args) {
        int[] arr = {4,1,4,56,7,8,76};
        System.out.println(toString(arr));
    }
   /*
    * int[] arr = {34,12,89,68};将一个int[]中元素转成字符串 
    * 格式 [34,12,89,68]
    * String s = "["
    * 数组遍历
    *   s+= arr[i];
    *  s+"]"
    *  StringBuffer实现,节约内存空间, String + 在缓冲区中,append方法
    */
    public static String toString(int[] arr){
        //创建字符串缓冲区
        StringBuffer buffer = new StringBuffer();
        buffer.append("[");
        //数组遍历
        for(int i = 0 ; i < arr.length;i++){
            //判断是不是数组的最后一个元素
            if(i == arr.length-1){
                buffer.append(arr[i]).append("]");
            }else{
                buffer.append(arr[i]).append(",");
            }
        }
        return buffer.toString();
    }
}

 

package com.it.demo05_stringbuilder;

/*
    案例: 演示StringBuilder入门.

    StringBuilder简介:
        概述:
            它是java.lang包下的类, 可以直接用, 无需导包. 它表示字符串缓冲区类,
            可以把它当做一个容器, 里边的内容是可以变化的.
        应用场景:
            当涉及到大量的字符串拼接操作的时候, 就可以考虑使用: StringBuilder来实现了.
        构造方法:
            public StringBuilder();             根据空参构造, 创建StringBuilder对象.
            public StringBuilder(String s);     根据传入的字符串值, 创建其对应的StringBuilder形式的对象.
 */
public class Demo01 {
    public static void main(String[] args) {
        //1.通过上述的两种方式, 创建StringBuilder对象.
        //测试: public StringBuilder();
        StringBuilder sb1 = new StringBuilder();

        //测试: public StringBuilder(String s);
        String s = "abc";
        StringBuilder sb2 = new StringBuilder(s);

        //2.在控制台直接打印上述创建好的两个对象, 并观察结果.
        System.out.println("sb1: " + sb1);
        System.out.println("sb2: " + sb2);
    }
}

package com.it.demo05_stringbuilder;

/*
    案例: 演示StringBuilder中的成员方法.

    需求:
        1.通过空参构造创建StringBuilder类的对象sb.
        2.通过append()方法, 往sb对象中添加"hello",然后用sb2对象接收.
        3.打印对象sb和sb2的结果, 并观察.
        4.通过reverse()方法, 来反转上述的内容.

    涉及到的StringBuilder类中的成员方法:
        public StringBuilder append(任意类型);      添加元素, 返回StringBuilder对象自身.
        public StringBuilder reverse();             反转元素, 返回StringBuilder对象自身.
 */
public class Demo02 {
    public static void main(String[] args) {
        //1.通过空参构造创建StringBuilder类的对象sb.
        StringBuilder sb = new StringBuilder();
        //2.通过append()方法, 往sb对象中添加"hello",然后用sb2对象接收.
        StringBuilder sb2 = sb.append("hello");
        sb.append(10.3);
        sb2.append(false);

        //3.打印对象sb和sb2的结果, 并观察.
        System.out.println("sb: " + sb);
        System.out.println("sb2: " + sb2);
        System.out.println(sb == sb2);      //true, 因为append()方法返回的是StringBuilder对象本身.
        System.out.println("-------------------------------");

        //4.通过reverse()方法, 来反转上述的内容.
        StringBuilder sb3 = sb2.reverse();
        System.out.println("sb: " + sb);
        System.out.println("sb2: " + sb2);
        System.out.println("sb3: " + sb3);
        System.out.println("-------------------------------");


        //5. 演示链式编程, 即: 如果一个方法的返回值是对象, 那可以可以接着调用该对象所能调用的成员方法.
        StringBuilder sb4 = new StringBuilder();
        sb4.append("hello").append("world").append("java");     //链式编程
    }
}

 

package com.it.demo05_stringbuilder;

/*
    案例: 演示String 和 StringBuilder对象之间的相互转换.

    涉及到的具体转换动作:
        String      ->      StringBuilder
            可以通过 StringBuilder类的构造方法实现.

        StringBuilder   ->  String
            可以通过 StringBuilder类的 toString()方法实现.

    涉及到的成员方法:
        StringBuilder类中的成员方法:
            public String toString();       //把StringBuilder -> String对象.

 */
public class Demo03 {
    public static void main(String[] args) {
        //1.定义空参不可变StringBuilder对象, 往里边添加完"hello"字符串后, 再将其转成String类型的对象.
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        //演示: StringBuilder   ->  String
        String s1 = sb.toString();
        System.out.println("s1: " + s1);
        System.out.println("-------------------------");

        //2.将String字符串转成StringBuilder对象, 然后打印.
        String ss = "abc";
        //演示:  String      ->      StringBuilder
        StringBuilder sb2 = new StringBuilder(ss);
        System.out.println("sb2: " + sb2);
    }
}

 

package com.it.demo06_arrays;

import java.util.Arrays;

/*
    案例: 演示冒泡排序.

    原理:
        相邻元素两两比较, 大的往后走, 这样第一轮比较完毕后, 最大值就在最大索引处, 依次类推.

    细节:
        1. 比较的轮数.       数组的长度 - 1
        2. 每轮比较的次数.   数组的长度 - 1 - i
        3. 谁和谁比较.       arr[j] 和 arr[j + 1]

    需求:
        1.已知数组int[] arr = {25, 69, 80, 57, 13}, 请编写代码对齐进行升序排序.
        2.即: 排序后结果为: arr = {13, 25, 57, 69, 80};
 */
public class Demo01 {
    public static void main(String[] args) {
        //1. 定义数组, 记录要排序的结果.
        int[] arr = {25, 69, 80, 57, 13};

        int count = 0;      //记录比较次数的.

        //2. 通过冒泡排序, 对数组元素进行升序排列.
        //外循环的 - 1是: 为了提高效率
        for (int i = 0; i < arr.length - 1; i++) {             //外循环: 控制比较的轮数.
            //内循环的 - 1 是: 为了防止出现索引越界异常.
            //内循环的 - i 是: 为了提高效率.
            for (int j = 0; j < arr.length - 1 - i; j++) {    //内循环: 控制每轮比较的次数.

                //比较一次, 计数器就 + 1
                count++;

                //细节:   arr[j] 和 arr[j + 1] 比较
                if (arr[j] > arr[j + 1]) {
                    //如果前一个元素比后一个元素大, 就交换
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        System.out.println("总比较次数: " + count);

        //3. 打印排序后的结果.
        System.out.println(Arrays.toString(arr));

        /*for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }*/
    }
}

package com.it.demo06_arrays;

import java.util.Arrays;

/*
    案例: 演示Arrays工具类的使用.

    需求:
        1.已知数组int[] arr = {25, 69, 80, 57, 13}.
        2.通过Arrays#sort()方法, 对其升序排列.
        3.打印排序后的结果.

    工具类解释:
        1. 成员都是静态的, 意味着可以通过 类名. 的形式调用.
        2. 构造方法私有化. 目的是: 不让外界来创建该类的对象.

     Arrays工具类解释:
        概述:
            它是用来操作数组的工具类, 提供了把数组转成字符串, 或者对数组元素排序等常见操作.
            它在java.util包下, 所以用之前需要导包.
        成员方法:
            public static String toString(int[] arr);   把数组对象转成其对应的字符串形式.
            public static void sort(int[] arr);         对数组元素排序, 默认是升序.
 */
public class Demo02 {
    public static void main(String[] args) {
        //1. 定义数组, 记录要排序的数据.
        int[] arr = {25, 69, 80, 57, 13};

        //2. 调用Arrays#sort() 对数组元素进行升序排列.
        Arrays.sort(arr);

        //3. 打印排序后的结果.
        System.out.println(Arrays.toString(arr));

    }
}

 

package cn.it.demo4;

import java.util.Arrays;

/*
 *  数组的工具类,包含数组的操作
 *  java.util.Arrays
 */
public class ArraysDemo {
    public static void main(String[] args) {
        function_2();
        int[] arr = {56,65,11,98,57,43,16,18,100,200};
        int[] newArray = test(arr);
        System.out.println(Arrays.toString(newArray));
    }
    /*
     *  定义方法,接收输入,存储的是10个人考试成绩
     *  将最后三个人的成绩,存储到新的数组中,返回新的数组
     */
    public static int[] test(int[] arr){
        //对数组排序
        Arrays.sort(arr);
        //将最后三个成绩存储到新的数组中
        int[] result = new int[3];
        //成绩数组的最后三个元素,复制到新数组中
    //    System.arraycopy(arr, 0, result, 0, 3);
        for(int i = 0 ;  i < 3 ;i++){
            result[i] = arr[i];
        }
        return result;
    }
    
    /*
     *  static String toString(数组)
     *  将数组变成字符串
     */
    public static void function_2(){
        int[] arr = {5,1,4,6,8,9,0};
        String s = Arrays.toString(arr);
        System.out.println(s);
    }
    
    /*
     *  static int binarySearch(数组, 被查找的元素)
     *  数组的二分搜索法
     *  返回元素在数组中出现的索引
     *  元素不存在, 返回的是  (-插入点-1)
     */
    public static void function_1(){
        int[] arr = {1,4,7,9,11,15,18};
        int index =  Arrays.binarySearch(arr, 10);
        System.out.println(index);
    }
    
    /*
     *  static void sort(数组)
     *  对数组升序排列
     */
    public static void function(){
        int[] arr = {5,1,4,6,8,9,0};
        Arrays.sort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

package com.it.demo07_integer;

/*
    案例: 包装类入门.

    包装类简介:
        概述:
            所谓的包装类指的就是 基本类型 对应的 引用类型, 这样做的好处是, 基本类型转成其对应的引用类型之后, 也可以调用成员变量和方法了.
        分类:
            基本类型        对应的     包装类型
            byte                        Byte
            short                       Short
            char                       Character                记忆
            int                        Integer                  必须记忆
            long                        Long
            float                       Float
            double                      Double
            boolean                     Boolean
       演示包装类入门的代码, 即: 打印int数据类型的描述范围.
       我们可以通过 Integer类的 成员变量实现.
            public static final int MAX_VALUE;
            public static final int MIN_VALUE;
 */
public class Demo01 {
    public static void main(String[] args) {
        //打印int类型的上限.
        System.out.println(Integer.MAX_VALUE);      //2147483647

//打印int类型的下限
        System.out.println(Integer.MIN_VALUE);      //-2147483648
    }
}

package com.it.demo07_integer;

/*
    案例: 演示包装类最常见的用法之 创建Integer对象. .

    包装类用法详解:
        包装类最常见的用法就是用于该类型对应的基本类型和字符串之间进行相互转换.
        例如:
            1. Byte 用于byte和String之间的相互转换.
            2. Integer 用于int和String之间的相互转换.
            3. Double 用于double和String之间的相互转换.
        细节:
            1. 其实学习包装类就是学习 该包装类对应的 基本类型的值, 如何和字符串之间进行相互转换.
            2. 基本类型对应的包装类型一共有8个, 除了 Character(字符) 和 String之间转换有额外规则外,
               其他7种数据类型都一样, 都有: parXxx()方法, 用来实现转换.
            3. 例如:
                int num = Integer.parseInt("10");
                double d = Double.parseDouble("10.3");

    此处, 我就用Integer来给大家演示了, 因为它们的操作都很相似, 都很简单.
    需求1: 创建integer类的对象.
        构造方法:
            public Integer(int num);            把int类型的数据, 封装成引用类型的数据.
            public Integer(String num);         根据传入的字符串内容, 将其转成对应的Integer对象


 */
public class Demo02 {
    public static void main(String[] args) {
        // 1.通过上述的两个构造方法, 分别创建Integer类型的对象.
        Integer i1 = new Integer(10);
        Integer i2 = new Integer("123");        //这里必须是纯数字形式的字符串.

        // 2.在main方法中, 打印创建好的Integer对象.
        System.out.println("i1: " + i1);        //10
        System.out.println("i2: " + i2);        //123
    }
}

 

package com.it.demo07_integer;

/*
    案例: 演示int和String之间的相互转换.

    需求:
         需求1: int        ->      String
            方式一: 和""拼接              推荐
            方式二: String#valueOf()

        需求2: String     ->      int
            方式一:    不推荐
                String -> Integer -> int
            方式二:    推荐
                String -> int
            Integer.parseInt("10");

 */
public class Demo03 {
    public static void main(String[] args) {
        //演示: int        ->      String
        int a = 10;
        String s1 = a + "";
        String s2 = String.valueOf(a);

        System.out.println("s1: " + s1);
        System.out.println("s2: " + s2);
        System.out.println("-----------------------");

        //演示:  String -> int
        String s3 = "123";

        //方式一: 思路  String -> Integer -> int
        Integer i1 = new Integer(s3);
        //把Integer对象 -> int类型的数据
        int num1 = i1.intValue();
        System.out.println(num1 + 0);
        System.out.println("-----------------------");

        //方式二: 思路, 通过Integer.parseInt(方法实现)
        int num2 = Integer.parseInt(s3);
        System.out.println(num2 + 0);

    }
}

package com.it.demo07_integer;

/*
    案例: 演示JDK1.5的特性 自动拆装箱.

    拆装箱解释:
        装箱:  指的是把 基本类型的数据 封装成 其对应的 引用类型.
        拆箱:  指的是把 引用类型的数据 拆解成 其对应的 基本类型.
 */
public class Demo04 {
    public static void main(String[] args) {
        //需求1: 演示JDK1.5以前的拆装箱操作.    了解.
        //装箱,  int -> Integer
        int a = 10;
        Integer i1 = new Integer(a);            //装箱.

        //拆箱:  Integer -> int
        int b = i1.intValue();                  //拆箱.


        //需求2: 演示JDK1.5及其以后的拆装箱动作.  掌握
        /*int aa = 10;
        Integer i2 = aa;  */

        Integer i2 = 10;             //自动装箱.
        int aa = i2;                 //自动拆箱
        System.out.println("------------------------------");

        //小案例
        Integer i3 = 20;        //自动装箱
        /*
             i3 += 10;    这行代码拆装箱做了几次?
                答: 拆装箱各做了一次, 因为 i3 += 10, 等价于 i3 = i3 + 10
                    第一步: 先拆箱, i3 从Integer 20 变成 int 20
                    第二步: 计算 i3 + 10 的结果 等于 30
                    第三步: 再装箱, 把int 30 封装成 Integer 30, 赋值给变量Integer i3
         */
        i3 += 10;
        System.out.println(i3);     //30
    }
}

 

package cn.it.demo1;
/*
 * Integer类,封装基本数据类型int,提高大量方法
 * 将字符串转成基本数据类型int
 * 
 * 
 * Integer i = Integer.valueOf("1");
 * i.intValue()
 */
public class IntegerDemo {
    public static void main(String[] args) {
        function_3();
    }
    /*
     *  Integer类构造方法
     *   Integer (String s)
     *   将数字格式的字符串,传递到Integer类的构造方法中
     *   创建Integer对象,包装的是一个字符串
     *   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的, intValue()
     */
    public static void function_3(){
        Integer in = new Integer("100");
        int i = in.intValue();
        System.out.println(--i);
    }
    
    /*
     *  如何将基本类型int,变成字符串
     *  
     *  int => String  任何类型+"" 变成String类型
     *  Integer类中的静态方法toString()
     *  
     *  toString(int ,int 进制), 将int整数,转成指定进制数
     *  0-9A-Z
     */
    public static void function_2(){
        int i = 3;
        String s = i+"";
        System.out.println(s+1);
        
        String s1 = Integer.toString(5,2);
        System.out.println(s1);
    }
    
    
    /*
     * Integer类静态方法parseInt(String s, int radix)
     * radix基数,进制
     * "110",2 含义 前面的数字是二进制的,但是方法parseInt运行结果都是十进制
     */
    public static void function_1(){
        int i = Integer.parseInt("110", 2);
        System.out.println(i);
    }
    
    /*
     * Integer类中静态方法 parseInt(String s) 返回基本数据类型
     * 要求: 字符串必须是数字格式的
     */
    public static void function(){
        int i = Integer.parseInt("12");
        System.out.println(i/2);
    }
}

package cn.it.demo1;
/*
 *  Integer类中的其他方法
 *  包括三个方法,和2个静态成员变量
 */
public class IntegerDemo1 {
    public static void main(String[] args) {
        function_1();
    }
    /*
     * Integer类的3个静态方法
     * 做进制的转换
     * 十进制转成二进制  toBinarString(int)
     * 十进制转成八进制  toOctalString(int)
     * 十进制转成十六进制  toHexString(int)
     * 三个方法,返回值都是以String形式出现
     */
    public static void function_1(){
        System.out.println(Integer.toBinaryString(99));
        System.out.println(Integer.toOctalString(99));
        System.out.println(Integer.toHexString(999));
    }
    
    /*
     *   Integer类的静态成员变量
     *   MAX_VALUE
     *   MIN_VALUE
     */
    public static void function(){
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    }
}

package cn.it.demo1;
/*
 *   JDK1.5后出现的特性,自动装箱和自动拆箱
 *   自动装箱: 基本数据类型,直接变成对象
 *   自动拆箱: 对象中的数据变回基本数据类型
 */
public class IntegerDemo2 {
    public static void main(String[] args) {
        function_2();
    }
    /*
     *  关于自动装箱和拆箱一些题目
     */
    public static void function_2(){
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i==j);// false 对象地址
        System.out.println(i.equals(j));// true  继承Object重写equals,比较的对象数据
        
        System.out.println("===================");
        
        Integer a = 500;
        Integer b = 500;
        System.out.println(a==b);//false
        System.out.println(a.equals(b));//true
        
        System.out.println("===================");
        
        
        //数据在byte范围内,JVM不会从新new对象
        Integer aa = 127; // Integer aa = new Integer(127)
        Integer bb = 127; // Integer bb = aa;
        System.out.println(aa==bb); //true
        System.out.println(aa.equals(bb));//true
    }
    
    
    //自动装箱和拆箱弊端,可能出现空指针异常
    public static void function_1(){
        Integer in =null;    
        //in = null.intValue()+1
        in = in + 1;
        System.out.println(in);
    }
    
    //自动装箱,拆箱的 好处: 基本类型和引用类直接运算
    public static void function(){
        //引用类型 , 引用变量一定指向对象
        //自动装箱, 基本数据类型1, 直接变成了对象
        
        Integer in = 1; // Integer in = new Integer(1)
        //in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型
        
        //in+1  ==> in.inValue()+1 = 2    
        // in = 2    自动装箱
        in = in + 1;
        
        System.out.println(in);
        
    }
}
/*
    ArrayList<Integer> ar = new ArrayList<Integer>();
    ar. add(1);
 */

 

package cn.it.demo3;
/*
 *  数学计算的工具类
 *  java.lang.Math 静态方法组成
 */
public class MathDemo {
    public static void main(String[] args) {
        function_6();
    }
    /*
     *  static double round(doubl d)
     *  获取参数的四舍五入,取整数
     */
    public static void function_6(){
        double d = Math.round(5.4195);
        System.out.println(d);
    }
    
    /*
     *  static double random() 返回随机数 0.0-1.0之间
     *  来源,也是Random类
     */
    public static void function_5(){
        for(int i = 0 ; i < 10 ;i++){
            double d = Math.random();
            System.out.println(d);
        }
    }
    
    /*
     * static double sqrt(double d)
     * 返回参数的平方根
     */
    public static void function_4(){
        double d = Math.sqrt(-2);
        System.out.println(d);
    }
    
    /*0
     * static double pow(double a, double b)
     * a的b次方
     */
    public static void function_3(){
        double d = Math.pow(2, 3);
        System.out.println(d);
    }
    
    /*
     * static double floor(double d)
     * 返回小于或者等于参数d的最大整数
     */
    public static void function_2(){
        double d = Math.floor(1.5);
        System.out.println(d);
    }
    
    /*
     *  static double ceil(double d)
     *  返回大于或者等于参数d的最小整数
     */
    public static void function_1(){
        double d = Math.ceil(5.1);
        System.out.println(d);
    }
    
    /*
     *  static int abs(int i)
     *  获取参数的绝对值
     */
     public static void function(){
        int i = Math.abs(0);
        System.out.println(i);
     }
     
}

package cn.it.demo5;

import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        function_1();
    }
    /*
     * BigDecimal实现除法运算
     * divide(BigDecimal divisor, int scale, int roundingMode) 
     * int scale : 保留几位小数
     * int roundingMode : 保留模式
     * 保留模式 阅读API文档
     *   static int ROUND_UP  向上+1
     *   static int ROUND_DOWN 直接舍去
     *   static int ROUND_HALF_UP  >= 0.5 向上+1
     *   static int ROUND_HALF_DOWN   > 0.5 向上+1 ,否则直接舍去
     */
    public static void function_1(){
        BigDecimal b1 = new BigDecimal("1.0301");
        BigDecimal b2 = new BigDecimal("100");
        //计算b1/b2的商,调用方法divied
        BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//0.01301
        System.out.println(bigDiv);
    }
    
    /*
     *  BigDecimal实现三则运算
     *  + - *
     */
    public static void function(){
        BigDecimal b1 =  new BigDecimal("0.09");
        BigDecimal b2 =  new BigDecimal("0.01");
        //计算b1+b2的和,调用方法add
        BigDecimal bigAdd = b1.add(b2);
        System.out.println(bigAdd);
        
        BigDecimal b3 = new BigDecimal("1");
        BigDecimal b4 = new BigDecimal("0.32");
        //计算b3-b2的差,调用方法subtract
        BigDecimal bigSub = b3.subtract(b4);
        System.out.println(bigSub);
        
        BigDecimal b5 = new BigDecimal("1.015");
        BigDecimal b6 = new BigDecimal("100");
        //计算b5*b6的成绩,调用方法 multiply
        BigDecimal bigMul = b5.multiply(b6);
        System.out.println(bigMul);
    }
}


/*
 * 计算结果,未知
 * 原因: 计算机二进制中,表示浮点数不精确造成
 * 超级大型的浮点数据,提供高精度的浮点运算, BigDecimal
System.out.println(0.09 + 0.01);//0.09999999999999999
System.out.println(1.0 - 0.32);//0.6799999999999999
System.out.println(1.015 * 100);//101.49999999999999
System.out.println(1.301 / 100);//0.013009999999999999 
*/

package cn.it.demo5;

import java.math.BigInteger;

/*
 *  超级大的整数运算
 *    超过long取值范围整数,封装成BigInteger类型的对象
 */
public class BigIntegerDemo {
    public static void main(String[] args) {
        function_1();
    }
    /*
     * BigInteger对象的四则运算
     * 调用方法计算,计算结果也只能是BigInteger对象
     */
     public static void function_1(){
         BigInteger b1 = new BigInteger("5665464516451051581613661405146");
         BigInteger b2 = new BigInteger("965855861461465516451051581613661405146");
         
         //计算 b1+b2对象的和,调用方法 add
         BigInteger bigAdd = b1.add(b2);//965855867126930032902103163227322810292
         System.out.println(bigAdd);
         
         //计算b1-b2对象的差,调用方法subtract
         BigInteger bigSub = b1.subtract(b2);
         System.out.println(bigSub);
         
         //计算b1*b2对象的乘积,调用方法multiply
         BigInteger bigMul = b1.multiply(b2);
         System.out.println(bigMul);
         
         //计算b2/b1对象商,调用方法divied
         BigInteger bigDiv = b2.divide(b1);
         System.out.println(bigDiv);
     }
    
    /*
     * BigInteger类的构造方法
     * 传递字符串,要求数字格式,没有长度限制
     */
    public static void function(){
        BigInteger b = new BigInteger("8465846668464684562385634168451684568645684564564");
        System.out.println(b);
        BigInteger b1 = new BigInteger("5861694569514568465846668464684562385634168451684568645684564564");
        System.out.println(b1);
    }
}

package cn.it.demo2;

public class Person {
    public void finalize(){
        System.out.println("垃圾收取了");
    }
}


package cn.it.demo2;

public class SystemDemo {
    public static void main(String[] args) {
        function_4();
    }
    /*
     * System类方法,复制数组
     * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
     * Object src, 要复制的源数组
     * int srcPos, 数组源的起始索引
     * Object dest,复制后的目标数组
     * int destPos,目标数组起始索引 
     * int length, 复制几个
     */
    public static void function_4(){
        int[] src = {11,22,33,44,55,66};
        int[] desc = {77,88,99,0};
        
        System.arraycopy(src, 1, desc, 1, 2);
        for(int i = 0 ;  i < desc.length ; i++){
            System.out.println(desc[i]);
        }
    }
    
    /*
     *  获取当前操作系统的属性
     *  static Properties getProperties() 
     */
    public static void function_3(){
        System.out.println( System.getProperties() );
    }
    
    /*
     *  JVM在内存中,收取对象的垃圾
     *  static void gc()
     */
    public static void function_2(){
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        new Person();
        System.gc();
    }
    
    /*
     *  退出虚拟机,所有程序全停止
     *  static void exit(0)
     */
    public static void function_1(){
        while(true){
            System.out.println("hello");
            System.exit(0);
        }
    }
    /*
     *  获取系统当前毫秒值
     *  static long currentTimeMillis()
     *  对程序执行时间测试
     */
    public static void function(){
        long start = System.currentTimeMillis();
        for(int i = 0 ; i < 10000; i++){
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println(end - start);
    }
}

package com.it.demo01_date;

import java.util.Date;

/*
    案例: 演示Date类入门.

    Date简介:
        概述:
            它是java.util包下的类, 用之前需要先导包, Date表示特定的瞬间, 可以精确到毫秒.
        作用:
            1. 可以用来计算某段代码的执行时间.
            2. 可以当做日志文件的字段来使用.
        构造方法:
            public Date();              采用当前系统时间作为默认值, 获取Date对象.
            public Date(long time);     采用指定的 毫秒值(时间种子)来获取对应的Date对象, 只要毫秒值一样, 获取的Date对象也一样.
        成员方法:

        细节:
            1. 计算机采用的时间 都是相对于 时间原点来讲的, 时间原点指的是: 1970年1月1日 00:00:00
            2. 因为我们处于中国, 采用的是北京时间(东八区时间), 所以我们现在的代码, 参考的时间原点是: 1970年1月1日 08:00:00

    需求:
        1.通过上述的两种方式创建Date对象.
        2.在main方法中, 打印上述创建好的Date对象, 并观察结果.
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求1: 测试 public Date();
        Date d1 = new Date();
        System.out.println(d1);         //Thu Jul 30 09:29:15 CST 2020

        //需求2: 测试  public Date(long time);
        Date d2 = new Date(0L);
        System.out.println(d2);
    }
}

package com.it.demo01_date;

import java.util.Date;

/*
    案例: 演示Date类入门.

    Date简介:
        概述:
            它是java.util包下的类, 用之前需要先导包, Date表示特定的瞬间, 可以精确到毫秒.
        作用:
            1. 可以用来计算某段代码的执行时间.
            2. 可以当做日志文件的字段来使用.
        构造方法:
            public Date();              采用当前系统时间作为默认值, 获取Date对象.
            public Date(long time);     采用指定的 毫秒值(时间种子)来获取对应的Date对象, 只要毫秒值一样, 获取的Date对象也一样.
        成员方法:
            public long getTime();              根据Date对象, 获取其对应的毫秒值.
            public void setTime(long time);     设置当前Date对象的毫秒值为指定的值.
        细节:
            1. 计算机采用的时间 都是相对于 时间原点来讲的, 时间原点指的是: 1970年1月1日 00:00:00
            2. 因为我们处于中国, 采用的是北京时间(东八区时间), 所以我们现在的代码, 参考的时间原点是: 1970年1月1日 08:00:00

    需求:
        1.通过上述的两种方式创建Date对象.
        2.在main方法中, 打印上述创建好的Date对象, 并观察结果.
 */
public class Demo02 {
    public static void main(String[] args) {
        //需求1: 获取当前时间的毫秒值.
        Date d1 = new Date();
        System.out.println(d1.getTime());       //毫秒值: 1596072985308
        System.out.println(d1);                 //Date对象: Thu Jul 30 09:36:25 CST 2020
        System.out.println("-----------------------------");

        //需求2: 设置Date对象的毫秒值为指定的值.
        //测试: 只要时间种子(毫秒值)一样, 获取的Date对象时间也是固定的.
        //方式一: 采用构造方法实现.
        Date d2 = new Date(1596072985308L);
        System.out.println("d2: " + d2);

        //方式二: 采用set()方法赋值
        Date d3 = new Date();
        d3.setTime(1596072985308L);
        System.out.println("d3: " + d3);
    }
}

package com.it.demo01_date;

import java.util.Date;

//需求: 计算打印10000次HelloWorld, 需要用到多少时间.
public class Demo03 {
    public static void main(String[] args) {
        //1. 获取当前时间的毫秒值, 充当 开始时间.
        //方式一: 标准写法
       /* Date d1 = new Date();
        long start = d1.getTime();*/

        //方式二: 采用匿名对象实现.     new Date(); 就是Date类的匿名对象.
        long start = new Date().getTime();
        //2. 这里写的是要测试执行之间的代码.
        for (int i = 0; i < 10000; i++) {
            System.out.println("Hello World!");
        }
        //3. 获取当前时间的毫秒值, 充当 结束时间.
        long end = new Date().getTime();

        //4.计算时间, 并打印.
        System.out.println("代码总执行时间为: "+ (end - start) +" 毫秒");
    }
}

 

package cn.it.demo02;

import java.util.Date;

/*
 *  时间和日期类
 *    java.util.Date
 *    
 *  毫秒概念: 1000毫秒=1秒
 *  
 *  毫秒的0点: 
 *     System.currentTimeMillis() 返回值long类型参数
 *     获取当前日期的毫秒值   3742769374405
 *     时间原点; 公元1970年1月1日,午夜0:00:00 英国格林威治  毫秒值就是0
 *     时间2088年8月8日
 *  
 *  重要: 时间和日期的计算,必须依赖毫秒值
 *    XXX-XXX-XX = 毫秒
 *    
 *         long time = System.currentTimeMillis();
        System.out.println(time);
 */
public class DateDemo {
    public static void main(String[] args) {
        function_3();
    }
    /*
     * Date类方法 setTime(long )传递毫秒值
     * 将日期对象,设置到指定毫秒值上
     * 毫秒值转成日期对象
     * Date的构造方法
     */
    public static void function_3(){
        Date date = new Date();
        System.out.println(date);
        
        date.setTime(0);
        System.out.println(date);
    }
    
    /*
     *   Date类方法 getTime() 返回值long
     *   返回的是毫秒值
     *   将Date表示的日期,转成毫秒值
     *   日期和毫秒值转换
     */
    public static void function_2(){
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
    }
    
    /*
     * Date类的long参数的构造方法
     * Date(long ) 表示毫秒值
     * 传递毫秒值,将毫秒值转成对应的日期对象
     */
    public static void function_1(){
        Date date = new Date(0);
        System.out.println(date);
    }
    
    /*
     * Date类空参数构造方法
     * 获取到的是,当前操作系统中的时间和日期
     */
    public static void function(){
        Date date = new Date();
        System.out.println(date);
    }
}

package com.it.demo02_simpledateformat;

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

/*
    案例: 演示SimpleDateFormat值 格式化的动作.

    需求:
        把当前时间对象, 按照2020年3月4日 00:00:00格式进行打印.

    SimpleDateFormat简介:
        概述:
            它是java.text包下的类, 用之前需要到导包, 它表示日期格式化类, 主要是来对日期进行 格式化和解析操作的.
            格式化:  Date对象    ->      String字符串形式的日期.
            解析:    String字符串形式的日期  -> Date对象
         构造方法:
            public SimpleDateFormat();                  采用默认模板, 创建SimpleDateFormat对象.
            public SimpleDateFormat(String pattern);    采用指定模板, 创建SimpleDateFormat对象.
                //yyyy: 年, MM: 月, dd: 日  HH: 小时, mm: 分钟, ss: 秒 E: 星期
         成员方法:
            public final String format(Date d);         格式化动作, 即: 把Date对象按照模板转成对应的 字符串形式.
            public Date parse(String str);              解析动作, 即: 把字符串形式的日期解析成Date对象.
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求:  把当前时间对象, 按照2020年3月4日 00:00:00格式进行打印.
        //1. 获取当前的日期对象.
        Date d = new Date();
        //2. 创建SimpleDateFormat对象(日期格式化对象), 用来对日期进行格式化操作,
        //SimpleDateFormat sdf = new SimpleDateFormat();      //默认模板格式为: 20-7-30 上午10:24
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss E");
        //3. 具体的格式化动作.
        String str = sdf.format(d);
        //4. 打印接结果.
        System.out.println(d);      //Thu Jul 30 10:22:49 CST 2020
        System.out.println(str);    //2020年07月30日 10:26:33 星期四
    }
}

 

package com.it.demo02_simpledateformat;

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

/*
    案例: 演示SimpleDateFormat类的 解析功能.

    需求:
        1.已知字符串String s = "2020年3月4日 00:00:00";
        2.将上述的字符串转成其对应的Date对象后, 直接打印到控制台上.

    SimpleDateFormat简介:
        概述:
            它是java.text包下的类, 用之前需要到导包, 它表示日期格式化类, 主要是来对日期进行 格式化和解析操作的.
            格式化:  Date对象    ->      String字符串形式的日期.
            解析:    String字符串形式的日期  -> Date对象
         构造方法:
            public SimpleDateFormat();                  采用默认模板, 创建SimpleDateFormat对象.
            public SimpleDateFormat(String pattern);    采用指定模板, 创建SimpleDateFormat对象.
                //yyyy: 年, MM: 月, dd: 日  HH: 小时, mm: 分钟, ss: 秒 E: 星期
         成员方法:
            public final String format(Date d);         格式化动作, 即: 把Date对象按照模板转成对应的 字符串形式.
            public Date parse(String str);              解析动作, 即: 把字符串形式的日期解析成Date对象.
 */
public class Demo02 {
    public static void main(String[] args) throws ParseException {
        //1.定义字符串String s = "2020年3月4日 00:00:00";
        String s = "2020年3月4日 00:00:00";
        //2. 创建SimpleDateFormat对象, 用来进行解析动作.  细节: 1. 必须指定模板.  2. 模板必须和要解析的字符串格式保持一致.
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");      //正确的.
        //SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");          //错误的, 模板没有和要解析的字符串格式保持一致
        //SimpleDateFormat sdf = new SimpleDateFormat();                               //错误的, 模板没有和要解析的字符串格式保持一致

        //3. 具体的解析动作, 因为传入的字符串有可能不是: 日期形式的字符串, 所以这里有一个 ParseException(转换异常), 需要我们手动处理.
        //关于异常处理的知识点在后续讲解 IO流的时候, 会详细说, 这里, 你不需要管什么意思, 先跟着我做就好了.
        Date date = sdf.parse(s);

        //4. 打印结果.
        System.out.println(date);
    }
}

package com.it.utils;

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

//自定义的工具类, 用来格式化和解析日期.
public class DateUtils {
    //1. 构造方法私有化.
    private DateUtils() {
    }

    //2. 成员方法都是静态的.
    /**
     * 用来对Date对象进行 格式化操作的
     * @param d 要操作的日期对象.
     * @param pattern 格式化时候采用的模板
     * @return 格式化之后获取到的 字符串.
     */
    public static String date2String(Date d, String pattern) {
        //1. 创建SimpleDateFormat对象, 用于 格式化日期.
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        //2. 具体的格式化动作, 并返回结果.
        return sdf.format(d);
    }


    /**
     * 用于对Date对象进行 解析操作的.
     * @param str   要被解析的 字符串形式的日期
     * @param pattern   解析时采用的模板
     * @return 返回解析后的Date对象
     * @throws ParseException 如果传入的要被解析的字符串不合法, 则抛出此异常
     */
    public static Date string2Date(String str, String pattern) throws ParseException {
        //1. 创建SimpleDateFormat对象, 用于 解析日期.
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        //2. 具体的解析动作, 并返回结果.
        return sdf.parse(str);
    }

}


package com.it.demo02_simpledateformat;

import com.it.utils.DateUtils;

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

/*
    案例: 演示自定义的工具类.

    需求:
        1.定义工具类DateUtils, 该类有两个方法: date2String(), string2Date(), 分别用来格式化, 解析日期.
        2.在测试类中, 测试上述的两个方法.

 */
public class Demo03 {
    public static void main(String[] args) throws ParseException {
        //需求: 测试DateUtils工具类的使用.

        //格式化动作,  Date  -> String
        Date d = new Date();
        //String s = DateUtils.date2String(d, "yyyy年MM月dd日 HH:mm:ss");
        String s = DateUtils.date2String(d, "yyyy/MM/dd HH:mm:ss");
        System.out.println(s);
        System.out.println("-------------------------------");

        //解析动作      String -> Date
        //细节: 模板和要解析的字符串的格式必须相匹配.
        String str = "2020:07:30";
        Date date = DateUtils.string2Date(str, "yyyy:MM:dd");
        System.out.println(date);
    }
}

package com.it.demo03_calendar;

import java.util.Calendar;

/*
    案例: 演示Calendar入门.

    需求:
        通过上述的方式, 创建Calendar对象.

    Calendar详解:
        概述:
            它是java.util包下的类, 用之前需要先导包. 它表示日历类, 也是一个抽象类, 里边绝大多数的功能都是用来替代 Date 类的.
        成员方法:
            public static Calendar getInstance();           //获取一个Calendar类的(子类)对象
 */
public class Demo01 {
    public static void main(String[] args) {
        //需求: 通过上述的方式, 创建Calendar对象.
        //Calendar c1 = new Calendar();           //报错, 因为Calendar是抽象类, 不能直接new.

        //多态
        //父类引用     子类对象
        Calendar c = Calendar.getInstance();      //获取日历字段 对象.
    }
}

package com.it.demo03_calendar;

import java.util.Calendar;

/*
    案例: 演示Calendar类中的成员变量和成员方法

    涉及到的Calendar类中的成员:
        成员变量:
            public static final int YEAR                表示年份
            public static final int MONTH               表示月份, 范围是: 0 - 11
            public static final int DATE                表示月中的某一天
            public static final int DAY_OF_YEAR         表示年中的某一天
            public static final int DAY_OF_WEEK         表示星期中的某一天
        成员方法:
             public static Calendar getInstance();           获取一个Calendar类的(子类)对象
             public int get(日历字段);                       根据日历字段, 获取其对应的值.
             public void set(int year, int month, int day)   设置时间为指定的: 年, 月, 日
             public void add(int field, int amount);         把指定的日历字段, 往前/往后推指定时间, 例如: 往前推3天, 往后推2年.
                                                             amount表示偏移量, 负数往前,  正数往后.
 */
public class Demo02 {
    public static void main(String[] args) {
        //1. 获取Calendar类型的对象
        Calendar c = Calendar.getInstance();

        //2. 测试 打印日历字段
        //获取年份
        int year1 = c.get(Calendar.YEAR);           //推荐使用.
        int year2 = c.get(1);                       //这里的1其实就是: Calendar.YEAR, 表示年份
        System.out.println(year1);
        System.out.println(year2);

        //获取月份
        int month = c.get(Calendar.MONTH);
        System.out.println(month);          //6

        //获取月中的某一天
        System.out.println(c.get(Calendar.DATE));           //30

        //获取年中的某一天
        System.out.println(c.get(Calendar.DAY_OF_YEAR));    //1,3,5 多一天, 2月: 29, 少一天,   1-7 7个月, 30天

        //获取星期中的某一天.
        System.out.println(c.get(Calendar.DAY_OF_WEEK));    //周六是每周的第一天, 所以这里的值是: 5
    }
}

package cn.it.demo03;

import java.util.Calendar;

/*
 *   日历类 java.util.Calendar
 *   抽象类,使用他的子类对象
 *   
 *   Calendar类写了静态方法 getInstance() 直接返回了子类的对象
 *   不需要直接new 子类的对象,通过静态方法直接获取
 */
public class CalendarDemo {
    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println(c);
    }
}

package cn.it.demo03;

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

public class CalendarDemo1 {
    public static void main(String[] args) {
        function_3();
    }
    /*
     * Calendar类的方法getTime()
     * 把日历对象,转成Date日期对象
     */
    public static void function_3(){
        Calendar c = Calendar.getInstance();
        Date date = c.getTime();
        System.out.println(date);
    }
    

    /*
     * Calendar类方法add 日历的偏移量,
     * 可以指定一个日历中的字段,
     * 进行整数的偏移 add(int field, int value)
     */
    public static void function_2() {
        Calendar c = Calendar.getInstance();
        // 让日历中的天数,向后偏移280天
        c.add(Calendar.DAY_OF_MONTH, -280);
        // 获取年份
        int year = c.get(Calendar.YEAR);
        // 获取月份
        int month = c.get(Calendar.MONTH) + 1;
        // 获取天数
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "年" + month + "月" + day + "日");
    }

    /*
     * Calendar类的set方法 设置日历 set(int field,int value) field 设置的是哪个日历字段 value
     * 设置后的具体数值
     * 
     * set(int year,int month,int day) 传递3个整数的年,月,日
     */
    public static void function_1() {
        Calendar c = Calendar.getInstance();
        // 设置,月份,设置到10月分
        // c.set(Calendar.MONTH, 9);

        // 设置年,月,日
        c.set(2099, 4, 1);

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

    /*
     * Calendar类的get方法 获取日历字段的值 int get(int) 参数int,获取的哪个日历字段 返回值,就表示日历字段的具体数值
     */
    public static void funtion() {
        Calendar c = Calendar.getInstance();
        // 获取年份
        int year = c.get(Calendar.YEAR);
        // 获取月份
        int month = c.get(Calendar.MONTH) + 1;
        // 获取天数
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "年" + month + "月" + day + "日");
    }
}

package cn.it.demo04;

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

public class DateTest {
    public static void main(String[] args) throws Exception {
        function_1();
    }
    /*
     *  闰年计算
     *  2000 3000
     *  高级的算法: 日历设置到指定年份的3月1日,add向前偏移1天,获取天数,29闰年
     */
    public static void function_1(){
        Calendar c = Calendar.getInstance();
        //将日历,设置到指定年的3月1日
        c.set(2088, 2, 1);
        //日历add方法,向前偏移1天
        c.add(Calendar.DAY_OF_MONTH, -1);
        //get方法获取天数
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(day);
    }
    
    /*
     *  计算活了多少天
     *   生日  今天的日期
     *   两个日期变成毫秒值,减法
     */
    public static void function() throws Exception {
        System.out.println("请输入出生日期 格式 YYYY-MM-dd");
        //获取出生日期,键盘输入
        String birthdayString = new Scanner(System.in).next();
        //将字符串日期,转成Date对象
        //创建SimpleDateFormat对象,写日期模式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        //调用方法parse,字符串转成日期对象
        Date birthdayDate = sdf.parse(birthdayString);
        
        //获取今天的日期对象
        Date todayDate = new Date();
        
        //将两个日期转成毫秒值,Date类的方法getTime
        long birthdaySecond = birthdayDate.getTime();
        long todaySecond = todayDate.getTime();
        long secone = todaySecond-birthdaySecond;
        
        if(secone < 0){
            System.out.println("还没出生呢");
        }
        else{
        System.out.println(secone/1000/60/60/24);
        }
        
    }
}

package com.it.demo04_exercise;

import java.util.Calendar;
import java.util.Scanner;

/*
    案例: 获取某年的2月有多少天.

    需求:
        1.提示用户录入年份.
        2.计算该年的2月有多少天, 并将结果打印到控制台上.

    规则:
        闰年的2月有29天, 平年的2月有28天.

    解题思路:
        方式一: 采用if逻辑判断实现, 即: 闰年的判断逻辑如下:
            1. 能被4整除但是不能被100整除.
            或者
            2. 能够被400整除.
        方式二: 采用Calendar类的方法实现.
            1. 把时间设置为该年的3月1日.
            2. 然后把时间往前推1天.
            3. 之后获取该天是月中的第几天即可, 这个值就是我们要的.
 */
public class Demo01 {
    public static void main(String[] args) {
        //1. 提示用户录入年份, 并接收.
        System.out.println("请录入一个年份: ");
        //new Scanner(System.in);  叫: 匿名对象.
        int year = new Scanner(System.in).nextInt();
        //2. 创建Calendar对象.
        Calendar c = Calendar.getInstance();
        //3. 把时间设置为该年的3月1日.
        c.set(year, 2, 1);      //2表示3月
        //4. 把时间往前推1天.
        c.add(Calendar.DATE, -1);
        //5. 获取该天是月中的第几天即可, 即: 该天为2月的最后一天.
        int day = c.get(Calendar.DAY_OF_MONTH);
        //6. 打印结果.
        System.out.println(year + "年2月有 " + day + " 天");
    }
}