String及其他常用API（String，StringBuilder，StringBuffer，Date，DateFormat，Math，System，Object，Arrays，包装类）

1.String

String类：一个字符串就是一个String对象
字符串是由多个字符组成的一串数据(字符序列)

String构造方法：

public String()
public String(byte[] bytes)
public String(byte[] bytes,int offset,int length)
public String(char[] value)
public String(char[] value,int offset,int count)
public String(String original)

String对象特点：

字符串是常量,它的值在创建之后不能更改

String s = “hello”; s += “world”; 问s的结果是多少?

面试题
String s = new String(“hello”)和String s = “hello”;的区别?

字符串比较之看程序写结果
字符串拼接之看程序写结果

String类的的判断功能：

boolean equals(Object obj)：比较字符串内容是否相同(区分大小写)
boolean equalsIgnoreCase(String str)：不区分大小写
boolean contains(String str)：判断当前字符串中是否包含参数内容
boolean startsWith(String str)：判断当前字符串对否以参数字符串开头
boolean endsWith(String str)：判断当前字符串是否已参数字符串结尾
boolean isEmpty()：判断空字符串 “”

用户登录

public class StringTest01 {
    public static void main(String[] args) {
        //已知用户名和密码，定义两个字符串表示即可
        String username = "user";
        String password = "123456";

        //用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束循环
        for(int i=0; i<3; i++) {

            //键盘录入要登录的用户名和密码，用 Scanner 实现
            Scanner sc = new Scanner(System.in);

            System.out.println("请输入用户名：");
            String name = sc.nextLine();

            System.out.println("请输入密码：");
            String pwd = sc.nextLine();

            //拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。字符串的内容比较，用equals() 方法实现
            if (name.equals(username) && pwd.equals(password)) {
                System.out.println("登录成功");
                break;
            } else {
                if(2-i == 0) {
                    System.out.println("你的账户被锁定，请与管理员联系");
                } else {
                    //2,1,0
                    //i,0,1,2
                    System.out.println("登录失败，你还有" + (2 - i) + "次机会");
                }
            }
        }
    }
}

小例子

public class Main {

    public static void main(String[] args) {
        //boolean equals(Object obj)

        String s = "helloworld";
        System.out.println(s.equals("Helloworld"));//输出false
        System.out.println(s.equals("Helloworld"));//输出true
        //不区分大小写的相等比较
        System.out.println(s.equalsIgnoreCase("Helloworld"));//输出true

        //boolean contains(String str) // 判断当前字符串中是否包含参数内容
        String s1 = "woshidawang";
        String s2 = "da";
        System.out.println(s1.contains(s2));//输出true

        //boolean startsWith(String str) //判断当前字符串对否以参数字符串开头
        String s3 = "wo";
        System.out.println(s1.startsWith(s3));//输出true


        //boolean endsWith(String str) // 判断当前字符串是否已参数字符串结尾
        String s4 = "ng";
        System.out.println(s1.endsWith(s4));//输出true

        //boolean isEmpty() //判断空字符串 “”  null
        String s5 = "";
        System.out.println(s5.isEmpty());//输出true
        String s6 = " ";
        System.out.println(s6.isEmpty());//输出false

        int a = ' ';
        System.out.println(a);//输出32

    }
}

String类的的获取功能：

int length()：当前字符串中包含的字符序列中的字符个数
char charAt(int index)：返回当前字符串对象中某个位置的字符 “abc”
int indexOf(int ch) ：返回 某个字符在当前字符串中首次出现的位置
int indexOf(String str)：查找参数字符串，当前字符串中首次出现的位置
int indexOf(int ch,int fromIndex)：从当前字符串的某个位置开始(包含这个位置)，向后查找参数字符首次出现的位置
int indexOf(String str,int fromIndex)：从当前字符串的某个位置开始(包含这个位置)，向后查找参数字符串首次出现的位置
String substring(int start) ：返回当前字符串从某个位置开始一直到结束的子串(不会改变原字符串)
String substring(int start,int end)：从[start, end)位置的当前字符串的子串

遍历字符串

统计字符次数

