Java API
API（Application Programming Interface）指的是应用程序编程接口。
String类
String初始化有两种，一个是使用字符串常量初始化一个String对象，
String str = “abc”;
还有一种是使用String构造方法初始化字符串，
public class Test{
public static void main(String[] args) {
String str1 = new String(); //创建一个空字符串
String str2 = new String("abcd"); //创建一个内容为abcd的字符串
char[] ch = new char[]{'A','B','C','D'}; //创建数组
String str3 = new String(ch); //创建一个内容为字符数组的字符串
System.out.println(str1+"|"+str2+"|"+str3);
}
}
运行结果
|abcd|ABCD
“==”和“equals()”区别
都可以通过这两种方式对字符串进行比较。equals()方法用于比较两个字符串中的字符是否相等；==方法用于比较字符串对象的地址是否相同。
public class Test{
public static void main(String[] args) {
String a = "abc";
String b = "abc";
System.out.println(a.equals(b));
System.out.println(a==b);
}
}
运行结果
true
true
当创建两个字符串对象时，
public class Test{
public static void main(String[] args) {
String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b));
System.out.println(a==b);
}
}
运行结果
true
false
StringBuffer类
StringBuffer类和String类最大的区别在于它的内容和长度是可以改变的。StringBuffer在其中添加和删除字符时，并不会产生新的StringBuffer对象。
public class Test{
public static void main(String[] args) {
System.out.println("1.添加----------");
add();
System.out.println("2.删除----------");
remove();
System.out.println("3.修改----------");
alter();
}
public static void add(){
StringBuffer sb = new StringBuffer(); //定义一个字符串缓冲区
sb.append("abcdefg"); //在末尾添加字符串
System.out.println("append添加结果："+sb);
sb.insert(2,"123"); //在指定位置插入字符串
System.out.println("insert添加结果："+sb);
}
public static void remove(){
StringBuffer sb = new StringBuffer("abcdefg"); //创建一个非空的字符串对象
sb.delete(1,5); //指定范围删除
System.out.println("delete删除结果："+sb);
sb.deleteCharAt(2); //指定位置删除
System.out.println("deleatCharAt删除结果："+sb);
sb.delete(0,sb.length()); //清空缓冲区
System.out.println("delete清空缓冲区结果："+sb);
}
public static void alter(){
StringBuffer sb = new StringBuffer("abcdef");
sb.setCharAt(1,'p'); //修改指定位置字符
System.out.println("setCharAt修改指定位置字符结果："+sb);
sb.replace(1,2,"qq"); //替换指定位置字符或字符串
System.out.println("replace替换指定位置字符或字符串结果："+sb);
sb.reverse(); //翻转字符串
System.out.println("reverse翻转字符串结果："+sb);
}
}
运行结果
1.添加----------
append添加结果：abcdefg
insert添加结果：ab123cdefg
2.删除----------
delete删除结果：afg
deleatCharAt删除结果：af
delete清空缓冲区结果：
3.修改----------
setCharAt修改指定位置字符结果：apcdef
replace替换指定位置字符或字符串结果：aqqcdef
reverse翻转字符串结果：fedcqqa
注：String类重写了Object类的equals()方法，而StringButter类没有。
要比较StringBuffer的字符串是否相等，需要用toString()转换成String类再进行比较。
String a = new String("abc");
String b = new String("abc");
System.out.println(a.equals(b)); //结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.println(sb1.equals(sb2)); //结果为false
System类
System类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的。
-
static Properties getProperties()
getProperties()方法用于获取当前系统的全部属性，该方法会返回一个Properties对象。
import java.util.Enumeration;
import java.util.Properties;
public class Test{
public static void main(String[] args) {
//获取当前系统属性
Properties properties = System.getProperties();
//获取所有系统属性的key，返回Enumeration对象
Enumeration propertyNames = properties.propertyNames();
while(propertyNames.hasMoreElements()){
//获取系统属性的键key
String key = (String)propertyNames.nextElement();
//获取当前键对应的值value
String value = System.getProperty(key);
System.out.println(key+"--->"+value);
}
}
}
-
static long currentTimeMillis()
返回long值，该值表示当前时间与1970年1月1日8点0分0秒之间的时间差，单位毫秒，习惯性的被称作时间戳。
public class Test{
public static void main(String[] args) {
long startTime = System.currentTimeMillis(); //循环开始的当前时间
int sum = 0;
for(int i=0;i<100000;i++){
for (int j=0;j<=i;j++)
sum++;
}
long endTime = System.currentTimeMillis(); //循环结束的当前时间
System.out.println("程序运行的时间为："+(endTime-startTime)+"毫秒");
}
}
运行结果
程序运行的时间为：2440毫秒
-
static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
该方法用于将一个数组中的元素快速拷贝到另一个数组。其中src（源数组），dest（目标数组），srcPos（源数组中拷贝元素的起始位置），destPos（拷贝到目标数组的起始位置），length（拷贝元素的个数）。
public class Test{
public static void main(String[] args) {
int[] fromArray = {101,102,103,104,105,106}; //源数组
int[] toArray = {201,202,203,204,205,206,207}; //目标数组
System.arraycopy(fromArray,2,toArray,3,4); //拷贝数组元素
//打印目标数组中的元素
for(int i=0;i<toArray.length;i++){
System.out.println(i+": "+toArray[i]);
}
}
}
运行结果
0: 201
1: 202
2: 203
3: 103
4: 104
5: 105
6: 106
除此之外，常用的还有 System.gc(); 垃圾回收，System.exit(int status); 终止当前正在运行的Java虚拟机，status表示状态码，非0表示异常终止。
Runtime类
Runtime类用于表示虚拟机运行时的状态，用于封装JVM虚拟机进程。该类采用的是单例模式设计，对象不可以被实例化，只能通过“Runtime run = Runtime.getRuntime()”方式创建一个Runtime的实例对象。
public class Test{
public static void main(String[] args) {
Runtime rt = Runtime.getRuntime(); //获取
System.out.println("处理器个数： "+rt.availableProcessors()+"个");
System.out.println("空闲内存数量： "+rt.freeMemory()/1024/1024+"M");
System.out.println("最大可用内存数量： "+rt.maxMemory()/1024/1024+"M");
}
}
运行结果
处理器个数： 4个
空闲内存数量： 187M
最大可用内存数量： 3040M
Runtime类提供了exec()方法，用于执行一个dos命令。
public class Test{
public static void main(String[] args) {
Runtime rt = Runtime.getRuntime(); //创建Runtime实例对象
//捕获异常里调用exec()方法打开记事本
try{rt.exec("notepad.exe");}catch(Exception e){e.printStackTrace();}
}
}
exec()方法返回一个Process对象，该对象表示操作系统的一个进程，关闭此进程只需调用destroy()方法即可。
以下是打开记事本3秒后自动关闭
public class Test{
public static void main(String[] args) {
Runtime rt = Runtime.getRuntime(); //创建Runtime实例对象
//捕获异常里调用exec()方法打开记事本
try{
Process process = rt.exec("notepad.exe"); //得到表示进程的Process对象
Thread.sleep(3000); //程序休眠3秒
process.destroy();
}catch (Exception e){
e.printStackTrace();
}
}
}
Math类
public class Test{
public static void main(String[] args) {
System.out.println("计算绝对值: "+Math.abs(-1));
System.out.println("求大于参数的最小整数: "+Math.ceil(5.4));
System.out.println("求小于参数的最大整数: "+Math.floor(-5.2));
System.out.println("对小数四舍五入: "+Math.round(-4.6));
System.out.println("生成一个最接近参数的整数值: "+Math.rint(10.5));//除了0.5这个值其他的和四舍五入相同
System.out.println("求两个数的较大值: "+Math.max(1,2.0));
System.out.println("求两个数的较小值: "+Math.min(1,2.0));
System.out.println("生成一个大于等于0.0小于1.0随机值: "+Math.random());
System.out.println("e的值: "+Math.E);
System.out.println("e的参数次方： "+Math.exp(1.0));
System.out.println("参数的自然底数的对数值: "+Math.log(Math.E));
System.out.println("返回第一个参数的第二个参数次方: "+Math.pow(2,3));
System.out.println("返回参数的算数平方根: "+Math.sqrt(16));
}
}
运行结果
计算绝对值: 1
求大于参数的最小整数: 6.0
求小于参数的最大整数: -6.0
对小数四舍五入: -5
生成一个最接近参数的整数值: 10.0
求两个数的较大值: 2.0
求两个数的较小值: 1.0
生成一个大于等于0.0小于1.0随机值: 0.1599159306911967
e的值: 2.718281828459045
e的参数次方： 2.718281828459045
参数的自然底数的对数值: 1.0
返回第一个参数的第二个参数次方: 8.0
返回参数的算数平方根: 4.0
Random类
在JDK的java.util包中有一个Random类，它可以在指定的取值范围内随机产生数字。Random类提供了两个构造方法，Random()用于创造一个伪随机数生成器，Random(long seed)使用一个long型的seed种子创建伪随机数生成器。
无参的构造方法每次使用的种子是随机的，所以产生的随机数不同，而有参的构造方法运行多次产生的随机数是相同的。
import java.util.Random;
public class Test{
public static void main(String[] args) {
Random r = new Random();
//随机产生5个[0,100)的随机数
for(int i=0;i<5;i++){
System.out.println(r.nextInt(100));
}
}
}
第一次运行结果
43
60
88
84
82
第二次运行结果
80
58
59
69
27
import java.util.Random;
public class Test{
public static void main(String[] args) {
Random r = new Random(1); //创建对象时传入种子
//随机产生5个[0,100)的随机数
for(int i=0;i<5;i++){
System.out.println(r.nextInt(100));
}
}
}
第一次运行结果
85
88
47
13
54
第二次运行结果
85
88
47
13
54
Random类的常用方法
|
方法声明
|
功能描述
|
|
boolean nextBoolean()
|
随机生成boolean类型的随机数
|
|
double nextDouble()
|
随机生成double类型的随机数
|
|
float nextFloat()
|
随机生成float类型的随机数
|
|
int nextInt()
|
随机生成int类型的随机数
|
|
int nextInt(int n)
|
随机生成0~n之间int类型的随机数
|
|
long nextLong()
|
随机生成long类型的随机数
|
包装类
通过包装类可以将基本类型的值包装成引用数据类型的对象。
除了char对应Character，int对应Integer外，其他都是将首字母大写即可。
包装类和基本数据类型转换时，引入了装箱（将基本数据类型的值转为引用数据类型）和拆箱（将引用数据类型的值转为基本数据类型）的概念。
Integer类常用方法
|
方法声明
|
功能描述
|
|
toBinaryString(int i)
|
以二进制无符号整数形式返回一个整数参数的字符串
|
|
toHexString(int i)
|
以十六进制无符号整数形式返回一个整数参数的字符串
|
|
toOctalString(int i)
|
以八进制无符号整数形式返回一个整数参数的字符串
|
|
valueOf(int i)
|
返回一个表示指定的int值的Integer实例
|
|
valueOf(String s)
|
返回保存指定的String值的Integer对象
|
|
parseInt(String s)
|
将字符串参数作为有符号的十进制整数进行解析
|
|
intValue()
|
将Integer类型的值以int类型返回
|
装箱：
public class Test{
public static void main(String[] args) {
int a = 20;
Integer i = new Integer(a);
System.out.println(i.toString());
}
}
运行结果
20
拆箱：
public class Test{
public static void main(String[] args) {
Integer i = new Integer(20);
int a = 10;
int num = i.intValue()+a;
System.out.println(num);
}
}
运行结果
30
public class Test{
public static void main(String[] args) {
System.out.println("10的二进制表示："+Integer.toBinaryString(10));
System.out.println("10的八进制表示："+Integer.toOctalString(10));
System.out.println("10的十六进制表示："+Integer.toHexString(10));
System.out.println("二进制1010的十进制表示："+Integer.valueOf("1010",2));
System.out.println("八进制-12的十进制表示："+Integer.valueOf("-12",8));
System.out.println("十六进制a的十进制表示："+Integer.valueOf("a",16));
System.out.println("二进制-1010的十进制表示"+Integer.parseInt("-1010",2));
System.out.println("八进制12的十进制表示："+Integer.parseInt("12",8));
System.out.println("十六进制-a的十进制表示："+Integer.parseInt("-a",16));
System.out.println(Integer.valueOf("-15"));
System.out.println(Integer.parseInt("-15"));
int a = new Integer(10).intValue(); //Integer实例对象.intValue()
int b = Integer.valueOf(10).intValue(); //Integer.valueOf(int i)就是表示一个指定int值的Integer实例
int c = Integer.valueOf("-10").intValue(); //Integer.valueOf(String s)就是表示一个指定String值的Integer实例
System.out.println("a:"+a+" b:"+b+" c:"+c);
}
}
运行结果
10的二进制表示：1010
10的八进制表示：12
10的十六进制表示：a
二进制1010的十进制表示：10
八进制-12的十进制表示：-10
十六进制a的十进制表示：10
二进制-1010的十进制表示-10
八进制12的十进制表示：10
十六进制-a的十进制表示：-10
-15
-15
a:10 b:10 c:-10
注：①包装类都重写了toString()方法，以字符串形式返回②除了Character外，包装类都有valueOf(String s)方法，字符串s不能为null而且必须能解析成相应的基本数据类型，可以根据String类型的参数创建包装类对象：
Integer i = Integer.valueOf(“123”);
③除了Character外，包装类都有parseXXX(String s)的静态方法，字符串s不能为null而且必须能解析成相应的基本数据类型，将字符串转换为对应基本类型数据：
int i = Integer.parseInt(“123”);
三种日期类Date类、Calendar类与DateFormat类
Date类中无参的构造方法Date()用来创建当前时间的Date对象，接收long型参数的构造方法Date(long date)，date参数表示1970.01.01 08:00:00(称为历元)以来的毫秒数。
import java.util.Date;
public class Test{
public static void main(String[] args) {
Date date1 = new Date();
Date date2 = new Date(100000L);
Date date3 = new Date(System.currentTimeMillis());
System.out.println(date1);
System.out.println(date2);
System.out.println(date3);
}
}
运行结果
Sat Oct 05 14:26:24 CST 2019
Thu Jan 01 08:01:40 CST 1970
Sat Oct 05 14:26:24 CST 2019
Calendar类可以设置和读取日期特定部分，是抽象类，不能被实例化，需要调用其静态方法getInstance()来得到一个Calendar对象。
Calendar的常用方法
|
方法声明
|
功能描述
|
|
int get(int field)
|
返回指定日历字段的值
|
|
void add(int field,int amount)
|
根据日历规则，为指定的日历字段增加或减去指定的时间量
|
|
void set(int field,int value)
|
为指定日历字段设置指定值
|
|
void set(int year,int month,int date)
|
设置Calendar对象的年月日三个字段的值
|
|
void set(int year,int,mouth,int date,int hourOfDate,int minute,int second)
|
设置Calendar对象的年月日时分秒六个字段的值
|
上面field参数需要接收Calendar类中定义的常量值，要注意的是Calendar.MONTH字段月份是从0开始的不是1。
import java.util.Calendar;
public class Test{
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();//获取表示当前时间的Calendar对象
int year = calendar.get(Calendar.YEAR); //获取当前年
int month = calendar.get(Calendar.MONTH)+1; //获取当前月
int date = calendar.get(Calendar.DATE); //获取当前日
int hour = calendar.get(Calendar.HOUR); //获取当前时
int minute = calendar.get(Calendar.MINUTE); //获取当前分
int second = calendar.get(Calendar.SECOND); //获取当前秒
System.out.println("当前时间： "+calendar.getTime()); //getTime()获取时间
System.out.println("当前时间： "+year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
}
}
运行结果
当前时间： Sat Oct 05 15:29:37 CST 2019
当前时间： 2019年10月5日3时29分37秒
import java.util.Calendar;
public class Test{
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();
calendar.set(2019,10,1);// 修改z时间为2019.10.01
calendar.add(Calendar.DATE,100); //日 加100天
System.out.println("2019.10.01的100天后是"+calendar.get(Calendar.YEAR)+"."+calendar.get(Calendar.MONTH+1)+"."+calendar.get(Calendar.DATE));
}
}
运行结果
2019.10.01的100天后是2020.7.9
Calendar有两种解释：日历字段的模式--lenient模式（默认模式）和non-lenient模式。Calendar.MONTH取值是0~11，当超过数值时比如13，会设置为“一年两个月”，当改为non-lenient模式时，会抛出异常
import java.util.Calendar;
public class Test{
public static void main(String[] args) {
Calendar calendar = Calendar.getInstance();//当前时间为2019.10.5
//将MONTH字段设置为13
calendar.set(Calendar.MONTH,13);
System.out.println(calendar.getTime());
//开启non-lenient模式
calendar.setLenient(false);
calendar.set(Calendar.MONTH,13);
System.out.println(calendar.getTime());
}
}
运行结果
Wed Feb 05 15:46:15 CST 2020
Exception in thread "main" java.lang.IllegalArgumentException: MONTH
Calendar的getTime()方法返回一个表示Calendar时间值的Date对象，
Calendar的setTime(Date date)方法接收一个Date对象，
通过这两个方法就可以完成Date和Calendar对象的转换。
Calendar.getInstance().setTime(new Date());
DateFormat类是抽象类，不能被直接实例化，可以用它的四个静态方法获取，它们可以分别对日期或者时间部分进行格式化。
FULL常量表示完整格式，LONG常量表示长格式，MEDIUM常量表示普通格式，SHORT常量表示短格式。
import java.text.DateFormat;
import java.util.Date;
public class Test{
public static void main(String[] args) {
Date date = new Date();
//FULL格式的日期格式器对象
DateFormat fullFormat = DateFormat.getDateInstance(DateFormat.FULL);
System.out.println("FULL格式："+fullFormat.format(date));
DateFormat fullFormat1 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL);
System.out.println("FULL格式："+fullFormat1.format(date));
//LONG格式的日期格式器对象
DateFormat longFormat = DateFormat.getDateInstance(DateFormat.LONG);
System.out.println("LONG格式："+longFormat.format(date));
DateFormat longFormat1 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG);
System.out.println("LONG格式："+longFormat1.format(date));
//MEDIUM格式的日期格式器对象
DateFormat mediumFormat = DateFormat.getDateInstance(DateFormat.MEDIUM);
System.out.println("MEDIUM格式："+mediumFormat.format(date));
DateFormat mediumFormat1 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
System.out.println("MEDIUM格式："+mediumFormat1.format(date));
//SHORT格式的日期格式器对象
DateFormat shortFormat = DateFormat.getDateInstance(DateFormat.SHORT);
System.out.println("SHORT格式："+shortFormat.format(date));
DateFormat shortFormat1 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT);
System.out.println("SHORT格式："+shortFormat1.format(date));
}
}
运行结果
FULL格式：2019年10月5日星期六
FULL格式：2019年10月5日星期六 中国标准时间 下午4:37:51
LONG格式：2019年10月5日
LONG格式：2019年10月5日 CST 下午4:37:51
MEDIUM格式：2019年10月5日
MEDIUM格式：2019年10月5日 下午4:37:51
SHORT格式：2019/10/5
SHORT格式：2019/10/5 下午4:37
getDateInstance()方法获得的实例对象用于对日期部分进行格式化，
getDateTimeInstance()方法获得的实例对象用于对日期和时间进行格式化。
DateFormat类还提供了parse(String source)方法，将字符串解析成Date对象，该方法需要捕获异常。
import java.text.DateFormat;
public class Test{
public static void main(String[] args) {
//创建LONG格式的DateFormat对象
DateFormat df = DateFormat.getDateInstance(DateFormat.LONG);
String d = "2000年10月1日";
try{
System.out.println(df.parse(d)); //字符串解析
}catch(Exception e){
e.printStackTrace();
}
}
}
运行结果
Sun Oct 01 00:00:00 CST 2000
SimpleDateFormat类是DateFormat的子类，可以使用new关键字创建实例对象，它的构造方法接收一个格式字符串参数，表示日期格式模板。
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test{
public static void main(String[] args) {
SimpleDateFormat sdf = new SimpleDateFormat("Gyyyy年MM月dd日E,第D天");
System.out.println(sdf.format(new Date()));
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy/MMM/dd");
String dt = "2009/五月/03";
try{
System.out.println(sdf1.parse(dt)); //字符串解析
}catch(Exception e){
e.printStackTrace();
}
}
}
运行结果
公元2019年10月05日周六,第278天
Sun May 03 00:00:00 CST 2009