java常用类

 String 字符串类

System 可得到系统信息

Runtime类

StringBuilder（StringBuffer)类

Thread 线程类

Math 与数学有关的工具类

Date 日期类（DateFormat抽象类，具体子类SimplementDateFormat）

Calendar 日期类（Calendar抽象类与GregorianCalender）

ArrayList 底层用数组实现的集合

LinkedList 底层用链表实现的集合

HashMap 接口Map的一个实现类

HashSet 接口Set的一个实现类

Scanner 简单文本扫描器

 

一、System类

System类代表java当前的运行平台，

System是一个final类，该类的所有属性方法都是静态的，

类中的in（标准输入）、out（标准输出）、err（错误输出流），

System类常用于记录程序执行时间、复制数组、确定当前的系统属性和获取环境变量等工作。

System常用方法

currentTimeMillis（）：返回以毫秒为单位的当前时间。

exit（int status）：终止当前正在运行的Java虚拟机

getProperties（） ：确定当前系统属性。

getProperty（String key）：获得指定键指示的系统属性。

nanoTime（）：返回最准确的可用系统计时器的当前值，以毫微秒为单位。

gc（）：运行垃圾回收器。

ex1：Ststrm.currentTimeMillis();返回1970年1月1日到当前时间的毫秒数

ex2：计算循环运行的时间

public class processTime{

public static void main （String args[]）{

long beginTime = Ststrm.currentTimeMillis();

for(int i=0;i<10000;i++){

//循环的语句

}

long endTime = Ststrm.currentTimeMillis();

System.out.print(endTime - beginTime ); //计算出循环运行时间

}

}

 

System累的getProperties（）和 getProperty（String key）方法可获得系统相关属性

       System属性表

 

 

终止虚拟机，退出正在执行程序：System.exit(0);

二、Runtime类

 

Runtime类代表java当前的运行时环境，

每个Java程序都有一个与之对应的Runtime实例，

应用程序通过该对象与其运行时环境相连，

应用程序不能创建自己的Runtime实，但可通过Runtime类的静态方法getRuntime（）获取与之相关联的Runtime对象。

获取Runtime对象后，我们就可以使用Runtime类相关方法访问JVM相关信息，包括处理器信息，内存信息等。

ex：/*

演示如何使用Runtime类访问程序运行期环境   运行操作系统命令

*/

public class RuntimeDemo{

public static void main(String args[]){

Runtime rt=Runtime.getRuntime();

System.out.println("当前处理器数量："+rt.availableProcessors());

System.out.println("空闲内存数："+rt.freeMemory());

System.out.println("总内存数："+rt.totalMemory());

System.out.println("可用最大内存数："+rt.maxMemory());

//运行操作系统命令（ex：运行Windows记事本）

try{

rt.exec("notepad.exe");

}catch(Exception e){

e.printStackTrace();

}

}

}

//更多请参考java.lang包中System与Runtime类相关方法文档说明。

三、字符串相关类

 String类包含了一个不可变得字符串，一旦一个String对象被创建，包含在这个对象中的内容就不可改变，直至对象被销毁。

创建方式：

（1）String str=new String（"Hellow"）;（放在常量池中）

（2）String str="Hello";（放在堆中）

两种方式结果一样但创建过程有很大区别。Java程序运行时引用类型的变量和基本类型的变量都放在栈中，引用变量指向的对象则放在常量池中，此外，类、方法、接口中的常量以及字符串常量也放在常量池中。

常量池存放的是指在编译期被确定，并保存在 .class文件中的一些数据。

Java中String类的常用方法:

public char charAt(int index)
返回字符串中第index个字符；
public int length()
返回字符串的长度；
public int indexOf(String str)
返回字符串中第一次出现str的位置；
public int indexOf(String str,int fromIndex)
返回字符串从fromIndex开始第一次出现str的位置；
public boolean equalsIgnoreCase(String another)
比较字符串与another是否一样（忽略大小写）；
public String replace(char oldchar,char newChar)
在字符串中用newChar字符替换oldChar字符
public boolean startsWith(String prefix)
判断字符串是否以prefix字符串开头；
public boolean endsWith(String suffix)
判断一个字符串是否以suffix字符串结尾；
public String toUpperCase()
返回一个字符串为该字符串的大写形式；
public String toLowerCase()
返回一个字符串为该字符串的小写形式
public String substring(int beginIndex)
返回该字符串从beginIndex开始到结尾的子字符串；
public String substring(int beginIndex,int endIndex)
返回该字符串从beginIndex开始到endsIndex结尾的子字符串
public String trim()
返回该字符串去掉开头和结尾空格后的字符串
public String[] split(String regex)
将一个字符串按照指定的分隔符分隔，返回分隔后的字符串数组