public class StringTest03 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

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

        //要统计三种类型的字符个数，需定义三个统计变量，初始值都为0
        int bigCount = 0;
        int smallCount = 0;
        int numberCount = 0;

        //遍历字符串，得到每一个字符
        for(int i=0; i<line.length(); i++) {
            char ch = line.charAt(i);

            //判断该字符属于哪种类型，然后对应类型的统计变量+1
            if(ch>='A' && ch<='Z') {
                bigCount++;
            } else if(ch>='a' && ch<='z') {
                smallCount++;
            } else if(ch>='0' && ch<='9') {
                numberCount++;
            }
        }

        //输出三种类型的字符个数
        System.out.println("大写字母：" + bigCount + "个");
        System.out.println("小写字母：" + smallCount + "个");
        System.out.println("数字：" + numberCount + "个");

    }
}

拼接字符串

public class StringTest04 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};

        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);

        //输出结果
        System.out.println("s:" + s);
    }

    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
            返回值类型：String
            参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        //在方法中遍历数组，按照要求进行拼接
        String s = "";

        s += "[";

        for(int i=0; i<arr.length; i++) {
            if(i==arr.length-1) {
                s += arr[i];
            } else {
                s += arr[i];
                s += ", ";
            }
        }

        s += "]";

        return s;
    }
}

字符串反转

public class StringTest05 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

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

        //调用方法，用一个变量接收结果
        String s = reverse(line);

        //输出结果
        System.out.println("s:" + s);
    }

    //定义一个方法，实现字符串反转
    /*
        两个明确：
            返回值类型：String
            参数：String s
     */
    public static String reverse(String s) {
        //在方法中把字符串倒着遍历，然后把每一个得到的字符拼接成一个字符串并返回
        String ss = "";

        for(int i=s.length()-1; i>=0; i--) {
            ss += s.charAt(i);
        }

        return ss;
    }
}

小例子

public class Main2 {
    public static void main(String[] args) {
        //int  length()    // 当前字符串中包含的字符序列中的字符个数
        String s1 = "atm";
        System.out.println(s1.length());//输出3

        // char charAt(int index) // 返回当前字符串对象中某个位置的字符  “abc”
        String s2 = "yuzhoutiao";
        System.out.println(s2.charAt(4));//输出o

        //int indexOf(int ch) //返回 某个字符在当前字符串中首次出现的位置
        String s3 = "absca";
        System.out.println("s3字符串absca中a首次出现的位置"+s3.indexOf('a'));//输出0

        // int indexOf(int ch,int fromIndex)  从当前字符串的某个位置开始(包含这个位置)，向后查找参数字符首次出现的位置
        System.out.println("s3字符串absca中从1开始向后查找a首次出现的位置："+s3.indexOf('a', 0));

        //int indexOf(String str,int fromIndex)
        String s4 = "sc";
        System.out.println("s3字符串absca中子字符串sc首次出现的位置："+s3.indexOf(s4));
        System.out.println("s3字符串absca中从3开始向后查找sc首次出现的位置："+s3.indexOf(s4, 3));


        // String substring(int start)
        String s5 = "abcedef";
        System.out.println("从位置2开始截取子串："+s5.substring(2));//cedef

        //String substring(int start,int end) [start, end)
        System.out.println("从位置1开始到leng-1截取子串："+s5.substring(1, s5.length() - 1)); //bcede


    }
}

输出：

3
o
s3字符串absca中a首次出现的位置0
s3字符串absca中从1开始向后查找a首次出现的位置：0
s3字符串absca中子字符串sc首次出现的位置：2
s3字符串absca中从3开始向后查找sc首次出现的位置：-1
从位置2开始截取子串：cedef
从位置1开始到leng-1截取子串：bcede

String类的的转换功能：

byte[] getBytes()：返回当前字符串中字符序列所代表的byte
char[] toCharArray()：返回当前字符串中字符序列的字符数组
static String valueOf(char[] chs)：将字符数组转化成对应的字符串
static String valueOf(int i)：把整数表示为其字符串表示形式 1 “1”
String toLowerCase()：把字符串转化为小写
String toUpperCase()：把字符串转化为大写
String concat(String str)：字符串连接

public class Main3 {

