// 自加自减练习

// ++、--   在前面是先加减后赋值，在后面是先赋值在加减

        int i1 = 10;

    int i2 = 20;

    int i = i2++;

    System.out.println("i:" + i);    //20，是先赋值在自加！

    System.out.println("i2:" + i2);    //

    i = ++i2;

    System.out.println("i:" + i);    //

    System.out.println("i2:" + i2);    //

    i = --i1;

    System.out.println("i:" + i);    //

    System.out.println("i1:" + i1);    //

    i = i1--;

    System.out.println("i:" + i);    //

    System.out.println("i1:" + i1);    //

    // 逻辑运算符练习

    boolean a, b, c;

    a = true; b=false;

    c = !a;        System.out.println(c);    //false

    c = a ^ b;     System.out.println(c);    //true

    c = a & b;     System.out.println(c);    //false

    c = a && b; System.out.println(c);    //false

    c = a | b;     System.out.println(c);    //true

    c = a || b; System.out.println(c);    //true

public class OneHundredAnd{

    public static void main(String[] args){

        int result=0;

        for(int i=1;i<=100;i++){

            result+=i;

        }

        System.out.println(result);

    }

}

public class TestArray {

   public static void main(String[] args) {

      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素

      for (double element: myList) {

         System.out.println(element);

      }

   }

}

public class OneHundredAnd{

    public static void main(String[] args){

        int a=1,result=0;

        while(a<=100){

            result+=a++;

        }

        System.out.println(result);

    }

}

public class OneHundredAnd{

    public static void main(String[] args){

        int a=1,result=0;

        do{

            result+=a++;

        }while(a<=100);

        System.out.println(result);

    }

}

public class PrimeNumbers{

    public static void main(String[] args){

        // 输出100~200内的质数

        // 只有1和它本身这两个因数的自然数叫做质数.还可以说成质数只有1和它本身两个约数.

        // 素数是这样的整数,它除了能表示为它自己和1的乘积以外,不能表示为任 何其它两个整数的乘积.

        // 例如: 12 ＝6×2＝4×3,所以12不是素数.

        for (int i=101; i<200; i+=2){

            for (int n=2; n<i; n++){

                if (i % n != 0){

                    System.out.println(i);

                    break;

                }

            }

        }

    }

}

public class DataConversion {

    public static void main(String[] args){

        switch (18) {

        case 18:

            System.out.print("I'm eighteen years old, fighting.");

            break;

        case 19:

        case 20:

        case 21:

        case 22:

            System.out.print("I'm twenty years old, fighting.");

            break;

        default:

            System.out.print("Grow up to go away ^.^.");

            break;

        }

    }

}

public class SimpleUnary{

 public static void main(String[] args) {

 　　char a = 'a';

 　　int b = 8;

　　 System.out.println(false?a:b); //打印b，b是8，所以打印出8

 　　System.out.println(false?a:8); //打印8，但a是char型的，所以打印8的char字 //符，也就是backspace

 　　System.out.println(false?8:a); //打印int型，也就是a

 　　System.out.println(false?b:'a'); //打印a的ASCII码

 }

}

public class Numbers {

    public static String getType(Object o){

        return o.getClass().toString();

    }