StringBuffer类：

StringBeffer类代表一个内容可变的字符串当一个StringBeffer类被创建后，通过StringBeffer类提供的方法·可以改变该字符串对象的字符序列。一旦StringBeffer生成了最终想要的字符串，就可以调用它的toString方法将其转换为一个String对象。

StringBeffer在进行字符串处理时，不生成新的对象，在内存上优于String。

StringBeffer的创建，通过使用StringBeffer的构造器创建：

StringBeffer str=new StringBeffer（）；

append( ),表示将括号里的某种数据类型的变量插入某一序列中
charAt( ),返回此序列中指定索引处的 char 值
toString( ),返回此序列中数据的字符串表示形式。
subString( ), 返回一个新的 String，它包含此序列当前所包含的字符子序列。
delete( ),移除此序列的子字符串中的字符。
deletecharAt (),  移除此序列指定位置的 char。
insert( ),表示将括号里的某种数据类型的变量插入某一序列中
reverse( ),将此字符序列用其反转形式取代
setCharAt(int index, char ch ),将给定索引处的字符设置为 ch。
trimToSize (),尝试减少用于字符序列的存储空间。
 StringBufferappend(boolean b) 将 boolean 参数的字符串表示形式追加到序列。

StringBufferappend(char c) 将 char 参数的字符串表示形式追加到此序列。

StringBufferappend(char[] str) 将 char 数组参数的字符串表示形式追加到此序列。

StringBufferappend(char[] str, int offset, int len)  将 char 数组参数的子数组的字符串表示形式追加到此序列。

StringBufferappend(CharSequence s) 将指定的 CharSequence 追加到该序列。

StringBufferappend(CharSequence s, int start, int end) 将指定 CharSequence 的子序列追加到此序列。

StringBufferappend(double d) 将 double 参数的字符串表示形式追加到此序列。

StringBufferappend(float f) 将 float 参数的字符串表示形式追加到此序列。

StringBufferappend(int i) 将 int 参数的字符串表示形式追加到此序列。

StringBufferappend(long lng) 将 long 参数的字符串表示形式追加到此序列。

StringBufferappend(Object obj) 追加 Object 参数的字符串表示形式。

StringBufferappend(String str)  将指定的字符串追加到此字符序列。

StringBufferappend(StringBuffer sb) 将指定的 StringBuffer 追加到此序列中。

StringBufferappendCodePoint(int codePoint) 将 codePoint 参数的字符串表示形式追加到此序列。

intcapacity() 返回当前容量。

charcharAt(int index) 返回此序列中指定索引处的 char 值。

intcodePointAt(int index)  返回指定索引处的字符（统一代码点）。

intcodePointBefore(int index)  返回指定索引前的字符（统一代码点）。

intcodePointCount(int beginIndex, int endIndex) 返回此序列指定文本范围内的统一代码点。

StringBufferdelete(int start, int end) 移除此序列的子字符串中的字符。

StringBufferdeleteCharAt(int index) 移除此序列指定位置的 char。

voidensureCapacity(int minimumCapacity) 确保容量至少等于指定的最小值。

voidgetChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 将字符从此序列复制到目标字符数组 dst。

intindexOf(String str) 返回第一次出现的指定子字符串在该字符串中的索引。

intindexOf(String str, int fromIndex) 从指定的索引处开始，返回第一次出现的指定子字符串在该字符串中的索引。

StringBufferinsert(int offset, boolean b)  将 boolean 参数的字符串表示形式插入此序列中。

StringBufferinsert(int offset, char c) 将 char 参数的字符串表示形式插入此序列中。

StringBufferinsert(int offset, char[] str) 将 char 数组参数的字符串表示形式插入此序列中。

StringBufferinsert(int index, char[] str, int offset, int len) 将数组参数 str 的子数组的字符串表示形式插入此序列中。

StringBufferinsert(int dstOffset, CharSequence s) 将指定 CharSequence 插入此序列中。

StringBufferinsert(int dstOffset, CharSequence s, int start, int end) 将指定 CharSequence 的子序列插入此序列中。

StringBufferinsert(int offset, double d) 将 double 参数的字符串表示形式插入此序列中。

StringBufferinsert(int offset, float f) 将 float 参数的字符串表示形式插入此序列中。

StringBufferinsert(int offset, int i) 将 int 参数的字符串表示形式插入此序列中。