    public static void main(String[] args) {

        //byte[] getBytes()  //返回当前字符串中字符序列所代表的byte[]
        String s = "abc";
        System.out.println(s.getBytes());//输出：[B@1b6d3586
        System.out.println(Arrays.toString(s.getBytes())); //输出：[97, 98, 99]

        // char[] toCharArray() //返回当前字符串中字符序列的字符数组
        System.out.println(Arrays.toString(s.toCharArray()));//输出：[a, b, c]

        //static String valueOf(char[] chs) //将字符数组转化成对应的字符串
        char[] chars = {'a', 'b', 'c', 'd'};
        String s1 = String.valueOf(chars);
        System.out.println("字符数组'a','b','c','d'转化成对应的字符串:"+s1);
        //输出：字符数组'a','b','c','d'转化成对应的字符串:abcd

        //static String valueOf(int i)
        System.out.println(String.valueOf(1) + 1);//输出：11
        System.out.println(String.valueOf(new Main3()));//输出：com.company.Main3@4554617c
        System.out.println(String.valueOf(3.3) + 1);//输出：3.31

        //String toLowerCase()
        String s2 = "ABcdEF";
        System.out.println(s2.toLowerCase());//abcdef
        
        System.out.println(s2.toUpperCase());//  ABCDEF
        //String concat(String str) //字符串连接
        System.out.println(s2.concat("lalala"));// ABcdEFlalala

    }
}

String类的替换功能
String replace(char old,char new)
String replace(String old,String new)

String类去除空格字符
String trim()

String类的比较功能
int compareTo(String str)
int compareToIgnoreCase(String str)

public class Main4 {

    public static void main(String[] args) {
        //String replace(char old,char new)  //用新字符替换字符串中所有旧字符
        String s = "ababab";
        String replace = s.replace('a', 'c');
        System.out.println(replace);//输出：cbcbcb

        //ababab -> "ab" -> "cd"
        String replace1 = s.replace("ab", "cd");
        System.out.println(replace1);//输出：cdcdcd

        //String trim()
        String s1 = " hello world ";
        System.out.println(s1 + " " + s1.length());
        System.out.println(s1.trim() + " " + s1.trim().length());

        // int compareTo(String str)
        System.out.println("helloworld".compareTo("hew"));

        int a = 'l' - 'w';
        System.out.println("span = " + a);

        System.out.println("helloworld".compareTo("hel"));//字符串长度比较，做差
        System.out.println('A' + 0);//+0，转为ASCII码数值
    }
}

2.StringBuilder

构造方法

添加和反转方法

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //创建对象
        StringBuilder sb = new StringBuilder();

        //public StringBuilder append(任意类型)：添加数据，并返回对象本身
//        StringBuilder sb2 = sb.append("hello");
//
//        System.out.println("sb:" + sb);
//        System.out.println("sb2:" + sb2);
//        System.out.println(sb == sb2);

//        sb.append("hello");
//        sb.append("world");
//        sb.append("java");
//        sb.append(100);

        //链式编程
        sb.append("hello").append("world").append("java").append(100);

        System.out.println("sb:" + sb);

        //public StringBuilder reverse()：返回相反的字符序列
        sb.reverse();
        System.out.println("sb:" + sb);
    }
}

StringBuilder和string相互转换

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        /*
        //StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

//        String s = sb; //这个是错误的做法

        //public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
        String s = sb.toString();
        System.out.println(s);
        */

        //String 转换为 StringBuilder
        String s = "hello";

//        StringBuilder sb = s; //这个是错误的做法

        //public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
        StringBuilder sb = new StringBuilder(s);

        System.out.println(sb);
    }
}

拼接字符串升级版

public class StringBuilderTest01 {
    public static void main(String[] args) {
        //定义一个 int 类型的数组，用静态初始化完成数组元素的初始化
        int[] arr = {1, 2, 3};

        //调用方法，用一个变量接收结果
        String s = arrayToString(arr);

        //输出结果
        System.out.println("s:" + s);

    }

