java之经常使用API
Scanner类html
Random类java
ArrayList类程序员
String类正则表达式
Arrays类编程
Math类数组
Object类安全
时间相关类app
System类dom
什么是API
API(Application Programming Interface)，应用程序编程接口。Java API是一本程序员的 字典 ，是JDK中提供给 咱们使用的类的说明文档。这些类将底层的代码实现封装了起来，咱们不须要关心这些类是如何实现的，只须要学习这些类如何使用便可。因此咱们能够经过查询API的方式，来学习Java提供的类，并得知如何使用它们。
使用步骤：
1. 打开帮助文档。
2. 点击显示，找到索引，看到输入框。
3. 你要找谁？在输入框里输入，而后回车。
4. 看包。java.lang下的类不须要导包，其余须要。
5. 看类的解释和说明。
6. 学习构造方法。
7. 使用成员方法。
Scanner类
Scanner类的功能：能够实现键盘输入数据，到程序当中。
使用步骤：
1. 导包：import 包路径.类名称;
若是须要使用的目标类，和当前类位于同一个包下，则能够省略导包语句不写。
只有java.lang包下的内容不须要导包，其余的包都须要import语句。
2. 建立：类名称 对象名 = new 类名称();
3. 使用：对象名.成员方法名()
1 import java.util.Scanner; // 1. 导包 2 3 public static void main(String[] args) { 4 // 2. 建立 5 // 备注：System.in表明从键盘进行输入 6 Scanner sc = new Scanner(System.in); 7 8 // 3. 获取键盘输入的int数字 9 int num = sc.nextInt(); 10 System.out.println("输入的int数字是：" + num); 11 12 // 4. 获取键盘输入的字符串 13 String str = sc.next(); 14 System.out.println("输入的字符串是：" + str); 15 }
方法：
获取键盘输入的一个int数字：int num = sc.nextInt();
获取键盘输入的一个字符串：String str = sc.next();
其他方法经过API来查找。
Random类
Random类：用来生成伪随机数字。
使用步骤：
1. 导包：import java.util.Random;
2. 建立：Random r = new Random(); // 小括号当中留空便可
3. 使用
获取一个随机的int数字（范围是int全部范围，有正负两种）：int num = r.nextInt()
获取一个随机的int数字（参数表明了范围，左闭右开区间）：int num = r.nextInt(3)。实际上表明的含义是：[0,3)，也就是0~2
1 // 1,导包 2 import java.util.Random; 3 public class Demo01Random { 4 5 public static void main(String[] args) { 6 // 建立对象 7 Random r = new Random(); 8 9 // 使用建立的对象调用方法 10 int num = r.nextInt(); 11 System.out.println("随机数是：" + num); 12 } 13 }
1 import java.util.Random; 2 import java.util.Scanner; 3 4 /* 5 题目： 6 用代码模拟猜数字的小游戏。 7 8 思路： 9 1. 首先须要产生一个随机数字，而且一旦产生再也不变化。用Random的nextInt方法 10 2. 须要键盘输入，因此用到了Scanner 11 3. 获取键盘输入的数字，用Scanner当中的nextInt方法 12 4. 已经获得了两个数字，判断（if）一下： 13 若是太大了，提示太大，而且重试； 14 若是过小了，提示过小，而且重试； 15 若是猜中了，游戏结束。 16 5. 重试就是再来一次，循环次数不肯定，用while(true)。 17 */ 18 public class Demo04RandomGame { 19 20 public static void main(String[] args) { 21 Random r = new Random(); 22 int randomNum = r.nextInt(100) + 1; // [1,100] 23 Scanner sc = new Scanner(System.in); 24 25 while (true) { 26 System.out.println("请输入你猜想的数字："); 27 int guessNum = sc.nextInt(); // 键盘输入猜想的数字 28 29 if (guessNum > randomNum) { 30 System.out.println("太大了，请重试。"); 31 } else if (guessNum < randomNum) { 32 System.out.println("过小了，请重试。"); 33 } else { 34 System.out.println("恭喜你，猜中啦！"); 35 break; // 若是猜中，再也不重试 36 } 37 } 38 39 System.out.println("游戏结束。"); 40 } 41 42 }
方法：
在API中查看
ArrayList类
引例：到目前为止，咱们想存储对象数据，选择的容器，只有对象数组。而数组的长度是固定的，没法适应数据变化的需求。为了解决这个问题，Java提供了另外一个容器 java.util.ArrayList 集合类,让咱们能够更便捷的存储和操做对象数据。
1 // 类 2 public class Person { 3 4 private String name; 5 private int age; 6 7 public Person() { 8 } 9 10 public Person(String name, int age) { 11 this.name = name; 12 this.age = age; 13 } 14 15 public String getName() { 16 return name; 17 } 18 19 public void setName(String name) { 20 this.name = name; 21 } 22 23 public int getAge() { 24 return age; 25 } 26 27 public void setAge(int age) { 28 this.age = age; 29 } 30 } 31 32 ------------------------------------------- 33 // 对象 34 /* 35 题目： 36 定义一个数组，用来存储3个Person对象。 37 38 数组有一个缺点：一旦建立，程序运行期间长度不能够发生改变。 39 */ 40 public class Demo01Array { 41 42 public static void main(String[] args) { 43 // 首先建立一个长度为3的数组，里面用来存放Person类型的对象 44 Person[] array = new Person[3]; 45 46 Person one = new Person("迪丽热巴", 18); 47 Person two = new Person("古力娜扎", 28); 48 Person three = new Person("玛尔扎哈", 38); 49 50 // 将one当中的地址值赋值到数组的0号元素位置 51 array[0] = one; 52 array[1] = two; 53 array[2] = three; 54 55 System.out.println(array[0]); // 地址值 56 System.out.println(array[1]); // 地址值 57 System.out.println(array[2]); // 地址值 58 59 System.out.println(array[1].getName()); // 古力娜扎 60 } 61 }
java.util.ArrayList 是大小可变的数组的实现，存储在内的数据称为元素。此类提供一些方法来操做内部存储 的元素。 ArrayList 中可不断添加元素，其大小也自动增加。
使用步骤：
1，查看类：java.util.ArrayList <E> ：该类须要 import导入使后使用。
<E> ，表示一种指定的数据类型，叫作泛型。 E ，取自Element（元素）的首字母。在出现 E 的地方，咱们使 用一种引用数据类型将其替换便可，表示咱们将存储哪一种引用类型的元素。代码以下：ArrayList <String>、ArrayList <People>
2，查看构造方法
public ArrayList() ：构造一个内容为空的集合。
基本格式:ArrayList<String> list = new ArrayList<String>();
在JDK 7后,右侧泛型的尖括号以内能够留空，可是<>仍然要写。简化格式：ArrayList<String> list = new ArrayList<>();
3，查当作员方法
public boolean add(E e) ： 将指定的元素添加到此集合的尾部。 参数 E e ，在构造ArrayList对象时， <E> 指定了什么数据类型，那么 add(E e) 方法中，只能添加什么数据 类型的对象。
1 import java.util.ArrayList; 2 /* 3 数组的长度不能够发生改变。 4 可是ArrayList集合的长度是能够随意变化的。 5 6 对于ArrayList来讲，有一个尖括号<E>表明泛型。 7 泛型：也就是装在集合当中的全部元素，全都是统一的什么类型。 8 注意：泛型只能是引用类型，不能是基本类型。 9 10 注意事项： 11 对于ArrayList集合来讲，直接打印获得的不是地址值，而是内容。 12 若是内容是空，获得的是空的中括号：[] 13 */ 14 public class Demo02ArrayList { 15 16 public static void main(String[] args) { 17 // 建立了一个ArrayList集合，集合的名称是list，里面装的全都是String字符串类型的数据 18 // 备注：从JDK 1.7+开始，右侧的尖括号内部能够不写内容，可是<>自己仍是要写的。 19 ArrayList<String> list = new ArrayList<>(); 20 System.out.println(list); // [] 21 22 // 向集合当中添加一些数据，须要用到add方法。 23 list.add("赵丽颖"); 24 System.out.println(list); // [赵丽颖] 25 26 list.add("迪丽热巴"); 27 list.add("古力娜扎"); 28 list.add("玛尔扎哈"); 29 System.out.println(list); // [赵丽颖, 迪丽热巴, 古力娜扎, 玛尔扎哈] 30 31 // list.add(100); // 错误写法！由于建立的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行 32 } 33 }
经常使用方法：
public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值表明添加是否成功。
备注：对于ArrayList集合来讲，add添加动做必定是成功的，因此返回值可用可不用。
可是对于其余集合（从此学习）来讲，add添加动做不必定成功。
public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。
1 import java.util.ArrayList; 2 3 /* 4 ArrayList当中的经常使用方法有： 5 6 public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值表明添加是否成功。 7 备注：对于ArrayList集合来讲，add添加动做必定是成功的，因此返回值可用可不用。 8 可是对于其余集合（从此学习）来讲，add添加动做不必定成功。 9 10 public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。 11 12 public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。 13 14 public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。 15 */ 16 public class Demo03ArrayListMethod { 17 18 public static void main(String[] args) { 19 ArrayList<String> list = new ArrayList<>(); 20 System.out.println(list); // [] 21 22 // 向集合中添加元素：add 23 boolean success = list.add("柳岩"); 24 System.out.println(list); // [柳岩] 25 System.out.println("添加的动做是否成功：" + success); // true 26 27 list.add("高圆圆"); 28 list.add("赵又廷"); 29 list.add("李小璐"); 30 list.add("贾乃亮"); 31 System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮] 32 33 // 从集合中获取元素：get。索引值从0开始 34 String name = list.get(2); 35 System.out.println("第2号索引位置：" + name); // 赵又廷 36 37 // 从集合中删除元素：remove。索引值从0开始。 38 String whoRemoved = list.remove(3); 39 System.out.println("被删除的人是：" + whoRemoved); // 李小璐 40 System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮] 41 42 // 获取集合的长度尺寸，也就是其中元素的个数 43 int size = list.size(); 44 System.out.println("集合的长度是：" + size); 45 } 46 }
1 import java.util.ArrayList; 2 3 public class Demo04ArrayListEach { 4 5 public static void main(String[] args) { 6 ArrayList<String> list = new ArrayList<>(); 7 list.add("迪丽热巴"); 8 list.add("古力娜扎"); 9 list.add("玛尔扎哈"); 10 11 // 遍历集合 12 for (int i = 0; i < list.size(); i++) { 13 System.out.println(list.get(i)); 14 } 15 } 16 }
基本类型和包装类
为何引入包装类：若是但愿向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。
从JDK 1.5+开始，支持自动装箱、自动拆箱。
自动装箱：基本类型 --> 包装类型
自动拆箱：包装类型 --> 基本类型
1 import java.util.ArrayList; 2 3 /* 4 若是但愿向集合ArrayList当中存储基本类型数据，必须使用基本类型对应的“包装类”。 5 6 基本类型 包装类（引用类型，包装类都位于java.lang包下） 7 byte Byte 8 short Short 9 int Integer 【特殊】 10 long Long 11 float Float 12 double Double 13 char Character 【特殊】 14 boolean Boolean 15 16 从JDK 1.5+开始，支持自动装箱、自动拆箱。 17 18 自动装箱：基本类型 --> 包装类型 19 自动拆箱：包装类型 --> 基本类型 20 */ 21 public class Demo05ArrayListBasic { 22 23 public static void main(String[] args) { 24 ArrayList<String> listA = new ArrayList<>(); 25 // 错误写法！泛型只能是引用类型，不能是基本类型 26 // ArrayList<int> listB = new ArrayList<>(); 27 28 ArrayList<Integer> listC = new ArrayList<>(); 29 listC.add(100); 30 listC.add(200); 31 System.out.println(listC); // [100, 200] 32 33 int num = listC.get(1); 34 System.out.println("第1号元素是：" + num);// 200 35 } 36 }
ArrayList的使用示例
使用ArrayList存储自定义对象
1 // 自定义对象 2 public class Student { 3 4 private String name; 5 private int age; 6 7 public Student() { 8 } 9 10 public Student(String name, int age) { 11 this.name = name; 12 this.age = age; 13 } 14 15 public String getName() { 16 return name; 17 } 18 19 public void setName(String name) { 20 this.name = name; 21 } 22 23 public int getAge() { 24 return age; 25 } 26 27 public void setAge(int age) { 28 this.age = age; 29 } 30 } 31 32 33 34 ----------------------------------------- 35 package g.demo05; 36 37 import java.util.ArrayList; 38 39 /* 40 题目： 41 自定义4个学生对象，添加到集合，并遍历。 42 43 思路： 44 1. 自定义Student学生类，四个部分。 45 2. 建立一个集合，用来存储学生对象。泛型：<Student> 46 3. 根据类，建立4个学生对象。 47 4. 将4个学生对象添加到集合中：add 48 5. 遍历集合：for、size、get 49 */ 50 public class Demo02ArrayListStudent { 51 52 public static void main(String[] args) { 53 ArrayList<Student> list = new ArrayList<>(); 54 55 Student one = new Student("洪七公", 20); 56 Student two = new Student("欧阳锋", 21); 57 Student three = new Student("黄药师", 22); 58 Student four = new Student("段智兴", 23); 59 60 list.add(one); 61 list.add(two); 62 list.add(three); 63 list.add(four); 64 65 // 遍历集合 66 for (int i = 0; i < list.size(); i++) { 67 Student stu = list.get(i); 68 System.out.println("姓名：" + stu.getName() + "，年龄" + stu.getAge()); 69 } 70 } 71 }
使用ArrayList做为方法的参数和返回值
1 import java.util.ArrayList; 2 import java.util.Random; 3 /* 4 题目： 5 用一个大集合存入20个随机数字，而后筛选其中的偶数元素，放到小集合当中。 6 要求使用自定义的方法来实现筛选。 7 8 分析： 9 1. 须要建立一个大集合，用来存储int数字：<Integer> 10 2. 随机数字就用Random nextInt 11 3. 循环20次，把随机数字放入大集合：for循环、add方法 12 4. 定义一个方法，用来进行筛选。 13 筛选：根据大集合，筛选符合要求的元素，获得小集合。 14 三要素 15 返回值类型：ArrayList小集合（里面元素个数不肯定） 16 方法名称：getSmallList 17 参数列表：ArrayList大集合（装着20个随机数字） 18 5. 判断（if）是偶数：num % 2 == 0 19 6. 若是是偶数，就放到小集合当中，不然不放。 20 */ 21 public class Demo04ArrayListReturn { 22 23 public static void main(String[] args) { 24 ArrayList<Integer> bigList = new ArrayList<>(); 25 Random r = new Random(); 26 for (int i = 0; i < 20; i++) { 27 int num = r.nextInt(100) + 1; // 1~100 28 bigList.add(num); 29 } 30 31 ArrayList<Integer> smallList = getSmallList(bigList); 32 33 System.out.println("偶数总共有多少个：" + smallList.size()); 34 for (int i = 0; i < smallList.size(); i++) { 35 System.out.println(smallList.get(i)); 36 } 37 } 38 39 // 这个方法，接收大集合参数，返回小集合结果 40 public static ArrayList<Integer> getSmallList(ArrayList<Integer> bigList) { 41 // 建立一个小集合，用来装偶数结果 42 ArrayList<Integer> smallList = new ArrayList<>(); 43 for (int i = 0; i < bigList.size(); i++) { 44 int num = bigList.get(i); 45 if (num % 2 == 0) { 46 smallList.add(num); 47 } 48 } 49 return smallList; 50 } 51 }
String类
java.lang.String 类表明字符串。Java程序中全部的字符串文字（例如 "abc" ）均可以被看做是实现此类的实例。
String 类中包括用于检查各个字符串的方法，好比用于比较字符串，搜索字符串，提取子字符串以及建立具备翻 译为大写或小写的全部字符的字符串的副本。
String类的特色
1. 字符串不变：字符串的值在建立后不能被更改。
2. 由于String对象是不可变的，因此它们能够被共享
3. "abc" 等效于 char[] data={ 'a' , 'b' , 'c' }
String的使用步骤
1，查看类 java.lang.String ：此类不须要导入。
2，查看构造方法
三种构造方法：
1，public String()：建立一个空白字符串，不含有任何内容。
2，public String(char[ ] array)：根据字符数组的内容，来建立对应的字符串。
3，public String(byte[ ] array)：根据字节数组的内容，来建立对应的字符串。
4，另外，还有一种不须要使用构造方法来建立对象：String str = "Hello"; // 右边直接用双引号
注意：
直接写上双引号，就是字符串对象。
字符串常量池：程序当中直接写上的双引号字符串，就在字符串常量池中。
1 /* 2 建立字符串的常见3+1种方式。 3 三种构造方法： 4 public String()：建立一个空白字符串，不含有任何内容。 5 public String(char[] array)：根据字符数组的内容，来建立对应的字符串。 6 public String(byte[] array)：根据字节数组的内容，来建立对应的字符串。 7 一种直接建立： 8 String str = "Hello"; // 右边直接用双引号 9 10 注意：直接写上双引号，就是字符串对象。 11 */ 12 public class Demo01String { 13 14 public static void main(String[] args) { 15 // 使用空参构造 16 String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。 17 System.out.println("第1个字符串：" + str1); 18 19 // 根据字符数组建立字符串 20 char[] charArray = { 'A', 'B', 'C' }; 21 String str2 = new String(charArray); 22 System.out.println("第2个字符串：" + str2); 23 24 // 根据字节数组建立字符串 25 byte[] byteArray = { 97, 98, 99 }; 26 String str3 = new String(byteArray); 27 System.out.println("第3个字符串：" + str3); 28 29 // 直接建立 30 String str4 = "Hello"; 31 System.out.println("第4个字符串：" + str4); 32 } 33 34 }
方法：
1，判断内容的方法
public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。
为何引入这两个方法不使用 == 进行判断
对于基本类型来讲，==是进行数值的比较。
对于引用类型来讲，==是进行【地址值】的比较。
1 /* 2 ==是进行对象的地址值比较，若是确实须要字符串的内容比较，可使用两个方法： 3 4 public boolean equals(Object obj)：参数能够是任何对象，只有参数是一个字符串而且内容相同的才会给true；不然返回false。 5 注意事项： 6 1. 任何对象都能用Object进行接收。 7 2. equals方法具备对称性，也就是a.equals(b)和b.equals(a)效果同样。 8 3. 若是比较双方一个常量一个变量，推荐把常量字符串写在前面。 9 推荐："abc".equals(str) 不推荐：str.equals("abc") 10 11 public boolean equalsIgnoreCase(String str)：忽略大小写，进行内容比较。 12 */ 13 public class Demo01StringEquals { 14 15 public static void main(String[] args) { 16 String str1 = "Hello"; 17 String str2 = "Hello"; 18 char[] charArray = {'H', 'e', 'l', 'l', 'o'}; 19 String str3 = new String(charArray); 20 21 System.out.println(str1.equals(str2)); // true 22 System.out.println(str2.equals(str3)); // true 23 System.out.println(str3.equals("Hello")); // true 24 System.out.println("Hello".equals(str1)); // true 25 26 String str4 = "hello"; 27 System.out.println(str1.equals(str4)); // false 28 System.out.println("================="); 29 30 String str5 = null; 31 System.out.println("abc".equals(str5)); // 推荐：false 32 // System.out.println(str5.equals("abc")); // 不推荐：报错，空指针异常NullPointerException 33 System.out.println("================="); 34 35 String strA = "Java"; 36 String strB = "java"; 37 System.out.println(strA.equals(strB)); // false，严格区分大小写 38 System.out.println(strA.equalsIgnoreCase(strB)); // true，忽略大小写 39 40 // 注意，只有英文字母区分大小写，其余都不区分大小写 41 System.out.println("abc一123".equalsIgnoreCase("abc壹123")); // false 42 } 43 }
2，获取功能的方法
public int length()：获取字符串当中含有的字符个数，拿到字符串长度。
public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。
public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。）
public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，若是没有返回-1值。
1 /* 2 String当中与获取相关的经常使用方法有： 3 4 public int length()：获取字符串当中含有的字符个数，拿到字符串长度。 5 public String concat(String str)：将当前字符串和参数字符串拼接成为返回值新的字符串。 6 public char charAt(int index)：获取指定索引位置的单个字符。（索引从0开始。） 7 public int indexOf(String str)：查找参数字符串在本字符串当中首次出现的索引位置，若是没有返回-1值。 8 */ 9 public class Demo02StringGet { 10 11 public static void main(String[] args) { 12 // 获取字符串的长度 13 int length = "asdasfeutrvauevbueyvb".length(); 14 System.out.println("字符串的长度是：" + length); 15 16 // 拼接字符串 17 String str1 = "Hello"; 18 String str2 = "World"; 19 String str3 = str1.concat(str2); 20 System.out.println(str1); // Hello，原封不动 21 System.out.println(str2); // World，原封不动 22 System.out.println(str3); // HelloWorld，新的字符串 23 System.out.println("=============="); 24 25 // 获取指定索引位置的单个字符 26 char ch = "Hello".charAt(1); 27 System.out.println("在1号索引位置的字符是：" + ch); 28 System.out.println("=============="); 29 30 // 查找参数字符串在原本字符串当中出现的第一次索引位置 31 // 若是根本没有，返回-1值 32 String original = "HelloWorldHelloWorld"; 33 int index = original.indexOf("llo"); 34 System.out.println("第一次索引值是：" + index); // 2 35 36 System.out.println("HelloWorld".indexOf("abc")); // -1 37 } 38 }
public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。
public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。备注：[begin,end)，包含左边，不包含右边。
1 /* 2 字符串的截取方法： 3 public String substring(int index)：截取从参数位置一直到字符串末尾，返回新字符串。 4 public String substring(int begin, int end)：截取从begin开始，一直到end结束，中间的字符串。 5 备注：[begin,end)，包含左边，不包含右边。 6 */ 7 public class Demo03Substring { 8 9 public static void main(String[] args) { 10 String str1 = "HelloWorld"; 11 String str2 = str1.substring(5); 12 System.out.println(str1); // HelloWorld，原封不动 13 System.out.println(str2); // World，新字符串 14 System.out.println("================"); 15 16 String str3 = str1.substring(4, 7); 17 System.out.println(str3); // oWo 18 System.out.println("================"); 19 20 // 下面这种写法，字符串的内容仍然是没有改变的 21 // 下面有两个字符串："Hello"，"Java" 22 // strA当中保存的是地址值。 23 // 原本地址值是Hello的0x666， 24 // 后来地址值变成了Java的0x999 25 String strA = "Hello"; 26 System.out.println(strA); // Hello 27 strA = "Java"; 28 System.out.println(strA); // Java 29 } 30 }
3，转换功能的方法
public char[] toCharArray()：将当前字符串拆分红为字符数组做为返回值。
public byte[] getBytes()：得到当前字符串底层的字节数组。
public String replace(CharSequence oldString, CharSequence newString)：将全部出现的老字符串替换成为新的字符串，返回替换以后的结果新字符串。
备注：CharSequence意思就是说能够接受字符串类型。
1 /* 2 String当中与转换相关的经常使用方法有： 3 4 public char[] toCharArray()：将当前字符串拆分红为字符数组做为返回值。 5 public byte[] getBytes()：得到当前字符串底层的字节数组。 6 public String replace(CharSequence oldString, CharSequence newString)： 7 将全部出现的老字符串替换成为新的字符串，返回替换以后的结果新字符串。 8 备注：CharSequence意思就是说能够接受字符串类型。 9 */ 10 public class Demo04StringConvert { 11 12 public static void main(String[] args) { 13 // 转换成为字符数组 14 char[] chars = "Hello".toCharArray(); 15 System.out.println(chars[0]); // H 16 System.out.println(chars.length); // 5 17 System.out.println("=============="); 18 19 // 转换成为字节数组 20 byte[] bytes = "abc".getBytes(); 21 for (int i = 0; i < bytes.length; i++) { 22 System.out.println(bytes[i]); 23 } 24 System.out.println("=============="); 25 26 // 字符串的内容替换 27 String str1 = "How do you do?"; 28 String str2 = str1.replace("o", "*"); 29 System.out.println(str1); // How do you do? 30 System.out.println(str2); // H*w d* y*u d*? 31 System.out.println("=============="); 32 33 String lang1 = "会不会玩儿呀！你大爷的！你大爷的！你大爷的！！！"; 34 String lang2 = lang1.replace("你大爷的", "****"); 35 System.out.println(lang2); // 会不会玩儿呀！****！****！****！！！ 36 } 37 }
4，分隔功能的方法
public String[] split(String regex)：按照参数的规则，将字符串切分红为若干部分。
注意事项：
split方法的参数实际上是一个“正则表达式”。
今天要注意：若是按照英文句点“.”进行切分，必须写"\\."（两个反斜杠）
1 /* 2 分割字符串的方法： 3 public String[] split(String regex)：按照参数的规则，将字符串切分红为若干部分。 4 5 注意事项： 6 split方法的参数实际上是一个“正则表达式”，从此学习。 7 今天要注意：若是按照英文句点“.”进行切分，必须写"\\."（两个反斜杠） 8 */ 9 public class Demo05StringSplit { 10 11 public static void main(String[] args) { 12 String str1 = "aaa,bbb,ccc"; 13 String[] array1 = str1.split(","); 14 for (int i = 0; i < array1.length; i++) { 15 System.out.println(array1[i]); 16 } 17 System.out.println("==============="); 18 19 String str2 = "aaa bbb ccc"; 20 String[] array2 = str2.split(" "); 21 for (int i = 0; i < array2.length; i++) { 22 System.out.println(array2[i]); 23 } 24 System.out.println("==============="); 25 26 String str3 = "XXX.YYY.ZZZ"; 27 String[] array3 = str3.split("\\."); 28 System.out.println(array3.length); // 0 29 for (int i = 0; i < array3.length; i++) { 30 System.out.println(array3[i]); 31 } 32 } 33 }
方法的综合使用示例
1 import java.util.Scanner; 2 /* 3 题目： 4 键盘输入一个字符串，而且统计其中各类字符出现的次数。 5 种类有：大写字母、小写字母、数字、其余 6 7 思路： 8 1. 既然用到键盘输入，确定是Scanner 9 2. 键盘输入的是字符串，那么：String str = sc.next(); 10 3. 定义四个变量，分别表明四种字符各自的出现次数。 11 4. 须要对字符串一个字、一个字检查，String-->char[]，方法就是toCharArray() 12 5. 遍历char[]字符数组，对当前字符的种类进行判断，而且用四个变量进行++动做。 13 6. 打印输出四个变量，分别表明四种字符出现次数。 14 */ 15 public class Demo07StringCount { 16 17 public static void main(String[] args) { 18 Scanner sc = new Scanner(System.in); 19 System.out.println("请输入一个字符串："); 20 String input = sc.next(); // 获取键盘输入的一个字符串 21 22 int countUpper = 0; // 大写字母 23 int countLower = 0; // 小写字母 24 int countNumber = 0; // 数字 25 int countOther = 0; // 其余字符 26 27 char[] charArray = input.toCharArray(); 28 for (int i = 0; i < charArray.length; i++) { 29 char ch = charArray[i]; // 当前单个字符 30 if ('A' <= ch && ch <= 'Z') { 31 countUpper++; 32 } else if ('a' <= ch && ch <= 'z') { 33 countLower++; 34 } else if ('0' <= ch && ch <= '9') { 35 countNumber++; 36 } else { 37 countOther++; 38 } 39 } 40 41 System.out.println("大写字母有：" + countUpper); 42 System.out.println("小写字母有：" + countLower); 43 System.out.println("数字有：" + countNumber); 44 System.out.println("其余字符有：" + countOther); 45 } 46 }
Arrays类
java.util.Arrays 此类包含用来操做数组的各类方法，好比排序和搜索等。其全部方法均为静态方法，调用起来很是简单
方法：
1，public static String toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
2，public static void sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。
sort方法使用注意：
1. 若是是数值，sort默认按照升序从小到大
2. 若是是字符串，sort默认按照字母升序
3. 若是是自定义的类型，那么这个自定义的类须要有Comparable或者Comparator接口的支持。
1 import java.util.Arrays; 2 3 public class Demo01Arrays { 4 5 public static void main(String[] args) { 6 int[] intArray = {10, 20, 30}; 7 // 将int[]数组按照默认格式变成字符串 8 String intStr = Arrays.toString(intArray); 9 System.out.println(intStr); // [10, 20, 30] 10 11 int[] array1 = {2, 1, 3, 10, 6}; 12 Arrays.sort(array1); 13 System.out.println(Arrays.toString(array1)); // [1, 2, 3, 6, 10] 14 15 String[] array2 = {"bbb", "aaa", "ccc"}; 16 Arrays.sort(array2); 17 System.out.println(Arrays.toString(array2)); // [aaa, bbb, ccc] 18 } 19 }
练习：请使用Arrays相关的API，将一个随机字符串中的全部字符升序排列，并倒序打印。
1 import java.util.Arrays; 2 3 /* 4 题目： 5 请使用Arrays相关的API，将一个随机字符串中的全部字符升序排列，并倒序打印。 6 */ 7 public class Demo02ArraysPractise { 8 9 public static void main(String[] args) { 10 String str = "asv76agfqwdfvasdfvjh"; 11 12 // 如何进行升序排列：sort 13 // 必须是一个数组，才能用Arrays.sort方法 14 // String --> 数组，用toCharArray 15 char[] chars = str.toCharArray(); 16 Arrays.sort(chars); // 对字符数组进行升序排列 17 18 // 须要倒序遍历 19 for (int i = chars.length - 1; i >= 0; i--) { 20 System.out.println(chars[i]); 21 } 22 } 23 }
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)：四舍五入。
Math.PI表明近似的圆周率常量（double）。
1 public class Demo03Math { 2 3 public static void main(String[] args) { 4 // 获取绝对值 5 System.out.println(Math.abs(3.14)); // 3.14 6 System.out.println(Math.abs(0)); // 0 7 System.out.println(Math.abs(-2.5)); // 2.5 8 System.out.println("================"); 9 10 // 向上取整 11 System.out.println(Math.ceil(3.9)); // 4.0 12 System.out.println(Math.ceil(3.1)); // 4.0 13 System.out.println(Math.ceil(3.0)); // 3.0 14 System.out.println("================"); 15 16 // 向下取整，抹零 17 System.out.println(Math.floor(30.1)); // 30.0 18 System.out.println(Math.floor(30.9)); // 30.0 19 System.out.println(Math.floor(31.0)); // 31.0 20 System.out.println("================"); 21 22 System.out.println(Math.round(20.4)); // 20 23 System.out.println(Math.round(10.5)); // 11 24 } 25 }
练习：计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？
1 /* 2 题目： 3 计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个？ 4 5 分析： 6 1. 既然已经肯定了范围，for循环 7 2. 起点位置-10.8应该转换成为-10，两种办法： 8 2.1 可使用Math.ceil方法，向上（向正方向）取整 9 2.2 强转成为int，自动舍弃全部小数位 10 3. 每个数字都是整数，因此步进表达式应该是num++，这样每次都是+1的。 11 4. 如何拿到绝对值：Math.abs方法。 12 5. 一旦发现了一个数字，须要让计数器++进行统计。 13 14 备注：若是使用Math.ceil方法，-10.8能够变成-10.0。注意double也是能够进行++的。 15 */ 16 public class Demo04MathPractise { 17 18 public static void main(String[] args) { 19 int count = 0; // 符合要求的数量 20 21 double min = -10.8; 22 double max = 5.9; 23 // 这样处理，变量i就是区间以内全部的整数 24 for (int i = (int) min; i < max; i++) { 25 int abs = Math.abs(i); // 绝对值 26 if (abs > 6 || abs < 2.1) { 27 System.out.println(i); 28 count++; 29 } 30 } 31 32 System.out.println("总共有：" + count); // 9 33 } 34 }
Object类
1 public class MyClass /*extends Object*/ { 2 // ... 3 }
方法：
public String toString()：返回该对象的字符串表示。
public boolean equals(Object obj)：指示其余某个对象是否与此对象“相等”。
其他方法查API
toString方法
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
因为toString方法返回的结果是内存地址，而在开发中，常常须要按照对象的属性获得相应的字符串表现形式，所以也须要重写它。
在咱们直接使用输出语句输出对象名的时候,其实经过该对象调用了其toString()方法。
重写toString方法
1 import java.util.Objects; 2 3 public class Person { 4 private String name; 5 private int age; 6 7 public Person() { 8 } 9 10 public Person(String name, int age) { 11 this.name = name; 12 this.age = age; 13 } 14 15 16 /* 17 直接打印对象的地址值没有意义,须要重写Object类中的toString方法 18 打印对象的属性(name,age) 19 */ 20 /*@Override 21 public String toString() { 22 //return "abc"; 23 return "Person{name="+name+" ,age="+age+"}"; 24 }*/ 25 @Override 26 public String toString() { 27 return "Person{" + 28 "name='" + name + '\'' + 29 ", age=" + age + 30 '}'; 31 } 32 33 public String getName() { 34 return name; 35 } 36 37 public void setName(String name) { 38 this.name = name; 39 } 40 41 public int getAge() { 42 return age; 43 } 44 45 public void setAge(int age) { 46 this.age = age; 47 } 48 }
注意：重写toSting方法return任何内容。可是通常返回成员变量。还能够自动重写toString方法。按art+insert选择toString便可，自动重写。
1 package a.demo01; 2 3 import java.util.ArrayList; 4 import java.util.Random; 5 import java.util.Scanner; 6 7 public class Demo01ToString{ 8 public static void main(String[] args) { 9 /* 10 Person类默认继承了Object类,因此可使用Object类中的toString方法 11 String toString() 返回该对象的字符串表示。 12 */ 13 Person p = new Person("张三",18); 14 String s = p.toString(); 15 System.out.println(s);//com.itheima.demo01.Object.Person@75412c2f | abc | Person{name=张三 ,age=18} 16 17 //直接打印对象的名字,其实就是调用对象的toString p=p.toString(); 18 System.out.println(p);//com.itheima.demo01.Object.Person@5f150435 | abc | Person{name=张三 ,age=18} 19 20 //看一个类是否重写了toString,直接打印这个类的对象便可,若是没有重写toString方法那么打印的是对象的地址值 21 Random r = new Random(); 22 System.out.println(r);//java.util.Random@3f3afe78 没有重写toString方法 23 24 Scanner sc = new Scanner(System.in); 25 System.out.println(sc);//java.util.Scanner[delimiters=\p{javaWhitespace}+.. 重写toString方法 26 27 ArrayList<Integer> list = new ArrayList<>(); 28 list.add(1); 29 list.add(2); 30 list.add(3); 31 System.out.println(list);//[1, 2, 3] 重写toString方法 32 } 33 }
equals方法
public boolean equals(Object obj)`：指示其余某个对象是否与此对象“相等”。
调用成员方法equals并指定参数为另外一个对象，则能够判断这两个对象是不是相同的。这里的“相同”有默认和自定义两种方式。
默认地址比较
对象内容比较
若是但愿进行对象的内容比较，即全部或指定的部分红员变量相同就断定两个对象相同，则能够覆盖重写equals方法。
1 package a.demo01; 2 3 import java.util.Objects; 4 5 public class Person { 6 private String name; 7 private int age; 8 9 public Person() { 10 } 11 12 public Person(String name, int age) { 13 this.name = name; 14 this.age = age; 15 } 16 17 /* 18 Object类的equals方法,默认比较的是两个对象的地址值,没有意义 19 因此咱们要重写equals方法,比较两个对象的属性(name,age) 20 问题: 21 隐含着一个多态 22 多态的弊端:没法使用子类特有的内容(属性和方法) 23 Object obj = p2 = new Person("古力娜扎",19); 24 解决:可使用向下转型(强转)把obj类型转换为Person 25 */ 26 27 28 // 本身重写的equals方法 29 /*@Override 30 public boolean equals(Object obj) { 31 //增长一个判断,传递的参数obj若是是this自己,直接返回true,提升程序的效率 32 if(obj==this){ 33 return true; 34 } 35 36 //增长一个判断,传递的参数obj若是是null,直接返回false,提升程序的效率 37 if(obj==null){ 38 return false; 39 } 40 41 //增长一个判断,防止类型转换一次ClassCastException 42 if(obj instanceof Person){ 43 //使用向下转型,把obj转换为Person类型 44 // 由于有多态，这里须要向下转型 45 Person p = (Person)obj; 46 //比较两个对象的属性,一个对象是this(p1),一个对象是p(obj->p2) 47 boolean b = this.name.equals(p.name) && this.age==p.age; 48 return b; 49 } 50 //不是Person类型直接返回false 51 return false; 52 }*/ 53 54 // 使用编辑器自动插入的equals方法 55 @Override 56 public boolean equals(Object o) { 57 if (this == o) return true; 58 if (o == null || getClass() != o.getClass()) return false; 59 Person person = (Person) o; 60 return age == person.age && 61 Objects.equals(name, person.name); 62 } 63 64 @Override 65 public int hashCode() { 66 67 return Objects.hash(name, age); 68 } 69 70 public String getName() { 71 return name; 72 } 73 74 public void setName(String name) { 75 this.name = name; 76 } 77 78 public int getAge() { 79 return age; 80 } 81 82 public void setAge(int age) { 83 this.age = age; 84 } 85 } 86
Objects类
在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？
在JDK7
在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法以下：
public static boolean equals(Object a, Object b):判断两个对象是否相等。
Objects类中equals方法源码：
1 public static boolean equals(Object a, Object b) { 2 return (a == b) || (a != null && a.equals(b)); 3 }
时间日期类
Date类
java.util.Date类 表示特定的瞬间，精确到毫秒。
继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已通过时，可是其中有未过期的构造函数能够把毫秒值转成日期对象。
构造方法：
public Date(long date)
1 import java.util.Date; 2 3 public class Demo02Date { 4 public static void main(String[] args) { 5 demo01(); 6 demo02(); 7 } 8 9 /* 10 Date类的带参数构造方法 11 Date(long date) :传递毫秒值,把毫秒值转换为Date日期 12 */ 13 private static void demo02() { 14 Date date = new Date(0L); 15 System.out.println(date);// Thu Jan 01 08:00:00 CST 1970 16 17 date = new Date(3742767540068L); 18 System.out.println(date);// Sun Aug 08 09:39:00 CST 2088 19 } 20 21 /* 22 Date类的空参数构造方法 23 Date() 获取当前系统的日期和时间 24 */ 25 private static void demo01() { 26 Date date = new Date(); 27 System.out.println(date);//Sun Aug 08 12:23:03 CST 2088 28 } 29 }
注意：在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，因此结果为指定格式的字符串。
经常使用方法：
1 import java.util.Date; 2 3 public class Demo02Date { 4 public static void main(String[] args) { 5 demo01(); 6 7 8 // System.currentTimeMillis()方法 9 System.out.println(System.currentTimeMillis());//获取当前系统时间到1970 年 1 月 1 日 00:00:00经历了多少毫秒 10 } 11 12 /* 13 long getTime() 把日期转换为毫秒值(至关于System.currentTimeMillis()方法) 14 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。 15 */ 16 private static void demo03() { 17 Date date = new Date(); 18 long time = date.getTime(); 19 System.out.println(time);//3742777636267 20 } 21 }
DateFormat类
解析
因为DateFormat为抽象类，不能直接使用，因此须要经常使用的子类java.text.SimpleDateFormat。这个类须要一个模式（格式）来指定格式化或解析的标准。
构造方法为：
public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，表明日期时间的自定义格式。
| 含义 | |
|---|---|
| y | 年 |
| M | 月 |
| d | 日 |
| H | 时 |
| m | 分 |
| s |
成员方法:
String format(Date date) 按照指定的模式,把Date日期,格式化为符合模式的字符串
1 package a.demo03; 2 3 import java.text.SimpleDateFormat; 4 import java.util.Date; 5 6 public class Demo01DateFormat { 7 public static void main(String[] args) throws ParseException { 8 demo02(); 9 } 10 11 /* 12 使用DateFormat类中的方法format,把日期格式化为文本 13 使用步骤: 14 1.建立SimpleDateFormat对象,构造方法中传递指定的模式 15 2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本) 16 */ 17 private static void demo01() { 18 //1.建立SimpleDateFormat对象,构造方法中传递指定的模式 19 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒"); 20 //2.调用SimpleDateFormat对象中的方法format,按照构造方法中指定的模式,把Date日期格式化为符合模式的字符串(文本) 21 //String format(Date date) 按照指定的模式,把Date日期,格式化为符合模式的字符串 22 Date date = new Date(); 23 String d = sdf.format(date); 24 System.out.println(date);//Sun Aug 08 15:51:54 CST 2088 25 System.out.println(d);//2088年08月08日 15时51分54秒 26 } 27 }
Date parse(String source) 把符合模式的字符串,解析为Date日期
1 import java.text.ParseException; 2 import java.text.SimpleDateFormat; 3 import java.util.Date; 4 5 public class Demo01DateFormat { 6 public static void main(String[] args) throws ParseException { 7 demo02(); 8 } 9 10 /* 11 使用DateFormat类中的方法parse,把文本解析为日期 12 使用步骤: 13 1.建立SimpleDateFormat对象,构造方法中传递指定的模式 14 2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期 15 注意: 16 public Date parse(String source) throws ParseException 17 parse方法声明了一个异常叫ParseException 18 若是字符串和构造方法的模式不同,那么程序就会抛出此异常 19 调用一个抛出了异常的方法,就必须的处理这个异常,要么throws继续抛出这个异常,要么try catch本身处理 20 */ 21 private static void demo02() throws ParseException { 22 //1.建立SimpleDateFormat对象,构造方法中传递指定的模式 23 SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒"); 24 25 //2.调用SimpleDateFormat对象中的方法parse,把符合构造方法中模式的字符串,解析为Date日期 26 //Date parse(String source) 把符合模式的字符串,解析为Date日期 27 Date date = sdf.parse("2088年08月08日 15时51分54秒"); 28 29 System.out.println(date); 30 } 31 32 }
Calendar类
Calendar类没法直接建立对象使用,里边有一个静态方法叫getInstance(),该方法返回了Calendar类的子类对象
static Calendar getInstance() 使用默认时区和语言环境得到一个日历。
1 public static void main(String[] args) { 2 Calendar c = Calendar.getInstance();//多态 3 System.out.println(c); 4 }
经常使用方法
public int get(int field)：返回给定日历字段的值。
1 import java.util.Calendar; 2 import java.util.Date; 3 4 public class Demo02Calendar { 5 public static void main(String[] args) { 6 demo04(); 7 } 8 9 /* 10 public int get(int field)：返回给定日历字段的值。 11 参数:传递指定的日历字段(YEAR,MONTH...) 12 返回值:日历字段表明的具体的值 13 */ 14 private static void demo01() { 15 //使用getInstance方法获取Calendar对象 16 Calendar c = Calendar.getInstance(); 17 18 int year = c.get(Calendar.YEAR); 19 System.out.println(year); 20 21 int month = c.get(Calendar.MONTH); 22 System.out.println(month);//西方的月份0-11 东方:1-12 23 24 //int date = c.get(Calendar.DAY_OF_MONTH); 25 int date = c.get(Calendar.DATE); 26 System.out.println(date); 27 } 28 }
public void set(int field, int value)：将给定的日历字段设置为给定值。
1 import java.util.Calendar; 2 import java.util.Date; 3 4 public class Demo02Calendar { 5 public static void main(String[] args) { 6 demo02(); 7 } 8 9 10 /* 11 public void set(int field, int value)：将给定的日历字段设置为给定值。 12 参数: 13 int field:传递指定的日历字段(YEAR,MONTH...) 14 int value:给指定字段设置的值 15 */ 16 private static void demo02() { 17 //使用getInstance方法获取Calendar对象 18 Calendar c = Calendar.getInstance(); 19 20 //设置年为9999 21 c.set(Calendar.YEAR,9999); 22 //设置月为9月 23 c.set(Calendar.MONTH,9); 24 //设置日9日 25 c.set(Calendar.DATE,9); 26 27 //同时设置年月日,可使用set的重载方法 28 c.set(8888,8,8); 29 30 int year = c.get(Calendar.YEAR); 31 System.out.println(year);// 8888 32 33 int month = c.get(Calendar.MONTH); 34 System.out.println(month);//8 西方的月份0-11 东方:1-12 35 36 int date = c.get(Calendar.DATE); 37 System.out.println(date);// 8 38 } 39 }
public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。
1 import java.util.Calendar; 2 import java.util.Date; 3 4 public class Demo02Calendar { 5 public static void main(String[] args) { 6 demo03(); 7 } 8 9 10 /* 11 public abstract void add(int field, int amount)：根据日历的规则，为给定的日历字段添加或减去指定的时间量。 12 把指定的字段增长/减小指定的值 13 参数: 14 int field:传递指定的日历字段(YEAR,MONTH...) 15 int amount:增长/减小指定的值 16 正数:增长 17 负数:减小 18 */ 19 private static void demo03() { 20 //使用getInstance方法获取Calendar对象 21 Calendar c = Calendar.getInstance(); 22 23 //把年增长2年 24 c.add(Calendar.YEAR,2); 25 //把月份减小3个月 26 c.add(Calendar.MONTH,-3); 27 28 29 int year = c.get(Calendar.YEAR); 30 System.out.println(year);//当前年增长2年 31 32 int month = c.get(Calendar.MONTH); 33 System.out.println(month);//当前月减小三个月 西方的月份0-11 东方:1-12 34 35 //int date = c.get(Calendar.DAY_OF_MONTH); 36 int date = c.get(Calendar.DATE); 37 System.out.println(date);// 当前天 38 } 39 }
public Date getTime()：返回一个表示此Calendar时间值（从历元到如今的毫秒偏移量）的Date对象。
1 import java.util.Calendar; 2 import java.util.Date; 3 4 public class Demo02Calendar { 5 public static void main(String[] args) { 6 demo04(); 7 } 8 9 /* 10 public Date getTime()：返回一个表示此Calendar时间值（从历元到如今的毫秒偏移量）的Date对象。 11 把日历对象,转换为日期对象 12 */ 13 private static void demo04() { 14 //使用getInstance方法获取Calendar对象 15 Calendar c = Calendar.getInstance(); 16 17 Date date = c.getTime(); 18 System.out.println(date);// Thu Apr 23 16:33:47 CST 2020 19 } 20 21 }
Calendar类中提供不少成员常量，表明给定的日历字段：
| 含义 | |
|---|---|
| YEAR | 年 |
| MONTH | 月（从0开始，能够+1使用） |
| DAY_OF_MONTH/DATE | 月中的天（几号） |
| HOUR | 时（12小时制） |
| HOUR_OF_DAY | 时（24小时制） |
| MINUTE | 分 |
| SECOND | 秒 |
| DAY_OF_WEEK |
System类
1 public static void main(String[] args) { 2 System.out.println(System.currentTimeMillis());//获取当前系统时间到1970 年 1 月 1 日 00:00:00经历了多少毫秒 3 }
public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
| 参数名称 | 参数类型 | 参数含义 | |
|---|---|---|---|
| 1 | src | Object | 源数组 |
| 2 | srcPos | int | 源数组索引发始位置 |
| 3 | dest | Object | 目标数组 |
| 4 | destPos | int | 目标数组索引发始位置 |
| 5 | length | int |
1 import java.util.Arrays; 2 3 public class Demo01System { 4 public static void main(String[] args) { 5 demo02(); 6 } 7 8 /* 9 练习: 10 将src数组中前3个元素，复制到dest数组的前3个位置上 11 复制元素前： 12 src数组元素[1,2,3,4,5]，dest数组元素[6,7,8,9,10] 13 复制元素后： 14 src数组元素[1,2,3,4,5]，dest数组元素[1,2,3,9,10] 15 */ 16 private static void demo02() { 17 //定义源数组 18 int[] src = {1,2,3,4,5}; 19 //定义目标数组 20 int[] dest = {6,7,8,9,10}; 21 System.out.println("复制前:"+ Arrays.toString(dest)); 22 23 //使用System类中的arraycopy把源数组的前3个元素复制到目标数组的前3个位置上 24 System.arraycopy(src,0,dest,0,3); 25 26 System.out.println("复制后:"+ Arrays.toString(dest)); 27 } 28 29 }
StringBuilder类
java.lang.StringBuilder类:字符串缓冲区,能够提升字符串的效率 。
它的内部拥有一个数组用来存放字符串内容，进行字符串拼接时，直接在数组中加入新内容。StringBuilder会自动维护数组的扩容。(默认16字符空间，超过自动扩充)
构造方法
public StringBuilder(String str)
1 public static void main(String[] args) { 2 //空参数构造方法 3 StringBuilder bu1 = new StringBuilder(); 4 System.out.println("bu1:"+bu1);//bu1:"" 5 6 //带字符串的构造方法 7 StringBuilder bu2 = new StringBuilder("abc"); 8 System.out.println("bu2:"+bu2);//bu2:abc 9 }
经常使用方法
1 public class Demo02StringBuilder { 2 public static void main(String[] args) { 3 //建立StringBuilder对象 4 StringBuilder bu = new StringBuilder(); 5 //使用append方法往StringBuilder中添加数据 6 //append方法返回的是this,调用方法的对象bu,this==bu 7 8 StringBuilder bu2 = bu.append("abc");//把bu的地址赋值给了bu2 9 System.out.println(bu);//"abc" 10 System.out.println(bu2);//"abc" 11 System.out.println(bu==bu2);//比较的是地址 true 12 13 //使用append方法无需接收返回值 14 bu.append("abc"); 15 bu.append(1); 16 bu.append(true); 17 bu.append(8.8); 18 bu.append('中'); 19 System.out.println(bu);//abc1true8.8中 20 21 //链式编程:方法返回值是一个对象,能够继续调用方法 22 System.out.println("abc".toUpperCase().toLowerCase().toUpperCase().toLowerCase()); 23 bu.append("abc").append(1).append(true).append(8.8).append('中'); 24 System.out.println(bu);//abc1true8.8中 25 26 } 27 }
public String toString()
使用StringBuilder(String str) 构造函数，构造一个字符串生成器，并初始化为指定的字符串内容。能够将String转换为StringBuilder
public String toString()：将当前StringBuilder对象转换为String对象。
1 /* 2 StringBuilder和String能够相互转换: 3 String->StringBuilder:可使用StringBuilder的构造方法 4 StringBuilder(String str) 构造一个字符串生成器，并初始化为指定的字符串内容。 5 StringBuilder->String:可使用StringBuilder中的toString方法 6 public String toString()：将当前StringBuilder对象转换为String对象。 7 */ 8 public class Demo03StringBuilder { 9 public static void main(String[] args) { 10 11 //String->StringBuilder 12 String str = "hello"; 13 System.out.println("str:"+str);//str:hello 14 StringBuilder bu = new StringBuilder(str); 15 16 //往StringBuilder中添加数据 17 bu.append("world"); 18 System.out.println("bu:"+bu);// bu:helloworld 19 20 //StringBuilder->String 21 String s = bu.toString(); 22 System.out.println("s:"+s);// str:helloworld 23 } 24 }
---------------------
相关文章
- 1. java各类经常使用Api之String
- 2. java经常使用API之Calendar类
- 3. Java 之经常使用API（二）
- 4. java经常使用api
- 5. HDFS java经常使用API
- 6. MongoDB java经常使用api
- 7. java-10：经常使用api
- 8. java 经常使用API
- 9. java经常使用API
- 10. Java经常使用API
- 更多相关文章...
- • 在Java程序中使用Redis - Redis教程
- • SQLite 常用函数 - SQLite教程
- • Java Agent入门实战（一）-Instrumentation介绍与使用
- • Java Agent入门实战（三）-JVM Attach原理与使用
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
相关文章
- 1. java各类经常使用Api之String
- 2. java经常使用API之Calendar类
- 3. Java 之经常使用API（二）
- 4. java经常使用api
- 5. HDFS java经常使用API
- 6. MongoDB java经常使用api
- 7. java-10：经常使用api
- 8. java 经常使用API
- 9. java经常使用API
- 10. Java经常使用API