常用API

一、 Scanner类

  一个可以解析基本类型和字符串的简单文本扫描器。

  System.in 系统输入指的是通过键盘录入数据。

//1. 导包
import java.util.Scanner;
public class Demo01_Scanner {   public static void main(String[] args) {     //2. 创建键盘录入数据的对象     Scanner sc = new Scanner(System.in);     //3. 接收数据     System.out.println("请录入一个整数:");     int i = sc.nextInt();     //4. 输出数据     System.out.println("i:"+i);   } }

二、Random类

  此类的实例用于生成伪随机数。

/* 
   使用Random类,完成生成3个10以内的随机整数的操作,代码如下: 
*/
//1. 导包
import java.util.Random;
public class Demo01_Random {
  public static void main(String[] args) {
    //2. 创建键盘录入数据的对象
     Random r = new Random();
     for(int i = 0; i < 3; i++){
       //3. 随机生成一个数据
      int number = r.nextInt(10);
      //4. 输出数据
      System.out.println("number:"+ number);
    }
  }
}

  猜数字小游戏:

  游戏开始时,会随机生成一个1-100之间的整数 number 。玩家猜测一个数字 guessNumber ,会与 number 作比 较,系统提示大了或者小了,直到玩家猜中,游戏结束。

import java.util.Random;
public class Test02Random {
    public static void main(String[] args) {
        // 系统产生一个随机数1‐100之间的。
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        while(true){
            // 键盘录入我们要猜的数据
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入你要猜的数字(1‐100):");
            int guessNumber = sc.nextInt();
            // 比较这两个数据(用if语句)
            if (guessNumber > number) {
                System.out.println("你猜的数据" + guessNumber + "大了");
            } else if (guessNumber < number) {
                System.out.println("你猜的数据" + guessNumber + "小了");
            } else {
                    System.out.println("恭喜你,猜中了");
               break;
            }
    }
}
}      

三、String类

  java.lang.String 类代表字符串。Java程序中所有的字符串文字(例如 "abc" )都可以被看作是实现此类的实例。

  类 String 中包括用于检查各个字符串的方法,比如用于比较字符串,搜索字符串,提取子字符串以及创建具有翻 译为大写或小写的所有字符的字符串的副本。

  3.1 特点

  (1)字符串不变:字符串的值在创建后不能被更改。

String s1 = "abc";
s1 += "d";
System.out.println(s1); // "abcd"
// 内存中有"abc","abcd"两个对象,s1从指向"abc",改变指向,指向了"abcd"。

  (2)因为String对象是不可变的,所以它们可以被共享。

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建,同时被s1和s2共享。

  (3)"abc" 等效于 char[] data={ ‘a‘ , ‘b‘ , ‘c‘ } 。

例如:
String str = "abc";
相当于:
char[] data = {‘a‘, ‘b‘, ‘c‘};
String str = new String(data);
// String底层是靠字符数组实现的。

  3.2  构造方法

// 无参构造
String str = new String();
// 通过字符数组构造
char chars[] = {‘a‘, ‘b‘, ‘c‘};
String str2 = new String(chars);
// 通过字节数组构造
byte bytes[] = { 97, 98, 99 };
String str3 = new String(bytes);

  3.3 常用方法

  (1)判断功能的方法

  • public boolean equals (Object anObject) :将此字符串与指定对象进行比较。
  • public boolean equalsIgnoreCase (String anotherString) :将此字符串与指定对象进行比较,忽略大小 写。  
常用API
/*

==是进行对象的地址值比较,如果确实需要字符串的内容比较,可以使用两个方法:

public boolean equals(Object obj):参数可以是任何对象,只有参数是一个字符串并且内容相同的才会给true;否则返回false。
    注意事项:
    1. 任何对象都能用Object进行接收。
    2. equals方法具有对称性,也就是a.equals(b)和b.equals(a)效果一样。
    3. 如果比较双方一个常量一个变量,推荐把常量字符串写在前面。
    推荐:"abc".equals(str)    不推荐:str.equals("abc")

public boolean equalsIgnoreCase(String str):忽略大小写,进行内容比较。

 */
public class Demo01StringEquals {

    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = "Hello";
        char[] charArray = {‘H‘, ‘e‘, ‘l‘, ‘l‘, ‘o‘};
        String str3 = new String(charArray);