    //定义一个方法，用于把 int 数组中的数据按照指定格式拼接成一个字符串返回
    /*
        两个明确：
            返回值类型：String
            参数：int[] arr
     */
    public static String arrayToString(int[] arr) {
        //在方法中用 StringBuilder 按照要求进行拼接，并把结果转成 String 返回
        StringBuilder sb = new StringBuilder();

        sb.append("[");

        for(int i=0; i<arr.length; i++) {
            if(i == arr.length-1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(", ");
            }
        }

        sb.append("]");

        String s = sb.toString();

        return  s;
    }

}

字符串反转升级版

public class StringBuilderTest02 {
    public static void main(String[] args) {
        //键盘录入一个字符串，用 Scanner 实现
        Scanner sc = new Scanner(System.in);

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

        //调用方法，用一个变量接收结果
        String s = myReverse(line);

        //输出结果
        System.out.println("s:" + s);
    }

    //定义一个方法，实现字符串反转。返回值类型 String，参数 String s
    /*
        两个明确：
            返回值类型：String
            参数：String s
     */
    public static String myReverse(String s) {
        //在方法中用StringBuilder实现字符串的反转，并把结果转成String返回
        //String --- StringBuilder --- reverse() --- String
//        StringBuilder sb = new StringBuilder(s);
//        sb.reverse();
//        String ss = sb.toString();
//        return ss;

       return new StringBuilder(s).reverse().toString();
    }
}

3.StringBuffer

我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。

为解决上述问题，Java语言引入了StringBuffer。

String 和 StringBuffer的区别？ StringBuffer是可变字符缓冲区

构造方法
public StringBuffer()
public StringBuffer(int capacity)： 可以指定StringBuffer初始容量
public StringBuffer(String str)：初始字符

public class Main6 {
    public static void main(String[] args) {

        //public StringBuffer()
        // capacity: 字符缓冲去本身的大小() 16个字符
        // length：字符缓冲区中真正包含的字符个数
        StringBuffer stringBuffer = new StringBuffer();
        System.out.println(stringBuffer.capacity());  //16
        System.out.println(stringBuffer.length()); //0

        // public StringBuffer(int capacity)  可以指定StringBuffer初始容量
        stringBuffer = new StringBuffer(20);
        System.out.println(stringBuffer.capacity());//输出：20
        System.out.println(stringBuffer.length());//输出：0

        //public StringBuffer(String str)
        stringBuffer = new StringBuffer("helloworld"); //参数字符串长度 + 16
        System.out.println(stringBuffer.capacity());//输出：26
        System.out.println(stringBuffer.length());//输出：10
    }

}

添加功能

不管任何数据类型都可以被添加到字符缓冲区中：

• 1. 如果该类型不是字符串类型 该值 -> 字符串类型
• 2. 放入字缓冲区中

  public StringBuffer append(String str) //向字符缓冲区中添加字符序列
  public StringBuffer insert(int offset,String str)

  虽然说，StringBuffer可以自动扩容，但是通常在开发中建议使用public StringBuffer(int capacity)
  如果在开发中，能有效的预估字符缓冲区所需的长度，因为每一次扩容，其实都比较耗时
  public StringBuffer append(String str)
  public StringBuffer insert(int offset,String str)

代码示例：

class Main5 {
    public static void main(String[] args) {

        //StringBuffer 可以自己根据需要扩容
        StringBuffer stringBuffer = new StringBuffer(); //capacity 16
        stringBuffer.append("12345678901234567890abc");
        String s = stringBuffer.toString();
        System.out.println(s);//输出：12345678901234567890abc
        System.out.println(stringBuffer.capacity());//输出：34

        // 测试尾部追加 append
        int i = 10;
        stringBuffer.append(i);
        System.out.println(stringBuffer.toString());//输出：12345678901234567890abc10

        boolean b = true;
        stringBuffer.append(b);
        System.out.println(stringBuffer.toString());//输出：12345678901234567890abc10true

        // insert
        // public StringBuffer insert(int offset,String str)
        String s1 = "jiang";
        stringBuffer.insert(3, s1);
        System.out.println(stringBuffer.toString());//输出：123jiang45678901234567890abc10true

        //链式调用 向stringbuffer插入 ‘a’ 1 true
        stringBuffer.insert(1, 'a')
                .append(1)
                .append(false);
        System.out.println(stringBuffer.toString());//输出：1a23jiang45678901234567890abc10true1false

        //己测试自己写的链式调用方法
        ChainedCall chainedCall = new ChainedCall();
        ChainedCall print = chainedCall.print("123").print(new Main5());
        //输出：123
        //com.company.Main5@1b6d3586
        System.out.println(print == chainedCall);//输出：true
    }

}