    public static void main(String[] args){

//        // xxxValue() 将number对象转换为xxx数据类型的值并返回。

//        Integer i1=1;

//        float f1 = i1.floatValue();

//        System.out.println(f1 + " " + getType(f1));    //1.0 class java.lang.Float

//        int f2 = i1.intValue();

//        System.out.println(f2 + " " + getType(f2));    //1 class java.lang.Integer

//        byte f3 = i1.byteValue();

//        System.out.println(f3 + " " + getType(f3));    //1 class java.lang.Byte

////        i1.compareTo(1);

//        // 比较这个Number对象的参数. 一样返回0，否则-1.

//        Integer i1=1;

//        int i2 = i1.compareTo(1);

//        System.out.println(i2);

//        // 确定这个数字对象是否等于参数.一样返回true，否则false.

//        Integer i1=1;

//        byte i2=1;

//        boolean i3 = i1.equals(i2);

//        System.out.println(i3);    //false

//        //返回一个 Number 对象指定的内置数据类型

//        //nteger.valueOf()方法基于减少对象创建次数和节省内存的考虑，

//        //缓存了[-128,127]之间的数字。此数字范围内传参则直接返回缓存中的对象。

//        Integer i1=1;

//        Integer i2 = Integer.valueOf(i1);

//        System.out.println(i2);    //1

//        //以字符串形式返回值。

//        Integer i1=1;

//        String i2 = i1.toString();

//        System.out.println(i2);    //1

//        //将字符串解析为int类型。

//        String i1="9";

//        Integer i2 = Integer.parseInt(i1);

//        System.out.println(i2);    //9

//        //返回参数的绝对值。

//        Integer i1=-1;

//        Integer i2 = Math.abs(i1);

//        System.out.println(i2);    //1

//        //对整形变量向左取整，返回类型为double型。

//        int i1=1;

//        double i2 = Math.ceil(i1);

//        System.out.println(i2);    //1.0

//        //对整型变量向右取整。返回类型为double类型。

//        int i1=1;

//        double i2 = Math.floor(i1);

//        System.out.println(i2);    //1.0

//        //返回与参数最接近的整数。返回类型为double。

//        double i1=1.623;

//        double i2 = Math.rint(i1);

//        System.out.println(i2);    //2.0

//        //返回一个最接近的int、long型值。

//        double i1=1.623;

//        long i2 = Math.round(i1);

//        System.out.println(i2);    //2

//        //返回两个参数中的最小值。

//        double i1=1.6;

//        double i2=1.8;

//        double i3 = Math.min(i1, i2);

//        System.out.println(i3);    //1.6

//        //返回两个参数中的最大值。

//        int i1=9;

//        int i2=5;

//        int i3 = Math.max(i1, i2);

//        System.out.println(i3);    //9

//        //返回两个参数中的最大值。

//        int i1=9;

//        int i2=5;

//        int i3 = Math.max(i1, i2);

//        System.out.println(i3);    //9

//        //返回自然数底数e的参数次方。

//        double i1=9;

//        double i2 = Math.exp(i1);

//        System.out.println(i2);    //8103.083927575384

//        //返回参数的自然数底数的对数值。

//        double i1=9;

//        double i2 = Math.log(i1);

//        System.out.println(i2); //2.1972245773362196

//        //返回第一个参数的第二个参数次方。2的3次方.

//        double i1=2;

//        double i2=3;

//        double i3 = Math.pow(i1, i2);

//        System.out.println(i3);    //8.0

//        //求参数的算术平方根。

//        double i1=9;

//        double i2 = Math.sqrt(i1);

//        System.out.println(i2);    //3.0

//        //求指定double类型参数的正弦值。

//        double i1=3;

//        double i2 = Math.sin(i1);

//        System.out.println(i2);    //3.0

//        //求指定double类型参数的余弦值。

//        double i1=3;

//        double i2 = Math.cos(i1);

//        System.out.println(i2);    //-0.9899924966004454

//        //求指定double类型参数的正切值。

//        double i1=3;

//        double i2 = Math.tan(i1);

//        System.out.println(i2);    //-0.1425465430742778

//        //求指定double类型参数的反正弦值。NaN

//        double i1=1;

//        double i2 = Math.asin(i1);

//        System.out.println(i2);    //1.5707963267948966

//        //求指定double类型参数的反余弦值。NaN

//        double i1=2;

//        double i2 = Math.acos(i1);

//        System.out.println(i2);    //0.0

//        //求指定double类型参数的反正切值。

//        double i1=3;

//        double i2 = Math.atan(i1);

//        System.out.println(i2);    //1.2490457723982544

//        //将笛卡尔坐标转换为极坐标，并返回极坐标的角度值。

//        double i1=3;

//        double i2=3;

//        double i3 = Math.atan2(i1, i2);

//        System.out.println(i3); //0.7853981633974483

//        //将参数转化为角度。

//        double i1=3;

//        double i2 = Math.toDegrees(i1);

//        System.out.println(i2);    //171.88733853924697

//        //将角度转换为弧度。

//        double i1=3;

//        double i2 = Math.toRadians(i1);

//        System.out.println(i2);    //0.05235987755982988

//        //返回一个随机数。

//        double i1 = Math.random();

//        System.out.println(i1);    //0.9591935059236623

    }

}