StringBufferinsert(int offset, long l) 将 long 参数的字符串表示形式插入此序列中。

StringBufferinsert(int offset, Object obj) 将 Object 参数的字符串表示形式插入此字符序列中。

StringBufferinsert(int offset, String str) 将字符串插入此字符序列中。

intlastIndexOf(String str) 返回最右边出现的指定子字符串在此字符串中的索引。

intlastIndexOf(String str, int fromIndex) 返回最后一次出现的指定子字符串在此字符串中的索引。

intlength() 返回长度（字符数）。

intoffsetByCodePoints(int index, int codePointOffset) 返回此序列中的一个索引，该索引是从给定 index 偏移 codePointOffset 个代码点后得到的。 StringBufferreplace(int start, int end, String str) 使用给定 String 中的字符替换此序列的子字符串中的字符。

StringBufferreverse() 将此字符序列用其反转形式取代。

voidsetCharAt(int index, char ch) 将给定索引处的字符设置为 ch。

voidsetLength(int newLength) 设置字符序列的长度。

CharSequencesubSequence(int start, int end) 返回一个新的字符序列，该字符序列是此序列的子序列。

Stringsubstring(int start) 返回一个新的 String，它包含此字符序列当前所包含的字符子序列。

Stringsubstring(int start, int end) 返回一个新的 String，它包含此序列当前所包含的字符子序列。

StringtoString() 返回此序列中数据的字符串表示形式。

voidtrimToSize() 尝试减少用于字符序列的存储空间。

 

StringBuffer sb = new StringBuffer("Hello ");
sb.append("world"); //在sb尾部追加一个字符串, 此时变成 Hello world;
sb.charAt(1) ; //返回下标为1的字符 此处是 e
sb.insert(1,"d"); //在 1 处插入新的字符串 d 此时变为 Hedllo world;
sb.reverse(); //反转字符 此时变成 dlrow olldeH
sb.delete(1,2); //删除字符串 此时变为Hllo world
sb.replace(3,4,"new"); //替换字符串 从 3开始到4结束 此时变为 Hllnewworld

StringBilder类：

与StringBuffer类方法相同，但StringBuffer是线程安全的，StringBuilder不是，StringBuilder的性能较高一点。

 dATE类：

未过时的方法：

boolean after(Date when):测试此日期是否在指定日期之后

boolean before(Date when):测试此日期是否在指定日期之前

long getTime():返回自1970年1月1日00:00:00GMT以后time毫秒的时间点

void setTime(long time):设置次Date对象，以表示1970年1月1日00:00:00GMT以后time毫秒的时间点

Date date = new Date();

System.out.print("现在的时间是："+date);//打印当前时间

System.out.print("1970年1月1日00:00:00GMT以后time毫秒数："+date.getTime());//1970年1月1日00:00:00GMT以后time毫秒的时间点

DateFormat抽象类，具体子类SimplementDateFormat:

ex:/*

在一个包中创建DateFormatDemo类

*/

public class DateFormatDemo{

public static void main(String args[]){

Date now=new Date();

//获取默认日期格式

DateFormat df = DateFormat.getDateInstance();

String datef=df.format(now);

System.out.print(datef);

//获取中国日期格式

DateFormat dfchina = DateFormat.getDateInstance(DateFormat .Full,Local.CHINA);

String datechina=dfchina .format(now);

System.out.print(datechina);

//默认时间格式

DateFormat dftime = DateFormat.getTimeInstance();

String time=dftime.format(now);

System.out.print(time);

 

//获取中国时间格式

 

DateFormat dfimechina = DateFormat.getTimeInstance(DateFormat .Full,Local.CHINA);

 

String dtimechina=dfimechina .format(now);

 

System.out.print(dtimechina);

 

}

}

ex2:/*

SimpleDateFormat 定义日期时间格式

在包中创建SimpleDateFormatDemo类

*/

public class SimpleDateFormatDemo {

public static void main(String args[]){

Date now=new Date();

SimpleDateFormat sdf=new SimpleDateFormat ("yyyy年MM月dd日 HH时mm分ss秒");

String date=sdf.format(now);

System.out.println(date);//若当前时间为2015-4-21 12:21:21则结果为：2015年04月21日 12时21分21秒

//将字符串解析为日期时间

SimpleDateFormat sdf=new SimpleDateFormat ("yyyy-MM-dd");

String dateString="1995-06-01";

Date date=sdf.parse(dateString);

System.out.println(date.getTine());//此处抛异常（try catch或者throws），我就就不写出来了

 

}

}

 