        System.out.println(str1.equals(str2)); // true
        System.out.println(str2.equals(str3)); // true
        System.out.println(str3.equals("Hello")); // true
        System.out.println("Hello".equals(str1)); // true

        String str4 = "hello";
        System.out.println(str1.equals(str4)); // false
        System.out.println("=================");

        String str5 = null;
        System.out.println("abc".equals(str5)); // 推荐:false
//        System.out.println(str5.equals("abc")); // 不推荐:报错,空指针异常NullPointerException
        System.out.println("=================");

        String strA = "Java";
        String strB = "java";
        System.out.println(strA.equals(strB)); // false,严格区分大小写
        System.out.println(strA.equalsIgnoreCase(strB)); // true,忽略大小写

        // 注意,只有英文字母区分大小写,其他都不区分大小写
        System.out.println("abc一123".equalsIgnoreCase("abc壹123")); // false
    }

}
判断功能

  (2)获取功能的方法

  • public int length () :返回此字符串的长度。
  • public String concat (String str) :将指定的字符串连接到该字符串的末尾。
  • public char charAt (int index) :返回指定索引处的 char值。
  • public int indexOf (String str) :返回指定子字符串第一次出现在该字符串内的索引。
  • public String substring (int beginIndex) :返回一个子字符串,从beginIndex开始截取字符串到字符 串结尾。
  • public String substring (int beginIndex, int endIndex) :返回一个子字符串,从beginIndex到 endIndex截取字符串。含beginIndex,不含endIndex。
常用API
/*
String当中与获取相关的常用方法有:

    public int length():获取字符串当中含有的字符个数,拿到字符串长度。
    public String concat(String str):将当前字符串和参数字符串拼接成为返回值新的字符串。
    public char charAt(int index):获取指定索引位置的单个字符。(索引从0开始。)
    public int indexOf(String str):查找参数字符串在本字符串当中首次出现的索引位置,如果没有返回-1值。

 */
public class Demo02StringGet {

    public static void main(String[] args) {
        // 获取字符串的长度
        int length = "asdasfeutrvauevbueyvb".length();
        System.out.println("字符串的长度是:" + length);

        // 拼接字符串
        String str1 = "Hello";
        String str2 = "World";
        String str3 = str1.concat(str2);
        System.out.println(str1); // Hello,原封不动
        System.out.println(str2); // World,原封不动
        System.out.println(str3); // HelloWorld,新的字符串
        System.out.println("==============");

        // 获取指定索引位置的单个字符
        char ch = "Hello".charAt(1);
        System.out.println("在1号索引位置的字符是:" + ch);
        System.out.println("==============");

        // 查找参数字符串在本来字符串当中出现的第一次索引位置
        // 如果根本没有,返回-1值
        String original = "HelloWorldHelloWorld";
        int index = original.indexOf("llo");
        System.out.println("第一次索引值是:" + index); // 2

        System.out.println("HelloWorld".indexOf("abc")); // -1
    }

}
获取功能

      (3)转换功能

  • public char[] toCharArray():将当前字符串拆分成为字符数组作为返回值。
  • public byte[] getBytes():获得当前字符串底层的字节数组。
  • public String replace(CharSequence oldString, CharSequence newString):将所有出现的老字符串替换成为新的字符串,返回替换之后的结果新字符串。
常用API
public class Demo04StringConvert {

    public static void main(String[] args) {
        // 转换成为字符数组
        char[] chars = "Hello".toCharArray();
        System.out.println(chars[0]); // H
        System.out.println(chars.length); // 5
        System.out.println("==============");

        // 转换成为字节数组
        byte[] bytes = "abc".getBytes();
        for (int i = 0; i < bytes.length; i++) {
            System.out.println(bytes[i]);
        }
        System.out.println("==============");

        // 字符串的内容替换
        String str1 = "How do you do?";
        String str2 = str1.replace("o", "*");
        System.out.println(str1); // How do you do?
        System.out.println(str2); // H*w d* y*u d*?
        System.out.println("==============");

        String lang1 = "会不会玩儿呀!你大爷的!你大爷的!你大爷的!!!";
        String lang2 = lang1.replace("你大爷的", "****");
        System.out.println(lang2); // 会不会玩儿呀!****!****!****!!!
    }

}
转换功能