public class Characters {

    public static void main(String[] args){

        char c1 = 'm';

//        //是否是一个字母

//        boolean b1 = Character.isLetter(c1);

//        System.out.println(b1);    //true

//        //是否是一个数字字符

//        boolean b1 = Character.isDigit(c1);

//        System.out.println(b1);    //false

//        //是否是一个空格

//        boolean b1 = Character.isWhitespace(c1);

//        System.out.println(b1);    //false

//        //是否是大写字母

//        boolean b1 = Character.isUpperCase(c1);

//        System.out.println(b1);    //false

//        //是否是小写字母

//        boolean b1 = Character.isLowerCase(c1);

//        System.out.println(b1);    //true

//        //指定字母的大写形式,变大写

//        char b1 = Character.toUpperCase(c1);

//        System.out.println(b1);    //M

//        //指定字母的小写形式,变小写

//        char b1 = Character.toLowerCase(c1);

//        System.out.println(b1);    //m

//        //返回字符的字符串形式，字符串的长度仅为1

//        String b1 = Character.toString(c1);

//        System.out.println(b1);    //m

    }

}

String()

          初始化一个新创建的 String 对象，它表示一个空字符序列。

String(byte[] bytes)

          构造一个新的 String，方法是使用平台的默认字符集解码字节的指定数组。

String(byte[] ascii, int hibyte)

          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 起，完成该转换的首选方法是通过 String 构造方法，该方法接受一个字符集名称或使用平台的默认字符集。

String(byte[] bytes, int offset, int length)

          构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。

String(byte[] ascii, int hibyte, int offset, int count)

          已过时。 该方法无法将字节正确转换为字符。从 JDK 1.1 开始，完成该转换的首选方法是通过 String 构造方法，它接受一个字符集名称，或者使用平台默认的字符集。

String(byte[] bytes, int offset, int length, String charsetName)

          构造一个新的 String，方法是使用指定的字符集解码字节的指定子数组。

String(byte[] bytes, String charsetName)

          构造一个新的 String，方法是使用指定的字符集解码指定的字节数组。

String(char[] value)

          分配一个新的 String，它表示当前字符数组参数中包含的字符序列。

String(char[] value, int offset, int count)

          分配一个新的 String，它包含来自该字符数组参数的一个子数组的字符。

String(int[] codePoints, int offset, int count)

          分配一个新的 String，它包含该 Unicode 代码点数组参数的一个子数组的字符。

String(String original)

          初始化一个新创建的 String 对象，表示一个与该参数相同的字符序列；换句话说，新创建的字符串是该参数字符串的一个副本。

String(StringBuffer buffer)

          分配一个新的字符串，它包含当前包含在字符串缓冲区参数中的字符序列。

import java.nio.charset.Charset;

import javax.print.DocFlavor.BYTE_ARRAY;

public class Strings {

