Java 基础知识复习 （四） 常用API
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了Java 基础知识复习 （四） 常用API，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含17389字，纯文字阅读大概需要25分钟。
内容图文
一，常用API（一）
API：
API(Application Programming Interface)，应用程序编程接口。
意思就是说这个是Java的开发人员早就定义好的类，我们只需要用哪个查那个，调用就行
如果不懂某个接口或者类，可以通过API文档搜索进行查看.
1.Scanner类，Random类，Arraylist类
Scanner 一个可以解析基本类型和字符串的简单文本扫描器。
例如，以下代码使用户能够从
System.in 中读取一个数：
通俗来将就是将你从控制台输入的数据，进行保存。
常用方法: nextInt() ：将输入信息的下一个标记扫描为一个 int 值。
注意：1.2.3. ....是使用步骤
1 package cn.itcast.day07.demo01;
2
3 import java.util.Scanner; // 1. 导包
4
5 /*
6 Scanner类的功能：可以实现键盘输入数据，到程序当中。
7
8 引用类型的一般使用步骤：
9
10 1. 导包
11 import 包路径.类名称;
12 如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。
13 只有java.lang包下的内容不需要导包，其他的包都需要import语句。
14
15 2. 创建
16 类名称 对象名 = new 类名称();
17
18 3. 使用
19 对象名.成员方法名()
20
21 获取键盘输入的一个int数字：int num = sc.nextInt();
22 获取键盘输入的一个字符串：String str = sc.next();
23 */
24 public class Demo01Scanner {
25
26 public static void main(String[] args) {
27 // 2. 创建
28 // 备注：System.in代表从键盘进行输入
29 Scanner sc = new Scanner(System.in);
30
31 // 3. 获取键盘输入的int数字
32 int num = sc.nextInt();
33 System.out.println("输入的int数字是：" + num);
34
35 // 4. 获取键盘输入的字符串
36 String str = sc.next();
37 System.out.println("输入的字符串是：" + str);
38 }
39
40 }
Random 此类的实例用于生成伪随机数
生成随机数
常用方法： nextInt(int n) ：返回一个伪随机数，范围在 0 （包括）和 指定值 n
（不包括）之间的int 值。
1 import java.util.Random;
2
3 /*
4 Random类用来生成随机数字。使用起来也是三个步骤：
5
6 1. 导包
7 import java.util.Random;
8
9 2. 创建
10 Random r = new Random(); // 小括号当中留空即可
11
12 3. 使用
13 获取一个随机的int数字（范围是int所有范围，有正负两种）：int num = r.nextInt()
14 获取一个随机的int数字（参数代表了范围，左闭右开区间）：int num = r.nextInt(3)
15 实际上代表的含义是：[0,3)，也就是0~2
16 */
17 public class Demo01Random {
18
19 public static void main(String[] args) {
20 Random r = new Random();
21
22 int num = r.nextInt();
23 System.out.println("随机数是：" + num);
24 }
25
26 }
Arraylist 对象数组
常用方法： 增删改查
add(E e) ：将指定的元素添加到此集合的尾部。
remove(int index) ：移除此集合中指定位置上的元素。返回被删除的元素。
get(int index) ：返回此集合中指定位置上的元素。返回获取的元素。
int size() ：返回此集合中的元素数。遍历集合时，可以控制索引范围，防止越界。
例子
import java.util.ArrayList;
/*
ArrayList当中的常用方法有：
public boolean add(E e)：向集合当中添加元素，参数的类型和泛型一致。返回值代表添加是否成功。
备注：对于ArrayList集合来说，add添加动作一定是成功的，所以返回值可用可不用。
但是对于其他集合（今后学习）来说，add添加动作不一定成功。
public E get(int index)：从集合当中获取元素，参数是索引编号，返回值就是对应位置的元素。
public E remove(int index)：从集合当中删除元素，参数是索引编号，返回值就是被删除掉的元素。
public int size()：获取集合的尺寸长度，返回值是集合中包含的元素个数。
*/
public class Demo03ArrayListMethod {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
System.out.println(list); // []
// 向集合中添加元素：add
boolean success = list.add("柳岩");
System.out.println(list); // [柳岩]
System.out.println("添加的动作是否成功：" + success); // true
list.add("高圆圆");
list.add("赵又廷");
list.add("李小璐");
list.add("贾乃亮");
System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 李小璐, 贾乃亮]
// 从集合中获取元素：get。索引值从0开始
String name = list.get(2);
System.out.println("第2号索引位置：" + name); // 赵又廷
// 从集合中删除元素：remove。索引值从0开始。
String whoRemoved = list.remove(3);
System.out.println("被删除的人是：" + whoRemoved); // 李小璐
System.out.println(list); // [柳岩, 高圆圆, 赵又廷, 贾乃亮]
// 获取集合的长度尺寸，也就是其中元素的个数
int size = list.size();
System.out.println("集合的长度是：" + size);
}
}
使用步骤
1 import java.util.ArrayList;
2
3 /*
4 数组的长度不可以发生改变。
5 但是ArrayList集合的长度是可以随意变化的。
6
7 对于ArrayList来说，有一个尖括号<E>代表泛型。
8 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。
9 注意：泛型只能是引用类型，不能是基本类型。
10
11 注意事项：
12 对于ArrayList集合来说，直接打印得到的不是地址值，而是内容。
13 如果内容是空，得到的是空的中括号：[]
14 */
15 public class Demo02ArrayList {
16
17 public static void main(String[] args) {
18 // 创建了一个ArrayList集合，集合的名称是list，里面装的全都是String字符串类型的数据
19 // 备注：从JDK 1.7+开始，右侧的尖括号内部可以不写内容，但是<>本身还是要写的。
20 ArrayList<String> list = new ArrayList<>();
21 System.out.println(list); // []
22
23 // 向集合当中添加一些数据，需要用到add方法。
24 list.add("赵丽颖");
25 System.out.println(list); // [赵丽颖]
26
27 list.add("迪丽热巴");
28 list.add("古力娜扎");
29 list.add("玛尔扎哈");
30 System.out.println(list); // [赵丽颖, 迪丽热巴, 古力娜扎, 玛尔扎哈]
31
32 // list.add(100); // 错误写法！因为创建的时候尖括号泛型已经说了是字符串，添加进去的元素就必须都是字符串才行
33 }
34
35 }
尖括号<E>代表泛型 泛型：也就是装在集合当中的所有元素，全都是统一的什么类型。 注意：泛型只能是引用类型，不能是基本类型。
2.String类、static关键字、Arrays类、Math类
String 字符串
常用方法：equals 将此字符串与指定对象进行比较。
equalsIgnoreCase 将此字符串与指定对象进行比较，忽略大小写。
length () ：返回此字符串的长度。
concat (String str) ：将指定的字符串连接到该字符串的末尾。.
charAt (int index) ：返回指定索引处的 char值。
indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到
字符串结尾。
substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到
endIndex截取字符串。含beginIndex，不含endIndex。
toCharArray () ：将此字符串转换为新的字符数组。
getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
replace (CharSequence target, CharSequence replacement) ：将与target匹配的
字符串使用replacement字符串替换。
/*
java.lang.String类代表字符串。
API当中说：Java 程序中的所有字符串字面值（如 "abc" ）都作为此类的实例实现。
其实就是说：程序当中所有的双引号字符串，都是String类的对象。（就算没有new，也照样是。）
字符串的特点：
1. 字符串的内容永不可变。【重点】
2. 正是因为字符串不可改变，所以字符串是可以共享使用的。
3. 字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。
创建字符串的常见3+1种方式。
三种构造方法：
public String()：创建一个空白字符串，不含有任何内容。
public String(char[] array)：根据字符数组的内容，来创建对应的字符串。
public String(byte[] array)：根据字节数组的内容，来创建对应的字符串。
一种直接创建：
String str = "Hello"; // 右边直接用双引号
注意：直接写上双引号，就是字符串对象。
*/
public class Demo01String {
public static void main(String[] args) {
// 使用空参构造
String str1 = new String(); // 小括号留空，说明字符串什么内容都没有。
System.out.println("第1个字符串：" + str1);
// 根据字符数组创建字符串
char[] charArray = { 'A', 'B', 'C' };
String str2 = new String(charArray);
System.out.println("第2个字符串：" + str2);
// 根据字节数组创建字符串
byte[] byteArray = { 97, 98, 99 };
String str3 = new String(byteArray);
System.out.println("第3个字符串：" + str3);
// 直接创建
String str4 = "Hello";
System.out.println("第4个字符串：" + str4);
}
}
Static 静态
用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。
静态方法：使用static关键字修饰成员方法，称为静态方法,静态方法先执行
注意事项：
静态方法可以直接访问类变量和静态方法。
静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以
直接访问类变量或静态方法。
静态方法中，不能使用this关键字。
小贴士：静态方法只能访问静态成员。
/*
一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。
如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它。
如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它。
无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
静态变量：类名称.静态变量
静态方法：类名称.静态方法()
注意事项：
1. 静态不能直接访问非静态。
原因：因为在内存当中是【先】有的静态内容，【后】有的非静态内容。
“先人不知道后人，但是后人知道先人。”
2. 静态方法当中不能用this。
原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
*/
public class Demo02StaticMethod {
public static void main(String[] args) {
MyClass obj = new MyClass(); // 首先创建对象
// 然后才能使用没有static关键字的内容
obj.method();
// 对于静态方法来说，可以通过对象名进行调用，也可以直接通过类名称来调用。
obj.methodStatic(); // 正确，不推荐，这种写法在编译之后也会被javac翻译成为“类名称.静态方法名”
MyClass.methodStatic(); // 正确，推荐
// 对于本来当中的静态方法，可以省略类名称
myMethod();
Demo02StaticMethod.myMethod(); // 完全等效
}
public static void myMethod() {
System.out.println("自己的方法！");
}
}
静态内存图
Arrays 操作数组
常用方法：排序和搜索
toString(数组)：将参数数组变成字符串（按照默认格式：[元素1, 元素2, 元素3...]）
sort(数组)：按照默认升序（从小到大）对数组的元素进行排序。
import java.util.Arrays;
/*
java.util.Arrays是一个与数组相关的工具类，里面提供了大量静态方法，用来实现数组常见的操作。
备注：
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]
}
}
Math 基本数学运算
常用方法：
abs(double num)：获取绝对值。有多种重载。
ceil(double num)：向上取整。
floor(double num)：向下取整。
round(double num)：四舍五入。
/*
java.util.Math类是数学相关的工具类，里面提供了大量的静态方法，完成与数学运算相关的操作。
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（二）
Object类，Date类，DateFormat类，Calendar类，System类，StringBuilder类
Object类：是Java语言的根类（java.lang.Object）也就是父类超类
如果一个类没有特别指定父类， 那么默认则继承自Object类。例如：
public class MyClass /*extends Object*/ {
// ...
}
常用方法：
?toString()：返回该对象的字符串表示。
toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。如果要使用需要按照对象的属性得到相应的字符串表现形式，我们需要重写方法
equals(Object obj)：指示其他某个对象是否与此对象“相等”
如果没有覆盖重写equals方法，那么Object类中默认进行==运算符的对象地址比较，只要不是同一个对象，结果必然为false。
tostring方法
public class Person {
private String name;
private int age;
@Override //检查重写
public String toString() {
return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
}
// 省略构造器与Getter Setter
}
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);
}
}
Objects类: JDK7添加了一个Objects工具类, Object的equals方法容易抛出空指针异常，Objects类中的equals方法就优化了这个问题
提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode、返回对象的字符串表示形式、比较两个对象
public static boolean equals(Object a, Object b) {
return (a == b) || (a != null && a.equals(b));
}
Date: 表示特定的瞬间，精确到毫秒。
构造方法
-
public Date()：分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。 -
public Date(long date)：分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。
示例
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
}
}
小提醒：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。
常用方法：
public long getTime() 获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
public void setTime(long time) 设置时间，给的是毫秒值
示例
public class DateDemo02 {
public static void main(String[] args) {
//创建日期对象
Date d = new Date();
//public long getTime():获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值
// System.out.println(d.getTime());
// System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 +"年");
//public void setTime(long time):设置时间，给的是毫秒值
// long time = 1000*60*60;
long time = System.currentTimeMillis();
d.setTime(time);
System.out.println(d);
}
}
DateFormat类 一个具体的类，用于以区域设置敏感的方式格式化和解析日期
构造方法
public SimpleDateFormat() 构造一个SimpleDateFormat，使用默认模式和日期格式
public SimpleDateFormat(String pattern) 构造一个SimpleDateFormat使用给定的模式和默认的日期格式
格式如下：
| 标识字母（区分大小写） | 含义 |
| y | 年 |
| M | 月 |
| d | 日 |
| H | 时 |
| m | 分 |
| s | 秒 |
常用方法
格式化(从Date到String) public final String format(Date date)：将日期格式化成日期/时间字符串
解析(从String到Date) public Date parse(String source)：从给定字符串的开始解析文本以生成日期
示例
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");
//调用format方法，格式化日期按照SimpleDateFormat定义的格式
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");
//调用parse方法，解析字符串，生成日期
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
}
Calendar类 日历类
静态方法
public static Calendar getInstance()：使用默认时区和语言环境获得一个日历
常用方法
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对象。
成员变量：
示例一： set/get方法
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对象
Calendar cal = Calendar.getInstance();
//调用set方法，设置年
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对象，getInstance使用默认时区和语言环境获得一个日历
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日;
}
}
示例三： getTime方法
import java.util.Calendar;
import java.util.Date;
public class Demo09CalendarMethod {
public static void main(String[] args) {
//创建Calendar对象，getInstance使用默认时区和语言环境获得一个日历
Calendar cal = Calendar.getInstance();
//getTime,Calendar中的getTime方法并不是获取毫秒时刻，而是拿到对应的Date对象
Date date = cal.getTime();
System.out.println(date); // Tue Jan 16 16:03:09 CST 2021
}
}
注意事项：
不要问为什么，因为Java语言是外国人发明的
西方星期的开始为周日，中国为周一。
在Calendar类中，月份的表示是以0-11代表1-12月。
日期是有大小关系的，时间靠后，时间越大。
内容总结
以上是互联网集市为您收集整理的Java 基础知识复习 （四） 常用API全部内容，希望文章能够帮你解决Java 基础知识复习 （四） 常用API所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。