  (4)分割功能

  • public String[] split(String regex):按照参数的规则,将字符串切分成为若*分。
常用API
/*
分割字符串的方法:
    public String[] split(String regex):按照参数的规则,将字符串切分成为若*分。

    注意事项:
    split方法的参数其实是一个“正则表达式”。
    如果按照英文句点“.”进行切分,必须写"\\."(两个反斜杠)
 */
public class Demo05StringSplit {

    public static void main(String[] args) {
        String str1 = "aaa,bbb,ccc";
        String[] array1 = str1.split(",");
        for (int i = 0; i < array1.length; i++) {
            System.out.println(array1[i]);
        }
        System.out.println("===============");

        String str2 = "aaa bbb ccc";
        String[] array2 = str2.split(" ");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i]);
        }
        System.out.println("===============");

        String str3 = "XXX.YYY.ZZZ";
        String[] array3 = str3.split("\\.");
        System.out.println(array3.length); // 0
        for (int i = 0; i < array3.length; i++) {
            System.out.println(array3[i]);
        }
    }

}
分割功能

  (5)截取功能

  • public String substring(int index):截取从参数位置一直到字符串末尾,返回新字符串。
  • public String substring(int begin, int end):截取从begin开始,一直到end结束,中间的字符串。
常用API
/*
字符串的截取方法:

    public String substring(int index):截取从参数位置一直到字符串末尾,返回新字符串。
    public String substring(int begin, int end):截取从begin开始,一直到end结束,中间的字符串。

    备注:[begin,end),包含左边,不包含右边。
 */
public class Demo03Substring {

    public static void main(String[] args) {
        String str1 = "HelloWorld";
        String str2 = str1.substring(5);
        System.out.println(str1); // HelloWorld,原封不动
        System.out.println(str2); // World,新字符串
        System.out.println("================");

        String str3 = str1.substring(4, 7);
        System.out.println(str3); // oWo
        System.out.println("================");

        // 下面这种写法,字符串的内容仍然是没有改变的
        // 下面有两个字符串:"Hello","Java"
        // strA当中保存的是地址值。
        // 本来地址值是Hello的0x666,
        // 后来地址值变成了Java的0x999
        String strA = "Hello";
        System.out.println(strA); // Hello
        strA = "Java";
        System.out.println(strA); // Java
    }

}
截取功能

  (6)综合练习

常用API
/*
题目:
    定义一个方法,把数组{1,2,3}按照指定格式拼接成一个字符串。格式参照如下:[word1#word2#word3]。

分析:
    1. 首先准备一个int[]数组,内容是:1、2、3
    2. 定义一个方法,用来将数组变成字符串
    3. 格式:[word1#word2#word3]
    用到:for循环、字符串拼接、每个数组元素之前都有一个word字样、分隔使用的是#、区分一下是不是最后一个
    4. 调用方法,得到返回值,并打印结果字符串
三要素
    返回值类型:String
    方法名称:fromArrayToString
    参数列表:int[]

 */
public class Demo06StringPractise {

    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4};

        String result = fromArrayToString(array);
        System.out.println(result);
    }

    public static String fromArrayToString(int[] array) {
        String str = "[";
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) {
                str += "word" + array[i] + "]";
            } else {
                str += "word" + array[i] + "#";
            }
        }
        return str;
    }

}
练习1
常用API
import java.util.Scanner;

/*
题目:
    键盘输入一个字符串,并且统计其中各种字符出现的次数。
    种类有:大写字母、小写字母、数字、其他

思路:
    1. 既然用到键盘输入,肯定是Scanner
    2. 键盘输入的是字符串,那么:String str = sc.next();
    3. 定义四个变量,分别代表四种字符各自的出现次数。
    4. 需要对字符串一个字、一个字检查,String-->char[],方法就是toCharArray()
    5. 遍历char[]字符数组,对当前字符的种类进行判断,并且用四个变量进行++动作。
    6. 打印输出四个变量,分别代表四种字符出现次数。
 */