    public static void main(String[] args){

        String s1 = "suoning";

        String s2 = "nick";

//        //返回指定索引处的 char 值。

//        char c1 = s1.charAt(3);

//        System.out.println(c1);    //n

//        //把这个字符串和另一个对象比较.等于返回0,此字符串小于字符串参数返回小于0,大于返回大于0.

//        int c1 = s1.compareTo(s2);

//        System.out.println(c1);    //5

//        //将指定字符串连接到此字符串的结尾。

//        String c1 = s1.concat(s2);

//        System.out.println(c1);    //suoningnick

//        //当且仅当字符串与指定的StringButter有相同顺序的字符时候返回真。

//        StringBuffer s3 = new StringBuffer("suoning");

//        boolean c1 = s1.contentEquals(s3);

//        System.out.println(c1);    //true

//        //返回指定数组中表示该字符序列的 String。

//        char[] s3 = {'s', 'u', 'o', ' ', 'n', 'i', 'n', 'g'};

//        String c1 = s1.copyValueOf(s3);

//        System.out.println(c1);    //suo ning

//        String c2 = s1.copyValueOf(s3, 1, 6);

//        System.out.println(c2);    //uo nin

//        //测试此字符串是否以指定的后缀结束。

//        boolean c1 = s1.endsWith(s2);

//        System.out.println(c1);    //false

//        //将此字符串与指定的对象比较。

//        boolean c1 = s1.equals(s2);

//        System.out.println(c1);    //false

//        //将此 String 与另一个 String 比较，不考虑大小写。

//        boolean c1 = s1.equalsIgnoreCase(s2);

//        System.out.println(c1);    //false

//        //使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。

//        byte[] c1 = s1.getBytes();

//        System.out.println(c1);    //[B@11e78461

//        //将字符从此字符串复制到目标字符数组。

//        //srcBegin -- 字符串中要复制的第一个字符的索引。 rcEnd -- 字符串中要复制的最后一个字符之后的索引。

//        //dst -- 目标数组。 dstBegin -- 目标数组中的起始偏移量。

//        //没有返回值，但会抛出 IndexOutOfBoundsException 异常。

//        //char[] s3 = new char[5];

//        s1.getChars(1,6,s3,0);

//        System.out.println(s3);    //uonin

//        //返回此字符串的哈希码。

//        int s3 = s1.hashCode();

//        System.out.println(s3);    //-1855756159

//        //返回指定字符在此字符串中第一次出现处的索引。

//        int s3 = s1.indexOf('s');

//        System.out.println(s3);    //0

//        //返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

//        int s3 = s1.indexOf('n', 3);

//        System.out.println(s3);    //3

//        // 返回字符串对象的规范化表示形式。

//        String s3 = s1.intern();

//        System.out.println(s3);    //suoning

//        // 返回指定字符在此字符串中最后一次出现处的索引。

//        int s3 = s1.lastIndexOf('n');

//        System.out.println(s3);    //5

//        // 返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。

//        int s3 = s1.lastIndexOf('n', 3);

//        System.out.println(s3);    //3

//        // 返回指定子字符串在此字符串中最右边出现处的索引。

//        String s4 = new String("ning");

//        int s3 = s1.lastIndexOf(s4);

//        System.out.println(s3);    //3

//        //返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

//        String s4 = new String("ning");

//        int s3 = s1.lastIndexOf(s4, 2);

//        System.out.println(s3);    //-1

//        //返回此字符串的长度。

//        int s3 = s1.length();

//        System.out.println(s3);    //7

//        //告知此字符串是否匹配给定的正则表达式。

//        boolean s3 = s1.matches("suo(.*)");

//        System.out.println(s3);    //true

        //测试两个字符串区域是否相等。

        //ignoreCase -- 如果为 true，则比较字符时忽略大小写。

        //toffset -- 此字符串中子区域的起始偏移量。

        //other -- 字符串参数。

        //toffset -- 字符串参数中子区域的起始偏移量。

        //len -- 要比较的字符数。

//        boolean s3 = s1.regionMatches(3, s2, 6, 4);

//        System.out.println(s3);    //false

//        boolean s3 = s1.regionMatches(true, 3, s2, 6, 4);

//        System.out.println(s3);    //false

//        //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

//        String s3 = s1.replace(' ', 'm');

//        System.out.println(s3);    //suoning

//        //返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。

//        String s3 = s1.replace(' ', 'm');

//        System.out.println(s3);    //suoning

//        // 使用给定的 replacement 替换此字符串所有匹配给定的正则表达式的子字符串。

//        String s3 = s1.replaceAll(".*", "m");

//        System.out.println(s3);    //mm

//        //使用给定的 replacement 替换此字符串匹配给定的正则表达式的第一个子字符串。

//        String s3 = s1.replaceFirst("n", "m");

//        System.out.println(s3);    //suoming

//        //根据给定正则表达式的匹配拆分此字符串。

//        String s5 = new String("suo ning");

//        String[] s3 = s5.split(" ", 0);

//        for (String retval: s3){

//            System.out.println(retval); //suo、ning

//        }

//        // 测试此字符串是否以指定的前缀开始。

//        boolean b1 = s1.startsWith(s2);

//        System.out.println(b1);    //false

//        //测试此字符串从指定索引开始的子字符串是否以指定前缀开始。

//        boolean b1 = s1.startsWith(s2, 3);

//        System.out.println(b1);    //false

//        //返回一个新的字符序列，它是此序列的一个子序列。

//        String s3 = s1.substring(2, 6);

//        System.out.println(s3);    //onin

//        //返回一个新的字符序列，它是此序列的一个子序列。

//        CharSequence s3 = s1.subSequence(2, 6);

//        System.out.println(s3);    //onin

//        //返回一个新的字符序列，它是此序列的一个子字符串。

//        String s3 = s1.substring(2, 6);

//        System.out.println(s3);    //onin

//        String s3 = s1.substring(2);

//        System.out.println(s3);    //oning

//        //将此字符串转换为一个新的字符数组。

//        System.out.println(s1.toCharArray());    //suoning

//        //使用默认语言环境的规则将此 String 中的所有字符都转换为小写。

//        String s3 = s1.toLowerCase();

//        System.out.println(s3);    //suoning

//        // 返回此对象本身（它已经是一个字符串！

//        String s3 = s1.toString();

//        System.out.println(s3);    //suoning

//        // 使用默认语言环境的规则将此 String 中的所有字符都转换为大写。

//        String s3 = s1.toUpperCase();

//        System.out.println(s3);    //SUONING

//        // 返回字符串的副本，忽略前导空白和尾部空白。

//        String s3 = s1.trim();

//        System.out.println(s3);    //suoning

//        // 返回给定data type类型x参数的字符串表示形式。

//        String s3 = String.valueOf(s1);

//        System.out.println(s3);    //suoning

    }

}

