小黑板
对于java初学者来说，很多常用类让主人们各种花式懵*，所以本喵整理了大部分java常用类，当然对于大牛来说这些当然是小儿科，但是相信对于初学者来说还是有很大帮助的！
敲黑板~~~干货来了，不多**，直接上内容：
第一章Exception类
1.1异常的结构：
1.异常处理
1.3自定义异常
第二章Object类
.1简介
.主要方法
第三章File类
3.1简介
3.常用成员函数
3.3示例程序
第四章System类与Runtime类
4.1System类简介
4.System类的成员变量
4.3System类的成员函数
4.4Runtime类简介
4.5Runtime类的成员函数
第五章String类
5.1java内存分区
5.java中String对象的创建
5.3常用成员方法
5.4示例程序
第六章文件的读写
6.1流的概念
6.流的读写过程
第七章集合类
7.1集合类及其子类的类继承图：
7.Iterator接口
7..1Iterator接口介绍
7..Iterator接口的基本方法:
7.3collection接口
7.3.1Collection接口介绍
7.3.Collection接口的常用方法：
7.4Set
7.4.1Set介绍
7.4.Set的子类的比较
7.4.3示例代码分析
7.5List(列表)
7.5.1List(列表)介绍及其常用方法
7.5.List的子类的比较：
7.5.3示例代码分析：
7.6Map(映射)
7.6.1Map的常用方法：
7.6.Map的功能方法：
7.6.3代码分析：
第八章Class类
8.1class类有什么用？
8.class类的特征
8.3class的主要方法
8.4Class的一些使用技巧
第九章Json
9.1介绍：
第十章XML
10.1什么是XML?
10.没有任何行为的XML
10.3Java如何处理XML
10.3.1介绍及优缺点分析
10.3.比较
这些类基本都是平时常用或者经常接触到的类，本篇文章先给大家介绍前四章，之后会按时给大家补上之后的哈，想要代码的童鞋私戳我哈~~给大家发代码的压缩文件~~上车gogogo
第一章Exception类Exception继承于Throwable,其继承关系图如下：
Java中异常分为两大类：RuntimeException(又叫uncheckedException)和非RuntimeException(又叫checkedException)。
RuntimeExcceptionJava程序应该捕获，却可以不去捕获的一个异常。在大多数情况下，都不会去捕获他，一个重要原因是这种异常可能发生的情况太普遍，几乎每行代码都会有RuntimeException的风险，因此反而无需去捕获了。Java中凡是继承自Exception，而不继承自RuntimeException类的异常都是非运行时异常
1.1异常的结构：publicclassExceptionTest
{
publicstaticvoidmain(String[]args)
{
intc=0;
try
{
inta=3;
intb=0;
//这块代码出现了异常
c=a/b;
//那么异常之后的代码都不会被执行
System.out.println("HelloWorld");
}
catch(ArithmeticExceptione)
{
e.printStackTrace();//打印异常信息
}
finally
{
//不管有没有发生异常，finally语句块都会被执行
System.out.println("finally");
}
System.out.println(c);
//当b为0时，有异常，输出为c的初始值0
}
}
//执行结果
//java.lang.ArithmeticException:/byzero
//atexception.ExceptionTest.main(ExceptionTest.java:13)
//finally
//0
1.异常处理对于非运行时异常，必须要对其进行处理，否则无法通过编译。
处理方式有两种：
1.使用try..catch..finally进行捕获；
.在产生异常的方法声明后面写上throws某一个Exception类型，如throwsException，将异常抛出到外面一层去。
处理方法1：将异常捕获
packageexception;
publicclassExceptionTest
{
publicvoidmethod()throwsException//将异常抛出，由调用这个方法的方法去处理这个异常,如果main方法也将异常抛出，则交给Java虚拟机来处理
{
System.out.println("throwaexception");
//抛出异常
thrownewException();
}
publicstaticvoidmain(String[]args)
{
ExceptionTesttest=newExceptionTest();
try
{
test.method();
}
catch(Exceptione)//捕获异常
{
e.printStackTrace();//输出异常信息
}
finally
{
System.out.println("finallyblock");
}
}
}
//执行结果
//throwaexception
//java.lang.Exception
//atexception.ExceptionTest.method(ExceptionTest.java:9)
//atexception.ExceptionTest.main(ExceptionTest.java:18)
//finallyblock
处理方法：将异常继续抛出
packageexception;
publicclassExceptionTest
{
publicvoidmethod()throwsException//将异常抛出，由调用这个方法的方法去处理这个异常,如果main方法也将异常抛出，则交给Java虚拟机来处理
{
System.out.println("throwexception");
//抛出异常
thrownewException();
}
publicstaticvoidmain(String[]args)throwsException//main方法选择将异常继续抛出
{
ExceptionTesttest=newExceptionTest();
test.method();//main方法需要对异常进行处理
System.out.println("test");//main方法没有对异常进行处理，程序崩溃，这行没有输出
}
}
//执行结果
//throwexception
//Exceptioninthread"main"java.lang.Exception
//atexception.ExceptionTest.method(ExceptionTest.java:10)
//atexception.ExceptionTest.main(ExceptionTest.java:17)
对于运行时异常（RuntimeException），可以对其进行处理，也可以不处理。推荐不对运行时异常进行处理。
1.3自定义异常自定义一个异常类型：
publicclassMyExceptionextendsException
{
publicMyException()
{
super();
}
publicMyException(Stringmessage)
{
super(message);
}
}
处理方法1：捕获异常
packageexception;
publicclassExceptionTest4
{
publicvoidmethod(Stringstr)throwsMyException
{
if(null==str)
{
thrownewMyException("传入的字符串参数不能为null！");
}
else
{
System.out.println(str);
}
}
publicstaticvoidmain(String[]args)
{
//异常处理方式1，采用try...catch语句
try
{
ExceptionTest4test=newExceptionTest4();
test.method(null);
}
catch(MyExceptione)
{
e.printStackTrace();
}
finally
{
System.out.println("程序处理完毕");
}
}
}
//执行结果
//exception.MyException:传入的字符串参数不能为null！
//atexception.ExceptionTest4.method(ExceptionTest4.java:9)
//atexception.ExceptionTest4.main(ExceptionTest4.java:3)
//程序处理完毕
处理方法：将异常抛出
packageexception;
publicclassExceptionTest4
{
publicvoidmethod(Stringstr)throwsMyException
{
if(null==str)
{
thrownewMyException("传入的字符串参数不能为null！");
}
else
{
System.out.println(str);
}
}
publicstaticvoidmain(String[]args)throwsMyException//异常处理方式，不断向外抛出
{
ExceptionTest4test=newExceptionTest4();
test.method(null);//异常被抛到main方法
System.out.println("test");//main未处理异常，程序崩溃，该句未执行
}
}
//执行结果
//Exceptioninthread"main"exception.MyException:传入的字符串参数不能为null！
//atexception.ExceptionTest4.method(ExceptionTest4.java:9)
//atexception.ExceptionTest4.main(ExceptionTest4.java:0)
第二章Object类.1简介又叫超类，所有java类的祖先，所有类默认继承Object类，唯一没有父类的类。一般在写框架的时候，不清楚使用者具体用带的对象类型，可以使用Object类。
.主要方法(1).equals
功能：对两个对象的地址值进行判断（比较对象的引用）
包含对称性、自反性、一致性、传递性
方法演示：
Catc1=newCat(1,1,1);
Catc=newCat(1,1,1);
System.out.println("c1.equals(c)的结果是："+c1.equals(c));
().hashcode
功能：标注实际返回对象的物理值，当set中新加一个元素时先调用hashcode方法，可以直接定位到此元素放置的物理位置；如果位置上没有元素，则直接存储；如果位置上有元素，equals判断是否为同一元素，相同则不进行存储，不同则存储到其他位置。
(3).clone
功能：复制对象，返回一个新的对象
与new一个新的对象的区别：clone对象包含原有对象的信息，而new一个新的对象不包含任何信息。
实现原理：第一步与new相同，先分配内存，分配的内存大小和原对象相同，之后调用构造函数，将对象初始化，填充新的对象的属性，返回。
(4).toString
功能：返回该对象的字符串表示，通常，toString方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。
(5).finalize
功能：finalize()是Object的protected方法，子类可以覆盖该方法以实现资源清理工作，GC在回收对象之前调用该方法。
finalize()与C++中的析构函数不是对应的。C++中的析构函数调用的时机是确定的（对象离开域或delete掉），但Java中的finalize的调用具有不确定性
不建议用finalize方法完成“非内存资源”的清理工作，但建议用于：①清理本地对象(通过JNI创建的对象)；②作为确保某些非内存资源(如Socket、文件等)释放的一个补充：在finalize方法中显式调用其他资源释放方法。
第三章File类3.1简介File类是对文件系统中文件以及文件夹进行封装的对象，可以通过对象的思想来操作文件和文件夹。File类保存文件或目录的各种元数据信息，包括文件名、文件长度、最后修改时间、是否可读、获取当前文件的路径名，判断指定文件是否存在、获得当前目录中的文件列表，创建、删除文件和目录等方法。
File类内部有一个FileSystem类的私有成员属性，这个属性封装了当前操作系统的文件系统。File类的成员函数主要通过调用这个成员属性的成员函数来实现。
3.常用成员函数(1).createNewFile()：创建一个文件
例：在指定位置创建一个新文件
importjava.io.*;
classhello{
publicstaticvoidmain(String[]args){
Filef=newFile("/home/upsmart/test1.txt");
try{
f.createNewFile();
}catch(Exceptione){
e.printStackTrace();
}
}
}
().delete()：删除一个文件或目录
importjava.io.*;
classhello{
publicstaticvoidmain(String[]args){
StringfileName="/home/upsmart/test1.txt";
Filef=newFile(fileName);
if(f.exists()){
f.delete();
}else{
System.out.println("文件不存在");
}
}
}
(3).mkdir()：创建一个目录
importjava.io.*;
classhello{
publicstaticvoidmain(String[]args){
StringfileName="/home/upsmart/test";
Filef=newFile(fileName);
f.mkdir();
}
}
(4).isDirectory()：判断一个指定的路径是否为目录
importjava.io.*;
classhello{
publicstaticvoidmain(String[]args){
StringfileName="/home/upsmart/test.txt";
Filef=newFile(fileName);
if(f.isDirectory()){
System.out.println("YES");
}else{
System.out.println("NO");
}
}
}
(5).length():返回文件的大小
classhello{
publicstaticvoidmain(String[]args){
StringfileName="/home/upsmart/test.txt";
Filef=newFile(fileName);
System.out.println(f.length());
}
}
3.3示例程序递归搜索指定目录的全部内容:
importjava.io.*;
classhello{
publicstaticvoidmain(String[]args){
Filef=newFile("/home/upsmart/");
print(f);
}
publicstaticvoidprint(Filef){
if(f!=null){
if(f.isDirectory()){
File[]fileArray=f.listFiles();
if(fileArray!=null){
for(inti=0;ifileArray.length;i++){
//递归调用
print(fileArray[i]);
}
}
}else{
System.out.println(f);
}
}
}
}
第四章System类与Runtime类4.1System类简介System类主要包含系统级属性和控制方法。
System类比较特殊，其构造方法是私有的，故不能被实例化；System类被final修饰，故不能被继承；System类所有的成员变量和成员方法都是static修饰的，可以直接通过类获得成员属性和调用成员方法。System类封装的属性与方法与进程本身并无关系，因此，直接通过类调用是合理的。
4.System类的成员变量System.in,System.out,System.err分别代表标准输入，标准输出，标准错误，这三个成员变量均属于IO类。
4.3System类的成员函数(1).currentTimeMillis()：获取系统时间。用法：System.currentTimeMillis();
().getProperty():获取属性。用法：System.getProperty(str);str为属性名。
(3).arraycopy():数组复制，使用本地方法实现，效率更高。用法：System.arraycopy(src,srcpos,dest,destpos,length);src为源数组，dest为目的数组，srcpos和destpos分别为偏移量，length为复制长度。
4.4Runtime类简介Runtime类封装了java运行时环境,无法通过new关键字创建，但是可以通过getRuntime()返回一个Runtime对象。每一个java进程都有一个Runtime实例，包含了与jvm相关的属性和控制方法。
4.5Runtime类的成员函数(1).gc()：通知jvm执行垃圾回收。用法：Runtime.gc();
().exit()：强制退出程序。用法：Runtime.exit();
(3).totalMemory()：所有可使用空间大小。用法：Runtime.totalMemory()
未完待续~~~荆轲刺秦王~~~~~~
治疗白癜风的药品北京中科医院假