正则表达式：

正则表达式是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为“元字符”）。模式描述在搜索文本时要匹配的一个或多个字符串。

字符	说明
\	将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，“n”匹配字符“n”。“\n”匹配换行符。序列“\\”匹配“\”，“\(”匹配“(”。
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^ 还会与“\n”或“\r”之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$ 还会与“\n”或“\r”之前的位置匹配。
*	零次或多次匹配前面的字符或子表达式。例如，zo* 匹配“z”和“zoo”。* 等效于 {0,}。
+	一次或多次匹配前面的字符或子表达式。例如，“zo+”与“zo”和“zoo”匹配，但与“z”不匹配。+ 等效于 {1,}。
?	零次或一次匹配前面的字符或子表达式。例如，“do(es)?”匹配“do”或“does”中的“do”。? 等效于 {0,1}。
{n}	n 是非负整数。正好匹配 n 次。例如，“o{2}”与“Bob”中的“o”不匹配，但与“food”中的两个“o”匹配。
{n,}	n 是非负整数。至少匹配 n 次。例如，“o{2,}”不匹配“Bob”中的“o”，而匹配“foooood”中的所有 o。“o{1,}”等效于“o+”。“o{0,}”等效于“o*”。
{n,m}	M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，“o{1,3}”匹配“fooooood”中的头三个 o。'o{0,1}' 等效于 'o?'。注意：您不能将空格插入逗号和数字之间。
?	当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是“非贪心的”。“非贪心的”模式匹配搜索到的、尽可能短的字符串，而默认的“贪心的”模式匹配搜索到的、尽可能长的字符串。例如，在字符串“oooo”中，“o+?”只匹配单个“o”，而“o+”匹配所有“o”。
.	匹配除“\n”之外的任何单个字符。若要匹配包括“\n”在内的任意字符，请使用诸如“[\s\S]”之类的模式。
(pattern)	匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果“匹配”集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用“\(”或者“\)”。
(?:pattern)	匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用“or”字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies) 是比 'industry|industries' 更经济的表达式。
(?=pattern)	执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)' 匹配“Windows 2000”中的“Windows”，但不匹配“Windows 3.1”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern)	执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)' 匹配“Windows 3.1”中的 “Windows”，但不匹配“Windows 2000”中的“Windows”。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
x|y	匹配 x 或 y。例如，'z|food' 匹配“z”或“food”。'(z|f)ood' 匹配“zood”或“food”。
[xyz]	字符集。匹配包含的任一字符。例如，“[abc]”匹配“plain”中的“a”。
[^xyz]	反向字符集。匹配未包含的任何字符。例如，“[^abc]”匹配“plain”中的“p”。
[a-z]	字符范围。匹配指定范围内的任何字符。例如，“[a-z]”匹配“a”到“z”范围内的任何小写字母。
[^a-z]	反向范围字符。匹配不在指定的范围内的任何字符。例如，“[^a-z]”匹配任何不在“a”到“z”范围内的任何字符。
\b	匹配一个字边界，即字与空格间的位置。例如，“er\b”匹配“never”中的“er”，但不匹配“verb”中的“er”。
\B	非字边界匹配。“er\B”匹配“verb”中的“er”，但不匹配“never”中的“er”。
\cx	匹配 x 指示的控制字符。例如，\cM 匹配 Control-M 或回车符。x 的值必须在 A-Z 或 a-z 之间。如果不是这样，则假定 c 就是“c”字符本身。
\d	数字字符匹配。等效于 [0-9]。
\D	非数字字符匹配。等效于 [^0-9]。
\f	换页符匹配。等效于 \x0c 和 \cL。
\n	换行符匹配。等效于 \x0a 和 \cJ。
\r	匹配一个回车符。等效于 \x0d 和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v] 等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v] 等效。
\t	制表符匹配。与 \x09 和 \cI 等效。
\v	垂直制表符匹配。与 \x0b 和 \cK 等效。
\w	匹配任何字类字符，包括下划线。与“[A-Za-z0-9_]”等效。
\W	与任何非单词字符匹配。与“[^A-Za-z0-9_]”等效。
\xn	匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，“\x41”匹配“A”。“\x041”与“\x04”&“1”等效。允许在正则表达式中使用 ASCII 代码。
\num	匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，“(.)\1”匹配两个连续的相同字符。
\n	标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
\nm	标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n 和 m 是八进制数字 (0-7)。
\nml	当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
\un	匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9 匹配版权符号 (©)。