public class StringBufferBuilders {

    public static void main(String[] args){

        StringBuffer s1 = new StringBuffer("suoning");

//        //将指定的字符串追加到此字符序列。

//        String s2 = "nick";

//        StringBuffer s3 = s1.append(s2);

//        System.out.println(s3);    //suoningnick

//        //将此字符序列用其反转形式取代。

//        StringBuffer s3 = s1.reverse();

//        System.out.println(s3);    //gninous

//        //移除此序列的子字符串中的字符。

//        StringBuffer s3 = s1.delete(0, 3);

//        System.out.println(s3);    //ning

//        //将 int 参数的字符串表示形式插入此序列中。

//        StringBuffer s3 = s1.insert(3, 99);

//        System.out.println(s3);    //suo99ning

//        //使用给定 String 中的字符替换此序列的子字符串中的字符。

//        StringBuffer s3 = s1.replace(0, 3, "nick");

//        System.out.println(s3);    //nickning

//        //返回当前容量。

//        int s3 = s1.capacity();

//        System.out.println(s3);    //23

//        //返回此序列中指定索引处的 char 值。

//        char s3 = s1.charAt(3);

//        System.out.println(s3);    //n

//        //确保容量至少等于指定的最小值。

//        s1.ensureCapacity(1);

//        System.out.println(s1.capacity());    //23

//        //将字符从此序列复制到目标字符数组 dst。

//        char[] s2 = new char[4];

//        s1.getChars(3,7,s2,0);

//        System.out.println(s2);    //ning

//        //返回第一次出现的指定子字符串在该字符串中的索引。

//        String s2 = "nick";

//        int s3 = s1.indexOf(s2);

//        System.out.println(s3);    //-1

//        //从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。

//        String s2 = "nick";

//        int s3 = s1.indexOf(s2, 2);

//        System.out.println(s3);    //-1

//        //返回最右边出现的指定子字符串在此字符串中的索引。

//        String s2 = "nick";

//        int s3 = s1.lastIndexOf(s2);

//        System.out.println(s3);    //-1

//        //返回最后一次出现的指定子字符串在此字符串中的索引。

//        String s2 = "nick";

//        int s3 = s1.lastIndexOf(s2, 3);

//        System.out.println(s3);    //-1

//        // 返回长度（字符数）。

//        int s3 = s1.length();

//        System.out.println(s3);    //7

//        //将给定索引处的字符设置为 ch。

//        s1.setCharAt(3, 'm');

//        System.out.println(s1);    //suoming

//        //设置字符序列的长度

//        s1.setLength(9);

//        System.out.println(s1.length());    //9

//        //返回一个新的字符序列，该字符序列是此序列的子序列。

//        CharSequence s3 = s1.subSequence(3, 7);

//        System.out.println(s3);    //ning

//        //返回一个新的 String，它包含此字符序列当前所包含的字符子序列。

//        String s3 = s1.substring(3);

//        System.out.println(s3);    //ning

//        //返回一个新的 String，它包含此序列当前所包含的字符子序列。

//        String s3 = s1.substring(3,7);

//        System.out.println(s3);    //ning

//        //返回此序列中数据的字符串表示形式

//        String s3 = s1.toString();

//        System.out.println(s3);    //suoning

    }

}