public class Demo07StringCount {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个字符串:");
        String input = sc.next(); // 获取键盘输入的一个字符串

        int countUpper = 0; // 大写字母
        int countLower = 0; // 小写字母
        int countNumber = 0; // 数字
        int countOther = 0; // 其他字符

        char[] charArray = input.toCharArray();
        for (int i = 0; i < charArray.length; i++) {
            char ch = charArray[i]; // 当前单个字符
            if (‘A‘ <= ch && ch <= ‘Z‘) {
                countUpper++;
            } else if (‘a‘ <= ch && ch <= ‘z‘) {
                countLower++;
            } else if (‘0‘ <= ch && ch <= ‘9‘) {
                countNumber++;
            } else {
                countOther++;
            }
        }

        System.out.println("大写字母有:" + countUpper);
        System.out.println("小写字母有:" + countLower);
        System.out.println("数字有:" + countNumber);
        System.out.println("其他字符有:" + countOther);
    }

}
练习2

四、Arrays类

  java.util.Arrays 此类包含用来操作数组的各种方法,比如排序和搜索等。其所有方法均为静态方法,调用起来非常简单。

import java.util.Arrays;

/*
java.util.Arrays是一个与数组相关的工具类,里面提供了大量静态方法,用来实现数组常见的操作。

    public static String toString(数组):将参数数组变成字符串(按照默认格式:[元素1, 元素2, 元素3...])
    public static void sort(数组):按照默认升序(从小到大)对数组的元素进行排序。

备注:
    1. 如果是数值,sort默认按照升序从小到大
    2. 如果是字符串,sort默认按照字母升序
    3. 如果是自定义的类型,那么这个自定义的类需要有Comparable或者Comparator接口的支持。
 */
public class Demo01Arrays {

    public static void main(String[] args) {
        int[] intArray = {10, 20, 30};
        // 将int[]数组按照默认格式变成字符串
        String intStr = Arrays.toString(intArray);
        System.out.println(intStr); // [10, 20, 30]

        int[] array1 = {2, 1, 3, 10, 6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10]

        String[] array2 = {"bbb", "aaa", "ccc"};
        Arrays.sort(array2);
        System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc]
    }

}
常用API
import java.util.Arrays;

/*
题目:
    请使用Arrays相关的API,将一个随机字符串中的所有字符升序排列,并倒序打印。
 */
public class Demo02ArraysPractise {

    public static void main(String[] args) {
        String str = "asv76agfqwdfvasdfvjh";

        // 如何进行升序排列:sort
        // 必须是一个数组,才能用Arrays.sort方法
        // String --> 数组,用toCharArray
        char[] chars = str.toCharArray();
        Arrays.sort(chars); // 对字符数组进行升序排列

        // 需要倒序遍历
        for (int i = chars.length - 1; i >= 0; i--) {
            System.out.println(chars[i]);
        }
    }

}
小练习

五、Math类

  java.lang.Math 类包含用于执行基本数学运算的方法,如初等指数、对数、平方根和三角函数。类似这样的工具 类,其所有方法均为静态方法,并且不会创建对象,调用起来非常简单。

  • public static double abs(double num):获取绝对值。有多种重载。
  • public static double ceil(double num):向上取整。
  • public static double floor(double num):向下取整。
  • public static long round(double num):四舍五入。
常用API
/*
java.util.Math类是数学相关的工具类,里面提供了大量的静态方法,完成与数学运算相关的操作。

    public static double abs(double num):获取绝对值。有多种重载。
    public static double ceil(double num):向上取整。
    public static double floor(double num):向下取整。
    public static long round(double num):四舍五入。

    Math.PI代表近似的圆周率常量(double)。
 */
public class Demo03Math {