class ChainedCall {

    public ChainedCall print(Object o) {

        System.out.println(o.toString());
        return this;
    }

删除功能
public StringBuffer deleteCharAt(int index)
public StringBuffer delete(int start,int end)

替换功能
public StringBuffer replace(int start,int end,String str)

反转功能
public StringBuffer reverse()

截取功能
public String substring(int start)
public String substring(int start,int end)

截取功能和前面几个功能的不同:返回值类型是String类型，本身没有发生改变

StringBuffer练习：
1.String和StringBuffer的相互转换
2.把数组拼接成一个字符串
3.把字符串反转
判断一个字符串是否是对称字符串
例如"abc"不是对称字符串，“aba”、“abba”、“aaa”、"mnanm"是对称字符串

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

        exercise2("1234");

        exercise3("abbac");
    }

    //1.把数组拼接成一个字符串 {1, 2, 3}
    public static void exercise1(int[] a) {
        StringBuffer buffer = new StringBuffer("{");
        for (int i = 0; i < a.length; i++) {
            int value = a[i];
            buffer.append(value).append(',');
        }

        buffer.deleteCharAt(buffer.length() - 1);
        buffer.append("}");
        System.out.println(buffer.toString());
    }

    //2. 把字符串反转
    public static void exercise2(String s) {
        StringBuffer buffer = new StringBuffer();
        // insert(0)  "abc"
        // "a" -> "ba" -> "cba"
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            buffer.insert(0, c);
        }
        System.out.println(buffer.toString());
    }

    //3.判断一个字符串是否是对称字符串
    public static void exercise3(String s) {

        StringBuffer stringBuffer = new StringBuffer(s);
        StringBuffer reverse = stringBuffer.reverse();
        System.out.println(reverse.toString().equals(s));
    }

}

输出：

{1,2,3,4}
4321
false

面试题

String, StringBuffer和StringBuilder有啥区别

• StringBuilder针对 单线程 运行环境，它的api和StringBuffer几乎没有差别
• 单线程：同一时间点永远只有写入缓冲区，和从缓冲区中读入数据。
  VS
• StringBuffer 针对多线程运行环境

StringBuffer和StringBuilder从效率上来说哪个更快？
StringBuilder更快

4.Date

Date类概述：类 Date 表示特定的瞬间，精确到毫秒。

构造方法
public Date()
public Date(long date)

成员方法
public long getTime()
public void setTime(long time)

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

long date表示从 The epoch 开始，经过的毫秒数

5.DateFormat

SimpleDateForma类概述

DateFormat类概述
是日期/时间格式化子类的抽象类
它以与语言无关的方式格式化并解析日期或时间。
因为是抽象类，所以实际使用的是SimpleDateFormat这个实现子类

SimpleDateFormat的构造方法
public SimpleDateFormat(String pattern)

成员方法
public final String format(Date date) ：把一个用字符串表示的时间转化成一个Date对象，该对象表示的时间点，就是你用字符串表示的那个时间点

public class Main8 {

    public static void main(String[] args) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy/mm/dd HH/mm/ss");
Date s=format.parse("2020/01/11 13/12/12");
        System.out.println(s);
    }
}

输出：

Sat Jan 11 13:12:12 CST 2020

public Date parse(String source)： 把一个Date对象表示成一个指定格式的表示时间的字符串

public class Main8 {

    public static void main(String[] args) throws ParseException {
        SimpleDateFormat format = new SimpleDateFormat("yyyy/mm/dd HH/mm/ss");
        Date date = new Date();
        String format1= format.format(date);
        System.out.println(format1);
    }
}

输出：

2021/50/16 22/50/15

• y 年
• M 表示年中的月份
• d 表示月份中的天数
• H 表示一天中的小时数
• m 小时中的分钟
• s 分钟中的秒数