public class TestArray {

   public static void main(String[] args) {

      double[] myList = {1.9, 2.9, 3.4, 3.5};

      // 打印所有数组元素

      for (int i = 0; i < myList.length; i++) {

         System.out.println(myList[i] + " ");

      }

      // 计算所有元素的总和

      double total = 0;

      for (int i = 0; i < myList.length; i++) {

         total += myList[i];

      }

      System.out.println("Total is " + total);

      // 查找最大元素

      double max = myList[0];

      for (int i = 1; i < myList.length; i++) {

         if (myList[i] > max) max = myList[i];

      }

      System.out.println("Max is " + max);

   }

}

import java.util.Arrays;

public class MyArrayOfs {

    public static void main(String[] args){

        int a1[] = new int[6];

        int[] a2 = new int[6];

        int[] a3 = {1, 2, 3, 4, 5, 6};

        int[] a5 = {1, 2, 3, 9, 8, 8};

        int[] a6 = {1, 2, 3, 4, 5, 6};

//        //    public static boolean equals(long[] a, long[] a2)

//        //如果两个指定的 long 型数组彼此相等，则返回 true。如果两个数组包含相同数量的元素，并且两个数组中的所有相应元素对都是相等的，则认为这两个数组是相等的。换句话说，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

//        boolean b1 = Arrays.equals(a3, a5);

//        System.out.println(b1);    //false

//        boolean b2 = Arrays.equals(a3, a6);

//        System.out.println(b2);    //true

//        //public static void fill(int[] a, int val)

//        //填充值

//        //将指定的 int 值分配给指定 int 型数组指定范围中的每个元素。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

//        Arrays.fill(a2, 9);

//        System.out.println(a2[5]);    //9

//        //public static void sort(Object[] a)

//        //对指定对象数组根据其元素的自然顺序进行升序排列。同样的方法适用于所有的其他基本数据类型（Byte，short，Int等）。

//        Arrays.sort(a5);

//        for(int i: a5) {

//             System.out.println(i);    //1、2、3、8、8、9

//          }

//        //public static int binarySearch(Object[] a, Object key)

//        //用二分查找算法在给定数组中搜索给定值的对象(Byte,Int,double等)。数组在调用前必须排序好的。如果查找值包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。

//        int index1 = Arrays.binarySearch(a5, 9);

//        System.out.println(index1);  //-7

//        Arrays.sort(a5);

//        int index2 = Arrays.binarySearch(a5, 8);

//        System.out.println(index2);  //4

//        int index3 = Arrays.binarySearch(a5, 9);

//        System.out.println(index3);  //

    }

}