    public static void main(String[] args) {
        // 获取绝对值
        System.out.println(Math.abs(3.14)); // 3.14
        System.out.println(Math.abs(0)); // 0
        System.out.println(Math.abs(-2.5)); // 2.5
        System.out.println("================");

        // 向上取整
        System.out.println(Math.ceil(3.9)); // 4.0
        System.out.println(Math.ceil(3.1)); // 4.0
        System.out.println(Math.ceil(3.0)); // 3.0
        System.out.println("================");

        // 向下取整,抹零
        System.out.println(Math.floor(30.1)); // 30.0
        System.out.println(Math.floor(30.9)); // 30.0
        System.out.println(Math.floor(31.0)); // 31.0
        System.out.println("================");

        System.out.println(Math.round(20.4)); // 20
        System.out.println(Math.round(10.5)); // 11
    }

}
工具类方法
常用API
/*
题目:
    计算在-10.8到5.9之间,绝对值大于6或者小于2.1的整数有多少个?

分析:
    1. 既然已经确定了范围,for循环
    2. 起点位置-10.8应该转换成为-10,两种办法:
        2.1 可以使用Math.ceil方法,向上(向正方向)取整
        2.2 强转成为int,自动舍弃所有小数位
    3. 每一个数字都是整数,所以步进表达式应该是num++,这样每次都是+1的。
    4. 如何拿到绝对值:Math.abs方法。
    5. 一旦发现了一个数字,需要让计数器++进行统计。

备注:如果使用Math.ceil方法,-10.8可以变成-10.0。注意double也是可以进行++的。
 */
public class Demo04MathPractise {

    public static void main(String[] args) {
        int count = 0; // 符合要求的数量

        double min = -10.8;
        double max = 5.9;
        // 这样处理,变量i就是区间之内所有的整数
        for (int i = (int) min; i < max; i++) {
            int abs = Math.abs(i); // 绝对值
            if (abs > 6 || abs < 2.1) {
                System.out.println(i);
                count++;
            }
        }

        System.out.println("总共有:" + count); // 9
    }

}
练习

六、Object类

  java.lang.Object类是Java语言中的根类,即所有类的父类。它中描述的所有方法子类都可以使用。在对象实例化的时候,最终找的父类就是Object。

1、toString方法

  方法摘要

  • public String toString():返回该对象的字符串表示。

  toString方法返回该对象的字符串表示,其实该字符串内容就是对象的类型+@+内存地址值。

  由于toString方法返回的结果是内存地址,而在开发中,经常需要按照对象的属性得到相应的字符串表现形式,因此也需要重写它。

  覆盖重写

  如果不希望使用toString方法的默认行为,则可以对它进行覆盖重写。例如自定义的Person类:

public class Person {  
    private String name;
    private int age;
?
    @Override
    public String toString() {
        return "Person{" + "name=‘" + name + ‘\‘‘ + ", age=" + age + ‘}‘;
    }
?
    // 省略构造器与Getter Setter
}

  在IntelliJ IDEA中,可以点击Code菜单中的Generate...,也可以使用快捷键alt+insert,点击toString()选项。选择需要包含的成员变量并确定。如下图所示:

小贴士: 在直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

2、equals方法

  方法摘要

  • public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。

  调用成员方法equals并指定参数为另一个对象,则可以判断这两个对象是否是相同的。这里的“相同”有默认和自定义两种方式。

  默认地址比较

  如果没有覆盖重写equals方法,那么Object类中默认进行==运算符的对象地址比较,只要不是同一个对象,结果必然为false。

  对象内容比较

  如果希望进行对象的内容比较,即所有或指定的部分成员变量相同就判定两个对象相同,则可以覆盖重写equals方法。例如:

import java.util.Objects;

public class Person {    
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object o) {
        // 如果对象地址一样,则认为相同
        if (this == o)
            return true;
        // 如果参数为空,或者类型信息不一样,则认为不同
        if (o == null || getClass() != o.getClass())
            return false;
        // 转换为当前类型
        Person person = (Person) o;
        // 要求基本类型相等,并且将引用类型交给java.util.Objects类的equals静态方法取用结果
        return age == person.age && Objects.equals(name, person.name);
    }
}

七、日期时间类

