一、 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) ：将此字符串与指定对象进行比较，忽略大小 写。
/*==是进行对象的地址值比较，如果确实需要字符串的内容比较，可以使用两个方法：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。
/*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)：将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串。
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)：按照参数的规则，将字符串切分成为若干部分。
/*分割字符串的方法： 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结束，中间的字符串。
/*字符串的截取方法： 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）综合练习
/*题目： 定义一个方法，把数组{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; }} 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); }} 3.4
常用的字符串拼接方式有五种，分别是使用+、使用concat、使用StringBuilder、使用StringBuffer以及使用StringUtils.join。
由于字符串拼接过程中会创建新的对象，所以如果要在一个循环体中进行字符串拼接，就要考虑内存问题和效率问题。
因此，经过对比，我们发现，直接使用StringBuilder的方式是效率最高的。因为StringBuilder天生就是设计来定义可变字符串和字符串的变化操作的。
但是，还要强调的是：
- 1、如果不是在循环体中进行字符串拼接的话，直接使用
+就好了。 - 2、如果在并发场景中进行字符串拼接的话，要使用
StringBuffer来代替StringBuilder。
四、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] }} 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)：四舍五入。
/*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 }} /*题目： 计算在-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类
方法摘要
-
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方法
方法摘要
调用成员方法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对象并初始化此对象，以表示分配它的时间（精确到毫秒）。 -
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是一个字符串，代表日期时间的自定义格式。
格式规则
常用的格式规则为：
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，计算出一个人已经出生了多少天。 **思路：** 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.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(); } } 根据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类中提供很多成员常量，代表给定的日历字段：
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日 }} 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月。
日期是有大小关系的，时间靠后，时间越大。
八、
java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作，在System类的API文档中，常用的方法有：
-
public static long currentTimeMillis()：返回以毫秒为单位的当前时间。 -
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)：将数组中指定的数据拷贝到另一个数组中。
import java.util.Date;public class SystemDemo { public static void main(String[] args) { //获取当前时间毫秒值 System.out.println(System.currentTimeMillis()); // 1516090531144 }} 数组的拷贝动作是系统级的，性能很高。System.arraycopy方法具有5个参数，含义分别为：
/*将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] */ }}
public class StringDemo { public static void main(String[] args) { String s = "Hello"; s += "World"; System.out.println(s); }} java.lang.StringBuilder
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 }} StringBuilder常用的方法有2个：
-
public StringBuilder append(...)：添加任意类型数据的字符串形式，并返回当前对象自身。 -
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); }} 通过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 }} Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能。
如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：
2 装箱与拆箱
基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：
-
装箱：从基本类型转换为对应的包装类对象。
-
拆箱：从包装类对象转换为对应的基本类型。
//示例//基本数值---->包装对象Integer i = new Integer(4);//使用构造函数函数Integer iii = Integer.valueOf(4);//使用包装类中的valueOf方法//包装对象---->基本数值int num = i.intValue();
由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：
Integer i = 4;//自动装箱。相当于Integer i = Integer.valueOf(4);i = i + 5;//等号右边：将i对象转成基本数值(自动拆箱) i.intValue() + 5;//加法运算完成后，再次装箱，把基本数值转成对象。
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`异常。