API（Application Programming Interface）指的是应用程序编程接口。
一、String 类和 StringBuffer 类
在应用程序中经常会用到字符串，所谓字符串就是指一连串的字符，它是由许多单个字符连接而成，如多个英文字母所组成的一个英文单词。字符串中可以包含任意字符，这些字符必须包含在一对双引号 " " 之内，例如 " abc " 。在 Java 中定义了 String 和 StringBuffer 两个类来封装字符串，并提供了一些列操作字符串的方法，他们都是位于 java.lang 包中，因此不需要导包就可以直接使用。
1、String 类的初始化
在操作 String 类之前，首先需要对 String 类进行初始化，在 Java 中可以通过一下两种方式对 String 类进行初始化，具体如下：1)、使用字符串常量直接初始化：
- String str = "abc";
2)、使用 String 的构造方法初始化：
- String()：创建一个内容为空的字符串；
- String(char[] value)：根据指定字符数组创建对象；
- String(String value)：根据指定的字符串内容创建对象。
class StringDemo{
public static void main(String[] args){
//创建一个空的字符串
String str1 = new String();
//创建一个内容为 abcd 的字符串
String str2 = new String("abcd");
//创建一个内同为字符数组的字符串
char[] charArray = {'d','e','f'};
String str3 = new String(charArray);
System.out.println("a"+str1+"b");
System.out.println(str2);
System.out.println(str3);
}
}2、String 类的常见操作
String 类在实际开发中的应用非常广泛，因此灵活地使用 String 类是非常重要的，接下来介绍一下 String 类的常用的一些方法。
1)、字符串的基本操作
在程序中需要对字符串进行一些基本操作，如获取字符串长度，获得指定位置的字符等，String 类针对每一个操作都提供了对应的方法。
class StringDemo1{
public static void main(String[] args){
String str = "afchaghqcthcagclka";
System.out.println("字符串的长度为："+str.length());
System.out.println("字符串中第一个字符为："+str.charAt(0));
System.out.println("字符c第一次出现的位置为"+str.indexOf('c'));
System.out.println("字符c最后一次出现的位置为"+str.lastIndexOf('c'));
}
} 2)、字符串的转换操作
程序开发中经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串的字符进行大小写转换等。
class StringDemo{
public static void main(String[] args){
String str = "abcd";
System.out.print("将字符串转换为字符数组的结果为：");
char[] ch = str.toCharArray();
for (int x=0; x<ch.length; x++){
if (x != ch.length-1){
System.out.print(ch[x]+",");
}else{
System.out.println(cha[x]);
}
}
System.out.println("将int转换为String的结果为："+String.valueOf(97));
System.out.println("将字符串转换为大写的结果为："+str.toUpperCase());
}
} 3)、字符串的替换和去空格操作
程序开发中用户输入数据时会有一些错误和空格，这时可以使用 String 类的 replace() 和 trim() 方法，进行字符串的替换和去除空格操作。
class StringDemo{
public static void main(String[] args){
//替换
String str1 = "itcast";
System.out.print("replace替换结果："+str1.replace("it","cn.it"));
//去空格
String str2 = "i t c a s t";
System.out.println("trim去空格结果："+str2.trim());
System.out.println("replace去空格结果："+str2.replace(" ",""));
}
} 4)、字符串的判断操作
操作字符串时经常需要进行一些判断，如判断字符串是否以指定的字符串开始、结束，是否包含指定的字符串，字符串是否为空等。
class StringDemo{
public static void main(String[] args){
String s1 = "String";
String s2 = "Str";
System.out.println("判断是否以Str开头："+s1.startsWith("Str"));
System.out.println("判断是否以ng结尾："+s1.endsWith("ng"));
System.out.println("判断是否包含tri："+s1.contains("tri"));
System.out.println("判断是否为空："+s1.siEmpty());
System.out.println("判断两个字符串是否相等："+s1.equals(s2));
}
}
在程序中可以通过 == 和 equals() 两种方式对字符串进行比较，但这两种方式有明显的区别。equals() 方法用于比较两个字符串中的字符是否相等，== 方法用于比较两个字符串对象的地址是否相等。对于两个字符串对象，当他们的字符内容完全相同时，使用 equals 判断结果会为 true，但使用 == 判断时，结果一定为 false。
String s1 = new String("abc");
String s2 = new String("abc");
System.out.printlm(s1 == s2);//结果为false，因为s1和s2是两个对象。
System.out.printlm(s1.equals(s2));//结果为true，因为s1和s2字符内容相同 5)、字符串的截取和分割
在 String 类中针对字符串的截取和分割操作提供了两个方法，其中 substring() 方法用于截取字符串的一部分，split() 方法可以将字符串按照某个字符进行切割。
class StringDemo{
public static void main(String[] args){
String str = "羽毛球-篮球-乒乓球";
//字符串截取操作
System.out.println("从第5个字符开始截取："+str.substring(4));
System.out.println("从第5个字符截取到第6个："+str.substring(4,6));
//字符串分割操作
String[] strs = str.split("-");
for (int x=0; x<strs.length; x++){
if (str != strs.length-1){
System.out.println(strs[x]+",");
}else{
System.out.println(strs[x]);
}
}
}
}
3、StringBuffer 类
由于字符串时常量，因此一旦创建，其内容和长度是不可变的。如果需要对一个字符串进行修改，则只能创建新的字符串。为了方便对字符串的修改，在 JDK 中提供了一个 StringBuffer 类（也称字符串缓冲区）。StringBuffer 类和 String 类最大的区别在于它的内同和长度都是可以改变的。StringBuffer 类似一个字符容器，当在其中添加或删除字符时，并不会产生新的 StringBuffer 对象。
针对添加和删除字符的操作，StringBuffer 类提供了一系列的方法。
class StringDemo{
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("删除1~5的字符："+sb);
sb.deleteCharAt(2);
System.out.println("删除指定位置的字符："+sb);
sb.delete(0,sb.length());
System.out.println("清空字符串缓冲区："+sb);
}
public static void alter(){
StringBuffer sb = new StringBuffer("abcdefg");
sb.setCharAt(0,"p");
System.out.println("修改指定位置字符："+sb);
sb.replace(1,3,"qq");
System.out.println("替换指定位置字符："+sb);
}
}
StringBuffer 类和String 类有很多相似之处，初学者在使用时很容易混淆。接下来针对两个类进行对比。
- String 类表示的字符串时常量，一旦创建后，内容和长度都是无法改变的。而 StringBuffer 表示字符容器，其内容和长度都可以随时修改。在操作字符串时如果该字符串仅用于表示数据类型，则使用 String 类即可，但是如果需要对字符串中的字符进行增删操作，则使用 StringBuffer 类。
- String 类覆盖了 Object 类的 equals() 方法，而 StringBuffer 类没有覆盖 Object 类的 equals() 方法，示例如下：
String s1 = new String("abc");
String s2 = new String("abc");
System.out.printlm(s1.equals(s2));//结果为true
StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = new StringBuffer("abc");
System.out.printlm(sb1.equals(sb2));//结果为false- String 类对象可以用操作符 + 进行连接，而 StringBuffer 类对象之间不能，示例如下：
String s1 = new String("a");
String s2 = new String("b");
System.out.printlm(s1+s2);//打印ab
StringBuffer sb1 = new StringBuffer("a");
StringBuffer sb2 = new StringBuffer("b");
System.out.printlm(sb1+sb2);//编译报错二、System 类与 Runtime 类
1、System 类
System 类定义了一些与系统相关的属性和方法，它所提供的属性和方法都是静态的，因此想要使用这些属性和方法，直接使用 System 类调用即可。
1)、getProperties() 方法
System 类的 getProperties() 方法用于获取当前系统的全部属性，该方法会返回一个 Properties 对象，其中封装了系统的所有属性，这些属性是以键值对的形式存在。
import java.util.*;
class SystemDemo{
public static void main(String[] args){
//获取当前系统属性
Properties properties = System.getProperties();
//获得所有系统属性的key，返回Enumeration对象
Enumeration propertyNames = properties.propertyNames();
//循环获取系统属性的键和值
while(propertyNames.hasMoreElements()){
String key = (String)propertyNames.nextElement();
String value = System.getProperty(key);
System.out.println(key+"<-->"+value);
}
}
}
2)、currentTimeMillis() 方法
currentTimeMillis() 方法返回一个 long 类型的值，该值表示当前时间与 1970 年 1 月 1 日 0 点 0 分 0 秒之间的时间差，单位是毫秒，习惯性的被称为时间戳。
import java.util.*;
class SystemDemo2{
public static void main(String[] args){
long startTime = System.currentTimeMillis();
int num = 0;
for(int x=0;x<10000000;x++){
num += x;
}
long endTime = System.currentTimeMillis();
System.out.println("程序的运行时间为："+(endTime-startTime)+"毫秒");
}
}
3)、arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
arraycopy() 方法用于将一个数组中的元素快速拷贝到另一个数组中，其中的参数作用如下：
- src：表示源数组；
- dest：表示目标数组；
- srcPos：表示源数组中拷贝元素的起始位置；
- destPos：表示拷贝到目标数组的起始位置；
- length：表示拷贝元素的个数。
需要注意的是，在进行数组复制时，目标数组必须有足够的空间来存放拷贝的元素，否则会发生角标越界异常。
import java.util.*;
class SystemDemo3{
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 x=0;x<toArray.length;x++){
System.out.println(x+":"+toArray[x]);
}
}
}
除了以上涉及到的方法，System 类还有两个常见的方法，分别是 gc() 和 exit(int status) 方法。其中 gc() 方法用来启动 Java 的垃圾回收器，并且对内存中的垃圾对象进行回收。exit(int status) 方法用来终止正在运行的 Java 虚拟机，其中的参数 status 用于表示当前方式的异常状态，通常指定为 0，表示正常退出，否则表示异常终止。
2、Runtime 类
Runtime 类用于表示虚拟机运行时的状态，它用于封装 JVM 虚拟机进程。每次使用 java 命令启动虚拟机都对应一个 Runtime 实例，并且只有一个实例，因此该类使用单例设计模式，对象不可以直接实例化。若想在程序中获得一个 Runtime 实例，只能通过以下方法：
Runtime run = Runtime.getRuntime()；
由于 Runtime 类封装了虚拟机进程，因此在程序中通常会通过该类的实例对象来获取当前虚拟机的相关信息。
class RuntimeDemo{
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");
}
}
需要注意的是，由于每个人的机器的配置不同，打印的结果可能不同，另外空闲内存数和可用最大内存数都是以字节为单位计算的。
Runtime 类中提供了一个 exec() 方法，该方法用于执行一个 dos 命令，从而实现和在命令行窗口输入 dos 命令同样的效果。exec() 方法返回一个 Process 对象，该对象表示操作系统的一个进程，通过该对象可以对产生的新进程管理，如关闭此进程只需要调用 destory() 方法即可。
class RuntimeDemo{
public static void main(String[] args){
Runtime rt = Runtime.getRuntime();
Process process = rt.exec("notepad.exe");
Thread.sleep(3000);
process.destory();
}
}
三、Math 类与 Random 类
1、Math 类
Math 类是数学操作类，提供了一系列用于数学运算的静态方法，包括求绝对值、三角函数等，Math 类有两个静态常量 PI 和 E，分别代表数学常量 π 和 e 。
class MathDemo{
public static void main(String[] args){
System.out.println("绝对值："+Math.abs(-1));
System.out.println("最小整数："+Math.ceil(5.6));
System.out.println("最大整数："+Math.floor(-2.1));
System.out.println("四舍五入："+Math.round(-4.6));
System.out.println("比较最大值："+Math.max(2.1,-2.1));
System.out.println("比较最小值："+Math.min(2.1,-2.1));
System.out.println("随机数："+Math.random());
}
}
需要注意的是，round() 方法用于对某个小数进行四舍五入，此方法会将小数点后面的数字全部忽略，返回一个 int 值；而 ceil() 方法和 floor() 方法返回的都是 double 类型的数，这个数在数值上等于一个整数。
2、Random 类
在 JDK 的 java.util 包中有一个 Random 类，它可以在指定的取值范围内随机产生数字。
在 Random 类中提供了两个构造方法，其中第一个构造方法是无参的，通过它创建的 Random 实例对象每次使用的种子是随机的，因此每个对象产生的随机数不同。
import java.util.Random;
class RandomDemo1{
public static void main(String[] args){
Random r = new Random();
for(int x=0;x<10;x++){
System.out.println(r.nextInt(100));
}
}
如果希望创建的多个 Random 实例对象产生相同序列的随机数，则可以在创建对象时调用第二个构造方法，传入相同的种子即可。
import java.util.Random;
class RandomDemo2{
public static void main(String[] args){
Random r = new Random(13);
for(int x=0;x<10;x++){
System.out.println(r.nextInt(100));
}
}
从运行结果看，因为创建 Random 的实例对象时没有指定种子，系统会以当前时间戳为种子，产生随机数。如果指定了相同的种子，则每个实例对象产生的随机数具有相同的序列。
相对于 Math 类的 random() 方法而言，Random 类提供了更多的方法来生产各种伪随机数，不仅可以生成证书类型的随机数，还可以生成浮点类型的随机数，下面列举了 Random 类中的常用方法。
import java.util.Random;
class RandomDemo3{
public static void main(String[] args){
Random r = new Random(13);
for(int x=0;x<10;x++){
System.out.println("产生float类型随机数："+r.nextFloat());
System.out.println("产证0~100之间的随机数："+r.nextInt(100));
System.out.println("产生double类型的随机数："+r.nextDouble());
}
}
四、包装类
在 Java 中，很多类的方法都需要接收引用类型的对象，此时就无法将一个基本数据类型的值传入。为了解决这样的问题，JDK 中提供了一系列的包装类，通过这些包装类可以将基本数据类型的值包装为引用数据类型的对象。
每种基本数据类型都有对应的包装类，其中除了 Integer 和 Character 类，其他包装类的名称和基本数据类型的名称一致，只是类名的第一个字母大写即可。
包装类和基本数据类型在进行转换时，引入了装箱和拆箱的概念，其中装箱是指将基本数据类型的值转为引用数据类型；反之，拆箱是指将引用数据类型的对象转为基本数据类型。
Integer 类的一些特有方法：
使用包装类需要注意以下几点：
- 包装类都重写了 Object 类中的 toString() 方法，以字符串的形式返回被包装的基本数据类型的值。
- 除了 Character 外，包装类都有 valueOf(String s) 方法，可以根据 String 类型的参数创建包装类对象，但参数字符串 s 不能为 null，而且字符串必须是可以解析为相应基本类型的数据，否则虽然编译通过，但是运行时会报错。
- 除了 Character 外，包装类都有 parseXXX(String s) 的静态方法，将字符串转换为对应的基本类型的数据，参数 s 不能为 null，而且同样必须是可以解析为相应基本类型的数据，否则虽然编译通过，但运行时报错。
五、Date 类、Calendar 类与 DateFormat 类
在 Java 程序中，针对日期类型的操作提供了三个类，分别是 java.util.Date、java.util.Calendar 和 java.text.DateFormat。
1、Date 类
在 JDK 的 java.util 包中提供了一个 Date 类用于表示日期和时间。Date 类中大部分构造方法都被声明已过时，只有两个构造方法是建议使用的：1)、一个是无参的构造方法 Date() ，用来创建当前日期时间的 Date 对象；2)、另一个是接收 long 类型参数的 Date(long date) ，用于创建指定时间的 Date 对象，其中 date 参数表示 1970 年 1 月 1 日 00:00:00 （称为历元）以来的毫秒数，即时间戳。
import java.util.*;
class DateDemo{
public static void main(String[] args){
Date date1 = new Date();
Date date2 = new Date(966666666661);
System.out.println(date1);
System.out.println(date2);
}
}
对于 Date 类，只需要了解如何通过创建对象封装时间值即可。由于 Date 类在设计之初，没有考虑国际化的问题，因此从 JDK1.1 开始，Calendar 类取代了 Date 类大部分功能。
2、Calendar 类
Calender 类用于完成日期和时间字段的操作，它可以通过特定的方法设置和读取日期的特定部分，比如年、月、日、时、分和秒等。Calendar 类是一个抽象类，不可以被实例化，在程序中需要调用其静态方法 getInstance() 来得到一个 Calendar 对象，然后调用其相应的方法。
Calendar calendar = Calendar.getInstance()；
Calendar 类为操作日期和时间提供了大量的方法，下面列举了一些常见的方法：
在这些方法中都用到了 int 类型的参数 field，该参数需要接受 Calendar 类中定义的常量值，这些常量值分别表示不同的字段，如 Calendar.YEAR 用于表示年份，Calendar.MONTH用于表示月份，Calendar.SECOND 用于表示秒等。其中在使用 Calendar.MONTH 字段时尤其需要注意，月份的起始值是从 0 开始而不是 1,。
import java.util.*;
class CalendarDemo{
public static void main(String[] args){
//获取当前日期
Calendar calendar1 = Calendar.getInstance();
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("当前时间为"+year+"年"+month+"月"+date+"日"+hour+"时"+minute+"分"+second+"秒");
//设置或修改某个时间
Calendar calendar2 = Calendar.getInstance();
calendar.set(2008,7,8);
calendar.add(Calendar.DATE,100);
int year2 = calendar.get(Calendar.YEAR);
int month2 = calendar.get(Calendar.MONTH)+1;
int date2 = calendar.get(Calendar.DATE);
System.out.println("100天后的日期为"+year2+"年"+month2+"月"+date2+"日");
}
}
Calendar 类的 getTime() 方法返回一个表示 Calendar 时间值的 Date 对象，同时 Calendar 有一个 setTime() 方法接收 Date 对象，将 Date 对象表示的时间值设置给 Calendar 对象，通过这两个方法可以完成 Date 和 Calendar 对象之间的转换。
3、DateFormat 类
DateFormat 类专门用于将日期格式化为字符串或者用特定格式显示的日期字符串转换为一个 Date 对象。DateFormat 是抽象类，不能被直接实例化，但它提供了静态方法，通过这些方法可以获取 DateFormat 类的实例对象，并调用其他相应的方法进行操作。
DateFormat 类汇总提供的常见方法如下表，DateFormat 类的四个静态方法都用于获得 DateFormat 类的实例对象，每种方法返回的对象都具有不同的作用，他们可以分别对日期或事件部分进行格式化。在 DateFormat 类中定义了四个常量值用于作为参数传递给这些方法，其中包含 FULL、LONG、MEDIUM 和 SHORT。FULL 常量用于表示完成格式，LONG 常量用于表示长格式，MEDIUM 常量用于表示普通格式，SHORT 常量用于表示短格式。
import java.util.*;
class DateFormatDemo1{
public static void main(String[] args){
Date date = new Date();
DateFormat fullFormat = DateFormat.getDateInstance(DateFormat.FULL);
DateFormat longFormat = DateFormat.getDateInstance(DateFormat.LONG);
DateFormat mediumFormat = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM);
DateFormat shortFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT);
System.out.println("当前日期的完整格式："+fullFormat.format(date));
System.out.println("当前日期的长格式："+longFormat.format(date));
System.out.println("当前日期的普通格式："+mediumFormat.format(date));
System.out.println("当前日期的短格式："+shortFormat.format(date));
}
}
import java.util.*;
class DateFormatDemo2{
public static void main(String[] args){
DateFormat df = DateFormat.getInstance(DateFormat.LONG);
String d = "2008年8月8日";
System.out.println(df.parse(d));
}
4、SimpleFormat 类
在使用 DateFormat 对象将字符串解析为日期时，需要输入固定格式的字符串，这显然不够灵活。JDK 中提供了一个 SimpleDateFormat 类，该类时 DateFormat 的子类。SimpleDateFormat 类可以使用 new 关键字创建实例对象，它的构造方法接收一个格式字符串参数，表示日期格式模板。
import java.util.*;
class SimpleDateFormatDemo1{
public static void main(String[] args){
SimpleDateFormat sdf = new SimpleDateFormat("Gyyyy年MM月dd日：今天是yyyy年的第D天,E");
System.out.println(sdf.format(new Date()));
}
import java.util.*;
class SimpleDateFormatDemo2{
public static void main(String[] args){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MMM/dd");
String dt = "2012年/8月/8日";
System.out.println(sdf.parse(dt));
}
六、JDK7 新特性
在 JDK7 中，switch 语句的判断条件增加了对字符串类型的支持，由于字符串的操作在编程中使用频繁，这个新特性的出现为 Java 编程带来了方便。
import java.util.*;
class SwitchDemo{
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("您的输入有误！");
}
}
3282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