2020-01-10 17:06:00
yyyy/MM/dd HH:mm:ss

SimpleDateForma格式化和解析日期

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
        //格式化：从 Date 到 String
        Date d = new Date();
//        SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String s = sdf.format(d);
        System.out.println(s);
        System.out.println("--------");

        //从 String 到 Date
        String ss = "2048-08-09 11:11:11";
        //ParseException
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date dd = sdf2.parse(ss);
        System.out.println(dd);
    }
}

日期工具类

**工具类：**
构造方法私有
成员方法静态

DateUtils

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

/*
    工具类

    构造方法私有
    成员方法静态
 */
public class DateUtils {
    private DateUtils() {}

    /*
        把日期转为指定格式的字符串
        返回值类型：String
        参数：Date date, String format
     */
    public static String dateToString(Date date, String format) {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        String s = sdf.format(date);
        return s;
    }


    /*
        把字符串解析为指定格式的日期
        返回值类型：Date
        参数：String s, String format
     */
    public static Date stringToDate(String s, String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(s);
        return d;
    }

}

DateDemo

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

/*
    测试类
 */
public class DateDemo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date d = new Date();

        String s1 = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s1);

        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        System.out.println(s2);

        String s3 = DateUtils.dateToString(d, "HH:mm:ss");
        System.out.println(s3);
        System.out.println("--------");

        String s = "2048-08-09 12:12:12";
        Date dd = DateUtils.stringToDate(s, "yyyy-MM-dd HH:mm:ss");
        System.out.println(dd);
    }
}

Calendar类概述

public class CalendarDemo {
    public static void main(String[] args) {
        //获取日历类对象
        Calendar c = Calendar.getInstance();

        //public int get​(int field):返回给定日历字段的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH) + 1;
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        //public abstract void add​(int field, int amount):根据日历的规则，将指定的时间量添加或减去给定的日历字段
        //需求1:3年前的今天
        c.add(Calendar.YEAR,-3);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        //需求2:10年后的10天前
        c.add(Calendar.YEAR,10);
        c.add(Calendar.DATE,-10);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

        //public final void set​(int year,int month,int date):设置当前日历的年月日
        c.set(2050,10,10);
        year = c.get(Calendar.YEAR);
        month = c.get(Calendar.MONTH) + 1;
        date = c.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");

    }
}

6.Math

Math类概述
Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

成员方法
public static int abs(int a)：求绝对值
public static double ceil(double a)：取整 向大的方向取整
public static double floor(double a)：取整 向小的方向取
public static int max(int a,int b) min自学
public static double pow(double a,double b)：a^b
public static double random()：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0 [0.0 1.0) 随机数。
public static int round(float a)： public static int round(float a) 取整 4舍五入的取整
public static double sqrt(double a)：返回正确舍入的 double 值的正平方根

7.System

system包含几个有用的类字段和方法，它不能被实例化

/*
    System类的常用方法
 */
public class SystemDemo {
    public static void main(String[] args) {
        /*
        System.out.println("开始");
        //public static void exit(int status)：终止当前运行的 Java 虚拟机，非零表示异常终止
        System.exit(0);
        System.out.println("结束");
        */

        //public static long currentTimeMillis()：返回当前时间(以毫秒为单位)
        System.out.println(System.currentTimeMillis());

        //计算距离1970年过去了多少年
        System.out.println(System.currentTimeMillis() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        //运行到10000的循环花费多少时间
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();
        System.out.println("共耗时：" + (end - start) + "毫秒");
    }
}

8.Object

toString()

建议所有子类重写此方法：toString()

Student

public class Student extends Object {
    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;
    }

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

ObjectDemo

public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        System.out.println(s); //com.itheima_01.Student@3f3afe78
        System.out.println(s.toString()); //com.itheima_01.Student@3f3afe78


    }
}

equals（）