1 Date类

  概述

  java.util.Date类 表示特定的瞬间,精确到毫秒。

  继续查阅Date类的描述,发现Date拥有多个构造函数,只是部分已经过时,但是其中有未过时的构造函数可以把毫秒值转成日期对象。

  • public Date():分配Date对象并初始化此对象,以表示分配它的时间(精确到毫秒)。

  • public Date(long date):分配Date对象并初始化此对象,以表示自从标准基准时间(称为“历元(epoch)”,即1970年1月1日00:00:00 GMT)以来的指定毫秒数。

  • public long getTime() 把日期对象转换成对应的时间毫秒值。

tips: 由于我们处于东八区,所以我们的基准时间为1970年1月1日8时0分0秒。

  简单来说:使用无参构造,可以自动设置当前系统时间的毫秒时刻;指定long类型的构造参数,可以自定义毫秒时刻。例如:

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
        // 创建日期对象,把当前的时间
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2018
        // 创建日期对象,把当前的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

//在使用println方法时,会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写,所以结果为指定格式的字符串。

2 DateFormat类

  java.text.DateFormat 是日期/时间格式化子类的抽象类,我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

  • 格式化:按照指定的格式,从Date对象转换为String对象。

  • 解析:按照指定的格式,从String对象转换为Date对象。

  构造方法

  由于DateFormat为抽象类,不能直接使用,所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式(格式)来指定格式化或解析的标准。构造方法为:

  • public SimpleDateFormat(String pattern):用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。

  参数pattern是一个字符串,代表日期时间的自定义格式。

  格式规则

  常用的格式规则为:

       常用API

import java.text.DateFormat;
import java.text.SimpleDateFormat;

public class Demo02SimpleDateFormat {
    public static void main(String[] args) {
        // 对应的日期格式如:2018-01-16 15:06:38
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }    
}

  常用方法

  DateFormat类的常用方法有:

  • public String format(Date date):将Date对象格式化为字符串。

  • public Date parse(String source):将字符串解析为Date对象。

  format方法

  使用format方法的代码为:

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把Date对象转换成String
*/
public class Demo03DateFormatMethod {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建日期格式化对象,在获取格式化对象时可以指定风格
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
          String str = df.format(date);
        System.out.println(str); // 2008年1月23日
    }
}

  parse方法

  使用parse方法的代码为:

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
/*
 把String转换成Date对象
*/
public class Demo04DateFormatMethod {
    public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
        String str = "2018年12月11日";
        Date date = df.parse(str);
        System.out.println(date); // Tue Dec 11 00:00:00 CST 2018
    }
}
常用API
/*
    请使用日期时间相关的API,计算出一个人已经出生了多少天。

    **思路:**

    1.获取当前时间对应的毫秒值

    2.获取自己出生日期对应的毫秒值

    3.两个时间相减(当前时间– 出生日期)
*/
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);
    }
}
练习

4 Calendar类

  4.1 概念

  java.util.Calendar是日历类,在Date后出现,替换掉了许多Date的方法。该类将所有可能用到的时间信息封装为静态成员变量,方便获取。日历类就是方便获取各个时间属性的。

  4.2 获取方式

  Calendar为抽象类,由于语言敏感性,Calendar类在创建对象时并非直接创建,而是通过静态方法创建,返回子类对象,如下:

  Calendar静态方法

  • public static Calendar getInstance():使用默认时区和语言环境获得一个日历

  例如:

import java.util.Calendar;

public class Demo06CalendarInit {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
    }    
}

  4.3 常用方法

  根据Calendar类的API文档,常用方法有:

  • public int get(int field):返回给定日历字段的值。

  • public void set(int field, int value):将给定的日历字段设置为给定值。

  • public abstract void add(int field, int amount):根据日历的规则,为给定的日历字段添加或减去指定的时间量。

  • public Date getTime():返回一个表示此Calendar时间值(从历元到现在的毫秒偏移量)的Date对象。

  Calendar类中提供很多成员常量,代表给定的日历字段:  

  常用API

  4.3.1 get/set方法

  get方法用来获取指定字段的值,set方法用来设置指定字段的值,代码使用演示:

