## Java API
API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，通俗一点就是别人已经写好的方法，我们直接进行调用就可以使用响应的功能。
## Java常用API
#### String类
```java
public class Main {
public static void main(String[] args) {
// 1 length（）字符串的长度
String a = "Hello Word!";
System.out.println(a.length());
// 输出的结果是字符串长度10。
// 2 charAt（）截取一个字符
String a = "Hello Word";
System.out.println(a.charAt(1));
// 输出的结果是字符串a的下标为1的字符e。
// 3 getchars（）截取多个字符并由其他字符串接收
String a = "Hello Word";
char[] b = new char[10];
a.getChars(0, 5, b, 0);
System.out.println(b);
// 输出的结果为Hello，其中第一个参数0是要截取的字符串的初始下标（int sourceStart），第二个参数5是要截取的字符串的结束后的下一个下标（int sourceEnd）也就是实际截取到的下标是int sourceEnd-1，第三个参数是接收的字符串（char target[]），最后一个参数是接收的字符串开始接收的位置。
// 4 getBytes()将字符串变成一个byte数组
String a = "Hello Word";
byte b[] = a.getBytes();
System.out.println(new String(b));
// 输出的结果为Hello Word的byte数组。
// 5 toCharArray()将字符串变成一个字符数组
String a = "Hello Word";
char[]b = a.toCharArray();
System.out.println(b);
// 输出的结果为Hello Word字符数组。
// 6 equals()和equalsIgnoreCase()比较两个字符串是否相等，前者区分大小写，后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.equals(b));
System.out.println(a.equalsIgnoreCase(b));
// 输出的结果为第一条为false，第二条为true。
// 7 startsWith()和endsWith()判断字符串是不是以特定的字符开头或结束
String a = "Hello Word";
System.out.println(a.startsWith("ee"));
System.out.println(a.endsWith("rd"));
// 输出的结果第一条为false，第二条为true。
// 8 toUpperCase()和toLowerCase()将字符串转换为大写或小写
String a = "Hello Word";
System.out.println(a.toUpperCase());
System.out.println(a.toLowerCase());
// 输出的结果第一条为“HELLO WORD”，第二条为“hello word”。
// 9 concat() 连接两个字符串
String a = "Hello Word";
String b = "你好";
System.out.println(b.concat(a));
// 输出的结果为“你好Hello Word”。
// 10 trim()去掉起始和结束的空格
String a = " Hello Word ";
System.out.println(a.trim());
// 输出的结果为“Hello Word”。
// 11 substring（）截取字符串
String a = "Hello Word";
System.out.println(a.substring(0, 5));
System.out.println(a.substring(6));
// 输出的结果第一条为“Hello”,第一个参数0（beginIndex）是开始截取的位置，第二个参数5（endIndex）是截取结束的位置，输出的结果第二条是“Word”，参数6（beginIndex）是开始截取的位置。
// 12 indexOf()和lastIndexOf()前者是查找字符或字符串第一次出现的地方，后者是查找字符或字符串最后一次出现的地方
String a = "Hello Word";
System.out.println(a.indexOf("o"));
System.out.println(a.lastIndexOf("o"));
// 输出的结果第一条是4，是o第一次出现的下标，第二条是7，是o最后一次出现的下标。
// 13 compareTo()和compareToIgnoreCase(）按字典顺序比较两个字符串的大小，前者区分大小写，后者不区分
String a = "Hello Word";
String b = "hello word";
System.out.println(a.compareTo(b));
System.out.println(a.compareToIgnoreCase(b));
// 输出的结果第一条为-32，第二条为0，两个字符串在字典顺序中大小相同，返回0。
// 14 replace() 替换
String a = "Hello Word";
String b = "你好";
System.out.println(a.replace(a, b));
System.out.println(a.replace(a, "HELLO WORD"));
System.out.println(b.replace("你", "大家"));
// 输出的结果第一条为“你好”，第二条为“HELLO WORD”，第三条为“大家好”。
}
}
```
#### StringBuffer类
```java
public class Main {
public static void main(String[] args) {
// 在sb尾部追加一个字符串
StringBuffer sb = new StringBuffer("Hello ");
sb.append("world");
System.out.println(sb.toString());
// 返回下标为1的字符
StringBuffer sb = new StringBuffer("Hello ");
sb.charAt(1);
System.out.println(sb.toString());
// 在 1 处插入新的字符串 d
StringBuffer sb = new StringBuffer("Hello ");
sb.insert(1, "d");
System.out.println(sb.toString());
// 反转字符
StringBuffer sb = new StringBuffer("Hello ");
sb.reverse();
System.out.println(sb.toString());
// 删除字符串
StringBuffer sb = new StringBuffer("Hello ");
sb.delete(1, 2);
System.out.println(sb.toString());
// 替换字符串 从 3开始到4结束
StringBuffer sb = new StringBuffer("Hello ");
sb.replace(3, 4, "new");
System.out.println(sb.toString());
}
}
```
#### Math类
```java
public class Main {
public static void main(String[] args) {
/**
* abs求绝对值
*/
System.out.println(Math.abs(-10.4)); //10.4
System.out.println(Math.abs(10.1)); //10.1
/**
* ceil天花板的意思，就是返回大的值，注意一些特殊值
*/
System.out.println(Math.ceil(-10.1)); //-10.0
System.out.println(Math.ceil(10.7)); //11.0
System.out.println(Math.ceil(-0.7)); //-0.0
System.out.println(Math.ceil(0.0)); //0.0
System.out.println(Math.ceil(-0.0)); //-0.0
System.out.println("my name is -0.5 " + Math.ceil(-0.5));
/**
* floor地板的意思，就是返回小的值
*/
System.out.println(Math.floor(-10.1)); //-11.0
System.out.println(Math.floor(10.7)); //10.0
System.out.println(Math.floor(-0.7)); //-1.0
System.out.println(Math.floor(0.0)); //0.0
System.out.println(Math.floor(-0.0)); //-0.0
/**
* max 两个中返回大的值,min和它相反，就不举例了
*/
System.out.println(Math.max(-10.1, -10)); //-10.0
System.out.println(Math.max(10.7, 10)); //10.7
System.out.println(Math.max(0.0, -0.0)); //0.0
/**
* random 取得一个大于或者等于0.0小于不等于1.0的随机数
*/
System.out.println(Math.random()); //0.08417657924317234
System.out.println(Math.random()); //0.43527904004403717
/**
* rint 四舍五入，返回double值
* 注意.5的时候会取偶数
*/
System.out.println(Math.rint(10.1)); //10.0
System.out.println(Math.rint(10.7)); //11.0
System.out.println(Math.rint(11.5)); //12.0
System.out.println(Math.rint(10.5)); //10.0
System.out.println(Math.rint(10.51)); //11.0
System.out.println(Math.rint(-10.5)); //-10.0
System.out.println(Math.rint(-11.5)); //-12.0
System.out.println(Math.rint(-10.51)); //-11.0
System.out.println(Math.rint(-10.6)); //-11.0
System.out.println(Math.rint(-10.2)); //-10.0
/**
* round 四舍五入，float时返回int值，double时返回long值
*/
System.out.println(Math.round(10.1)); //10
System.out.println(Math.round(10.7)); //11
System.out.println(Math.round(10.5)); //11
System.out.println(Math.round(10.51)); //11
System.out.println(Math.round(-10.5)); //-10
System.out.println(Math.round(-10.51)); //-11
System.out.println(Math.round(-10.6)); //-11
System.out.println(Math.round(-10.2)); //-10
}
}
```
#### Random类
```java
import java.util.Random;
public class Main {
public static void main(String[] args) {
Random rnd = new Random();
String[] str = {"红桃1", "红桃2", "红桃3", "红桃4", "红桃5", "红桃6"};
for (int i = 0; i < 5; i++) {
int m = rnd.nextInt(6);
System.out.println(str[m]);
}
/**
* 红桃2
* 红桃3
* 红桃2
* 红桃1
* 红桃1
*/
}
}
```
#### Date类
```java
import java.util.Date;
public class Main {
public static void main(String[] args) {
Date date = new Date();
System.out.println("当前时间：" + date);
}
/**
* 当前时间：Tue Dec 11 10:11:49 CST 2018
*/
}
```
#### SimpleDateFormat类
```java
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Main {
/**
* 将日期对象格式为指定格式的日期字符串
*
* @return
*/
public static String formatDate(Date date, String format) {
String result = "";
SimpleDateFormat sm = new SimpleDateFormat(format);
if (date != null) {
result = sm.format(date);
}
return result;
}
/**
* 将日期字符串转换成日期对象
*
* @return
* @throws ParseException
*/
public static Date formatToDate(String dateStr, String format) throws ParseException {
SimpleDateFormat sm = new SimpleDateFormat(format);
return sm.parse(dateStr);
}
public static void main(String[] args) throws ParseException {
Date date = new Date();
SimpleDateFormat sm = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
System.out.println(sm.format(date));
// 下面是调用封装方法实现
System.out.println(formatDate(date, "yyyy-MM-dd"));
String date1 = "2016-10-22 18:18:35";
Date da = formatToDate(date1, "yyyy-MM-dd"); // 将日期字符串转换成日期对象
System.out.println(formatDate(da, "yyyy-MM-dd")); // 将日期对象格式为指定格式的日期字符串
System.out.println(formatDate(da, "yyyy-MM-dd HH:mm:ss"));
}
}
```
#### List接口、ArrayList集合
```java
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List list = new ArrayList();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
// 使用List中的添加方法 add(int index,Object Obj)
// 添加的角标 就是后面元素 所在的位置 不能越界
list.add(4, "e");
System.out.println(list);
// 输出的是 a, b, c, d, e
// set方法(不要越界)
list.set(4, "z");
System.out.println(list);
// 通过角标获取对应的元素
Object object = list.get(3);
System.out.println(object);
// 通过get方法 进行遍历
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
// 删除(根据角标删除) 返回的是 被删除的元素
Object remove = list.remove(4);
System.out.println(remove);
System.out.println(list);
}
}
```
#### Map接口、HashMap集合
```java
import java.util.*;
public class Main {
public static void main(String[] args) {
Map map = new HashMap();
map.put("发发发", "8");
map.put("还挺好听", "31");
map.put("替换", "12");
map.put("聚", "14");
System.out.print(map);
}
/**
* 结果：{还挺好听=31, 发发发=8, 聚=14, 替换=12}
*/
}
```
## 包装类
在Java中,很多类的方法都需要接收引用类型的对象,此时就无法将一个基本数据类型的值传入。为了解决这样的问题,JDK 中提供了一系列的包装类,通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。在Java中,每种基本类型都有对应的包装类。
基本数据类型对应的包装类
| 基本数据类型 | 对应的包装类 |
| ------------ | ------------ |
| byte | Byte |
| char | Character |
| int | Integer |
| short | Short |
| long | Long |
| float | Float |
| double | Double |
| boolean | Boolean |
包装类和基本数据类型在进行转换时,引入了装箱和拆箱的概念,其中装箱是指将基本数据类型的值转为引用数据类型;反之,拆箱是指将引用数据类型的对象转为基本数据类型。
## JDK7新特性switch支持字符串
在JDK7中,switch语句的判断条件增加了对字符串类型的支持。由于字符串的操作在编程中使用频繁,这个新特性的出现为Java编程带来了便利。接下来通过一个案例演示一下在switch语句中使用字符串进行匹配。
```java
public class Example {
public static void main(String[] args) {
String week = "Friday";
switch (week) {
case "Monday":
System.out.println("星期一");
break;
case "Tuesday":
System.out.println("星期二");
break;
case "Wednesday":
System.out.println("星期三");
break;
case "Thursday":
System.out.println("星期四");
break;
case "Friday":
System.out.println("星期五");
break;
case "Saturday":
System.out.println("星期六");
break;
case "Sunday":
System.out.println("星期天");
break;
default:
System.out.println("你的输入不正确...");
}
}
}
```
运行结果：
```
星期五
```
## Java帮助文档
java帮助文档就是java的词典，就像汉语和汉语词典的关系一样。
Java1.8 帮助文档
中文 – 谷歌版在线版: https://blog.fondme.cn/apidoc/jdk-1.8-google/
中文 – 有道版在线版: https://blog.fondme.cn/apidoc/jdk-1.8-youdao/
中文 – 百度版在线版: https://blog.fondme.cn/apidoc/jdk-1.8-baidu/