Student

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;
    }

    @Override
    public boolean equals(Object o) {
        //this -- s1
        //o -- s2
        //比较this（s1）与o（s2）地址是否相同，如果相同，直接返回true
        if (this == o) return true;
        
        //判断参数o是否为null
        //判断两个对象是否来自于同一个类
        if (o == null || getClass() != o.getClass()) return false;
        
         //将o向下转型
        Student student = (Student) o; //student -- s2

        //比较年龄是否相同
        if (age != student.age) return false;
        
        //比较姓名内容是否相同
        return name != null ? name.equals(student.name) : student.name == null;
    }
}

ObjectDemo

public class ObjectDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);

        Student s2 = new Student();
        s2.setName("林青霞");
        s2.setAge(30);

        //需求：比较两个对象的内容是否相同
//        System.out.println(s1 == s2);
        System.out.println(s1.equals(s2));

    }
}

9.Arrays

public class ArraysDemo {
    public static void main(String[] args) {
        //定义一个数组
        int[] arr = {24, 69, 80, 57, 13};

        System.out.println("排序前：" + Arrays.toString(arr));

        Arrays.sort(arr);

        System.out.println("排序后：" + Arrays.toString(arr));

//        Math;
//        System;
    }
}

10.基本类型包装类

Interger类的概述和使用

public class IntegerDemo {
    public static void main(String[] args) {
        //public Integer(int value)：根据 int 值创建 Integer 对象(过时)
        Integer i1 = new Integer(100);
        System.out.println(i1);

        //public Integer(String s)：根据 String 值创建 Integer 对象(过时)
        Integer i2 = new Integer("100");
//        Integer i2 = new Integer("abc"); //NumberFormatException
        System.out.println(i2);
        System.out.println("--------");

        //public static Integer valueOf​(int i)：返回表示指定的 int 值的 Integer 实例
        Integer i3 = Integer.valueOf(100);
        System.out.println(i3);

        //public static Integer valueOf​(String s)：返回一个保存指定值的 Integer 对象 String
        //Integer i4 = Integer.valueOf("abc");//NumberFormatException
        Integer i4 = Integer.valueOf("100");
        System.out.println(i4);
    }
}

int和string的相互转换

/*
    int和String的相互转换
 */
public class IntegerDemo {
    public static void main(String[] args) {
        //int --- String
        int number = 100;
        //方式1
        String s1 = number + "";
        System.out.println(s1);
        //方式2
        //public static String valueOf​(int i)
        String s2 = String.valueOf(number);
        System.out.println(s2);
        System.out.println("--------");

        //String --- int
        String s = "100";
        //方式1：String --- Integer --- int
        Integer i = Integer.valueOf(s);
        //public int intValue​()
        int x = i.intValue();
        System.out.println(x);
        //方式2
        //public static int parseInt​(String s)
        int y = Integer.parseInt(s);
        System.out.println(y);
    }
}

字符串中数据排序

public class IntegerTest {
    public static void main(String[] args) {
        //定义一个字符串
        String s = "91 27 46 38 50";

        //把字符串中的数字数据存储到一个int类型的数组中
        String[] strArray = s.split(" ");
//        for(int i=0; i<strArray.length; i++) {
//            System.out.println(strArray[i]);
//        }

        //定义一个int数组，把 String[] 数组中的每一个元素存储到 int 数组中
        int[] arr = new int[strArray.length];
        for(int i=0; i<arr.length; i++) {
            arr[i] = Integer.parseInt(strArray[i]);
        }

        //对 int 数组进行排序
        Arrays.sort(arr);

        //把排序后的int数组中的元素进行拼接得到一个字符串，这里拼接采用StringBuilder来实现
        StringBuilder sb = new StringBuilder();
        for(int i=0; i<arr.length; i++) {
            if(i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(" ");
            }
        }
        String result = sb.toString();

        //输出结果
        System.out.println(result);
    }
}

自动装箱和拆箱

public class IntegerDemo {
    public static void main(String[] args) {
        //装箱：把基本数据类型转换为对应的包装类类型
        Integer i = Integer.valueOf(100);
        Integer ii = 100; //Integer.valueOf(100);

        //ii += 200;
        // ii = ii + 200;
        // ii = ii.intValue() + 200;
        // ii = 300;
        ii += 200;
        System.out.println(ii);

        Integer iii = null;
//        iii += 100; //NullPointerException
        if(iii != null) {
            iii += 100;
        }

    }
}