import java.util.Calendar;

public class CalendarUtil {
    public static void main(String[] args) {
        // 创建Calendar对象
        Calendar cal = Calendar.getInstance();
        // 设置年 
        int year = cal.get(Calendar.YEAR);
        // 设置月
        int month = cal.get(Calendar.MONTH) + 1;
        // 设置日
        int dayOfMonth = cal.get(Calendar.DAY_OF_MONTH);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日");
    }    
}

import java.util.Calendar;

public class Demo07CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.YEAR, 2020);
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2020年1月17日
    }
}

  4.3.2 add方法

  add方法可以对指定日历字段的值进行加减操作,如果第二个参数为正数则加上偏移量,如果为负数则减去偏移量。代码如:

import java.util.Calendar;

public class Demo08CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2018年1月17日
        // 使用add方法
        cal.add(Calendar.DAY_OF_MONTH, 2); // 加2天
        cal.add(Calendar.YEAR, -3); // 减3年
        System.out.print(year + "年" + month + "月" + dayOfMonth + "日"); // 2015年1月18日; 
    }
}

  4.3.3 getTime方法

  Calendar中的getTime方法并不是获取毫秒时刻,而是拿到对应的Date对象。

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

public class Demo09CalendarMethod {
    public static void main(String[] args) {
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        System.out.println(date); // Tue Jan 16 16:03:09 CST 2018
    }
}

 

  小贴士:

  西方星期的开始为周日,中国为周一。

  在Calendar类中,月份的表示是以0-11代表1-12月。

  日期是有大小关系的,时间靠后,时间越大。

八、System类

  java.lang.System类中提供了大量的静态方法,可以获取与系统相关的信息或系统级操作,在System类的API文档中,常用的方法有:

  • public static long currentTimeMillis():返回以毫秒为单位的当前时间。

  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中。

1 currentTimeMillis方法

  实际上,currentTimeMillis方法就是 获取当前系统时间与1970年01月01日00:00点之间的毫秒差值

import java.util.Date;

public class SystemDemo {
    public static void main(String[] args) {
           //获取当前时间毫秒值
        System.out.println(System.currentTimeMillis()); // 1516090531144
    }
}

2 arraycopy方法

  • public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length):将数组中指定的数据拷贝到另一个数组中。

  数组的拷贝动作是系统级的,性能很高。System.arraycopy方法具有5个参数,含义分别为:

常用API

常用API
/*
将src数组中前3个元素,复制到dest数组的前3个位置上复制元素前:src数组元素[1,2,3,4,5],dest数组元素[6,7,8,9,10]复制元素后:src数组元素[1,2,3,4,5],dest数组元素[1,2,3,9,10]
*/
import java.util.Arrays;

public class Demo11SystemArrayCopy {
    public static void main(String[] args) {
        int[] src = new int[]{1,2,3,4,5};
        int[] dest = new int[]{6,7,8,9,10};
        System.arraycopy( src, 0, dest, 0, 3);
        /*代码运行后:两个数组中的元素发生了变化
         src数组元素[1,2,3,4,5]
         dest数组元素[1,2,3,9,10]
        */
    }
}
练习

九、StringBuilder类

  由于String类的对象内容不可改变,所以每当进行字符串拼接时,总是会在内存中创建一个新的对象。例如:

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";
        System.out.println(s);
    }
}

  java.lang.StringBuilder的API,StringBuilder又称为可变字符序列,它是一个类似于 String 的字符串缓冲区,通过某些方法调用可以改变该序列的长度和内容。

  StringBuilder是个字符串的缓冲区,即它是一个容器,容器中可以装很多字符串。并且能够对其中的字符串进行各种操作。

  它的内部拥有一个数组用来存放字符串内容,进行字符串拼接时,直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。原理如下图所示:(默认16字符空间,超过自动扩充)

1 构造方法

  根据StringBuilder的API文档,常用构造方法有2个:

  • public StringBuilder():构造一个空的StringBuilder容器。

  • public StringBuilder(String str):构造一个StringBuilder容器,并将字符串添加进去。