import java.util.Date;

public class DateTimes {

    public static void main(String[] args){

        Date d1 = new Date();

        long t1 = 1514736000000L;

        Date d2 = new Date(t1);

        System.out.println(d1);  //Mon Dec 05 23:59:59 CST 2016

        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018

//        //    boolean after(Date date)

//        //若当调用此方法的Date对象在指定日期之前\后返回true,否则返回false。

//        boolean b1 = d2.after(d1);

//        System.out.println(b1);  //true

//        //    int compareTo(Date date)

//        //比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数

//        int b1 = d2.compareTo(d1);

//        System.out.println(b1);  //1

//        //    int compareTo(Object obj)

//        //若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。

//        int b1 = d2.compareTo(d1);

//        System.out.println(b1);  //1

//        //boolean equals(Object date)

//        //当调用此方法的Date对象和指定日期相等时候返回true,否则返回false

//        boolean b1 = d2.equals(d1);

//        System.out.println(b1);  //false

//        //    long getTime( )

//        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

//        long l1 = d2.getTime();

//        System.out.println(l1);  //1514736000000

//        //int hashCode( )

//        //返回此对象的哈希码值。

//        long l1 = d2.hashCode();

//        System.out.println(l1);  //-1387455136

//        //void setTime(long time)

//        //用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。

//        d1.setTime(t1);

//        System.out.println(d1);  //Mon Jan 01 00:00:00 CST 2018

//        //String toString( )

//        //转换Date对象为String表示形式，并返回该字符串。

//        d2.toString();

//        System.out.println(d2);  //Mon Jan 01 00:00:00 CST 2018

    }

}

import java.util.Date;

public class DateDemo {

   public static void main(String args[]) {

       // 初始化 Date 对象

       Date date = new Date();

       // 使用 toString() 函数显示日期时间

       System.out.println(date.toString());

   }

}

//解析字符串为时间

import java.util.*;

import java.text.*;

public class DateTimes {

    public static void main(String args[]) {

        SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd");

        String input = args.length == 0 ? "2018-01-01" : args[0];

        System.out.print(input + " Parses as ");

        Date t;

        try {

          t = ft.parse(input);

          System.out.println(t);

          } catch (ParseException e) {

          System.out.println("Unparseable using " + ft);

          //2018-01-01 Parses as Mon Jan 01 00:00:00 CST 2018

        }

    }

}

//Java 休眠(sleep)

import java.util.*;

public class DateTimes {

    public static void main(String args[]) {

        try {

            System.out.println(new Date( ) + "\n");

            Thread.sleep(1000*3); // 休眠3秒

            System.out.println(new Date( ) + "\n");

        } catch (Exception e) {

            System.out.println("Got an exception!");

        }

    }

}

//检测时间间隔（以毫秒为单位）

import java.util.*;

public class DateTimes {

   public static void main(String args[]) {

      try {

         long start = System.currentTimeMillis( );

         System.out.println(new Date( ) + "\n");

         Thread.sleep(5*20*5);

         System.out.println(new Date( ) + "\n");

         long end = System.currentTimeMillis( );

         long diff = end - start;

         System.out.println("Difference is : " + diff);    //Difference is : 520

      } catch (Exception e) {

         System.out.println("Got an exception!");

      }

   }

}