public class StringBuilderDemo {
    public static void main(String[] args) {
        StringBuilder sb1 = new StringBuilder();
        System.out.println(sb1); // (空白)
        // 使用带参构造
        StringBuilder sb2 = new StringBuilder("itcast");
        System.out.println(sb2); // itcast
    }
}

2 常用方法

  StringBuilder常用的方法有2个:

  • public StringBuilder append(...):添加任意类型数据的字符串形式,并返回当前对象自身。

  • public String toString():将当前StringBuilder对象转换为String对象。

  2.1 append方法

  append方法具有多种重载形式,可以接收任意类型的参数。任何数据作为参数都会将对应的字符串内容添加到StringBuilder中。例如:

//备注:StringBuilder已经覆盖重写了Object当中的toString方法。
public class Demo02StringBuilder {
    public static void main(String[] args) {
        //创建对象
        StringBuilder builder = new StringBuilder();
        //public StringBuilder append(任意类型)
        StringBuilder builder2 = builder.append("hello");
        //对比一下
        System.out.println("builder:"+builder);
        System.out.println("builder2:"+builder2);
        System.out.println(builder == builder2); //true
        // 可以添加 任何类型
        builder.append("hello");
        builder.append("world");
        builder.append(true);
        builder.append(100);
        // 在我们开发中,会遇到调用一个方法后,返回一个对象的情况。然后使用返回的对象继续调用方法。
        // 这种时候,我们就可以把代码现在一起,如append方法一样,代码如下
        //链式编程
        builder.append("hello").append("world").append(true).append(100);
        System.out.println("builder:"+builder);
    }
}

  2.2 toString方法

  通过toString方法,StringBuilder对象将会转换为不可变的String对象。如:

public class Demo16StringBuilder {
    public static void main(String[] args) {
        // 链式创建
        StringBuilder sb = new StringBuilder("Hello").append("World").append("Java");
        // 调用方法
        String str = sb.toString();
        System.out.println(str); // HelloWorldJava
    }
}

十、包装类

1 概述

  Java提供了两个类型系统,基本类型与引用类型,使用基本类型在于效率,然而很多情况,会创建对象使用,因为对象可以做更多的功能。

        如果想要我们的基本类型像对象一样操作,就可以使用基本类型对应的包装类,如下:

      常用API

2 装箱与拆箱

  基本类型与对应的包装类对象之间,来回转换的过程称为”装箱“与”拆箱“:

  • 装箱:从基本类型转换为对应的包装类对象。

  • 拆箱:从包装类对象转换为对应的基本类型。

//示例
//基本数值---->包装对象
Integer i = new Integer(4);//使用构造函数函数
Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法

//包装对象---->基本数值
int num = i.intValue();

3 自动装箱与自动拆箱

  由于我们经常要做基本类型与包装类之间的转换,从Java 5(JDK 1.5)开始,基本类型与包装类的装箱、拆箱动作可以自动完成。例如:

Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);
i = i + 5;//等号右边:将i对象转成基本数值(自动拆箱) i.intValue() + 5;
//加法运算完成后,再次装箱,把基本数值转成对象。

4 基本类型与字符串之间的转换

4.1 基本类型转String

  常用:基本类型直接与””相连接即可;如:34+""

4.2 String转换成对应的基本类型

除了Character类之外,其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型:

  • public static byte parseByte(String s):将字符串参数转换为对应的byte基本类型。

  • public static short parseShort(String s):将字符串参数转换为对应的short基本类型。

  • public static int parseInt(String s):将字符串参数转换为对应的int基本类型。

  • public static long parseLong(String s):将字符串参数转换为对应的long基本类型。

  • public static float parseFloat(String s):将字符串参数转换为对应的float基本类型。

  • public static double parseDouble(String s):将字符串参数转换为对应的double基本类型。

  • public static boolean parseBoolean(String s):将字符串参数转换为对应的boolean基本类型。

// 注意:如果字符串参数的内容无法正确转换为对应的基本类型,则会抛出`java.lang.NumberFormatException`异常。

 

常用API

上一篇:火狐不支持backgroundPosition的js插件


下一篇:Windows上Tomcat安装以及解决乱码问题