常用类库有哪些，都能处理那些东西

一般java.lang：java编程语言基本类库：如String[字符串类]，Boolean，System[系统及运行]，Math[数字]，Byte，Class，Exception[异常]，Thread[线程]等基本编程；不需要input导入，其他都需要。

Java.util：提供使用方法及数据结构:Data，Calendar，Arrays，Collection，HashTable等

Java.io：通过数据流，文件系统实现及对象序列的系统输入输出：如FileWhite，File，FileInputStream，IOException，OutPutStream，Writer等

Java.net：提供实现网络通讯应用的所有类

Java.sql：用于访问及处理数据源数据的类

Java.test：用于独立自然语言使用处理文本日期和消息的类和接口

Java.beans：java beans所需要的类

Java.math： 简明的整数算术以及十进制算术的基本函数

Java.awt：创建用户界面以及绘制和管理图形、图像的类 绘图类

Javax.swing.*：提供了一系列轻量级的用户界面组件，是目前 Java 用户界面常用的包

1）：StringBuffer类：

String、StringBuffer、StringBuilder的区别

1.String一旦声明，不可改变，StringBuffer与StringBuilder声明的内容可以改变

2.StringBuffer类中提供的方法都是同步方法，属于安全的线程操作，而StringBuilder类中大的方法都是属于异步方法，属于非线程安全的操作。

2）：Runtime类

Runtime类是Java中与运行时环境有关的操作类，利用此类可以取得系统的内存信息，也可以利用此类产生新的操作系统进程对象。

Runtime类表示运行时操作类，是一个封装了JVM进程的类，每一个JVM都对应着一个Runtime类的实例，此实例由JVM运行时为其实例化。

Runtime run = Runtime.getRuntime();

package library;public class RuntimeDemo { public static void main(String[] args) {  Runtime run = Runtime.getRuntime();//通过Runtime类的静态方法为其进行实例化操作  System.out.println("JVM最大内存量："+run.maxMemory());//观察最大内存量，根据机器环境会有所不同  System.out.println("JVM空闲内存量："+run.freeMemory());//取得程序运行时的内存空闲量  String str = "Hello"+"World"+"!!!"+"\t"+"Welcome"+"To"+"MLDN"+"~";  System.out.println(str);  for (int i = 0; i < 100; i++) {//循环修改Sting，产生多个垃圾，会占用内存   str+=i;  }  System.out.println("操作String之后的，JVM空闲内存量："+run.freeMemory());//观察有多个垃圾空间产生之后的内存空闲量  run.gc();//进行垃圾收集，释放空间  System.out.println("垃圾回收之后的，JVM空闲内存量："+run.freeMemory());//垃圾收集之后的内存空闲量。 }}

结果：

JVM最大内存量：66650112JVM空闲内存量：4934616HelloWorld!!! WelcomeToMLDN~操作String之后的，JVM空闲内存量：4877968垃圾回收之后的，JVM空闲内存量：5015840

1.GC（Garbage Collector，垃圾收集器）指的是释放无用的内存空间。

2.GC会由系统不定期进行自动回收，或者调用Runtime类中的gc()方法手工回收。

Runtime类与Process类

调用本机可执行程序

package library;import java.io.IOException;/** * 调用本机可以执行程序 * 让记事本进程5s后消失 */public class RuntimeDemo2 { public static void main(String[] args) {  Runtime run = Runtime.getRuntime();//通过Runtime类的静态方法为其进行实例化操作  Process pro = null;//声明一个Process对象，接受启动的进程  try {   pro = run.exec("notepad.exe");//调用本机程序，必须进行异常处理  } catch (IOException e) {   // TODO Auto-generated catch block   e.printStackTrace();//打印异常信息  }  try {   Thread.sleep(5000);//让此线程存活5s  } catch (InterruptedException e) {   // TODO Auto-generated catch block   e.printStackTrace();//打印异常信息  }  pro.destroy();//结束此进程 }}

3）：国际化程序

国际化操作是指程序可以同时适应多门语言。

实现国际化光靠Locale类是不够的，还需要属性文件和ResourceBundle类的支持。属性文件是指扩展名为.properties的文件，文件中的内容保存结构是一种“key=value”的形式，因为国际化的程序只显示语言的不同，那么就可以根据不同的国家定义不同的属性文件，属性文件中保存真正要使用的文字信息，要访问这些属性文件，可以使用ResourceBundle类来完成。

实现java程序国际化操作必须通过一下3各类完成：

java.util.Local-----java.util.ResourceBundle---MessageFormat

通过Locale类所指定的区域码，然后ResourceBundle根据Locale类所指定的区域码找到相应的资源文件，如果资源文件（属性文件）中存在动态文本，子使用MesssageFormat进行格式化。

属性文件定义时，必须要按照“名称_国家代码”的形式命名，即所有的相关属性文件的名称全部一样，只有国家的代码不一样，代码如下

（处理动态文本：以中文为例是：”你好，xxx！“，其中“xxx”的内容是由程序动态设置的，那么就需要使用占位符清楚地表示出动态文本的位置，占位符使用“{编号}”的格式出现。使用占位符之后，程序可以使用MessageFormat对信息进行格式化。为占位符动态设置文本的内容。）

1.中文的属性代码文件：Message_zh_CN.propertiesinfo = \u4f60\u597d\uff01

以上信息就是中文：你好，{0}！

2.英语属性文件：Message_en_US.properties

info = Hello，{0}!

3.法语属性文件：Message_fr_FR.properties

info = Bonjour，{0}!

通过Locale类和ResourceBundle类读取属性文件的内容，代码如下：

package library;import java.text.MessageFormat;import java.util.Locale;import java.util.ResourceBundle;public class InterDemo { public static void main(String[] args) {  Locale zhLoc = new Locale("zh","CN");//表示中国地区  Locale enLoc = new Locale("en","US");  Locale frLoc = new Locale("fr","FR");  ResourceBundle zhrb = ResourceBundle.getBundle("Message",zhLoc);//找到中文的属性文件（.getBundle(文件名称,区域码)）  ResourceBundle enrb = ResourceBundle.getBundle("Message",enLoc);  ResourceBundle frrb = ResourceBundle.getBundle("Message",frLoc);  String str1 = zhrb.getString("info");  String str2 = enrb.getString("info");  String str3 = frrb.getString("info");  System.out.println("中文："+MessageFormat.format(str1, "你好"));//通过键值读取属性文件的类容  System.out.println("英文："+MessageFormat.format(str2, "nihao"));  System.out.println("法文："+MessageFormat.format(str3, "nihao"));   }}

结果：

中文：你好，你好！英文：Hello,Hello!法文：Bonjour，Hello!

多个占位符设置多个动态文本：

MessageFormat.format(str1,"你好"，“hello”,"hello")

info = Hello，{0}，{1}，{2}！

 

4）：System类、

System类是一些与系统相关的属性和方法的集合，而且在System类中所有的书信给都是静态的，要引用这些属性和方法，直接使用System类调用即可。

System.gc()：垃圾对象的回收，如果在一个对象被回收之前要进行某些操作，那么该怎么办呢，实际上，在Object类中有一个finalize()方法，此方法定义如下：

protected  void finalize() throws Throwable

package library.finalize;public class Person { private String name; private int age ;  public Person(String name, int age) {  super();  this.name = name;  this.age = age; } public String getName() {  return name; } public void setName(String name) {  this.name = name; } public int getAge() {  return age; } public void setAge(int age) {  this.age = age; } @Override public String toString() {  return "年龄：age=" + age + ",姓名： name=" + name ; } public void finalize()throws Throwable{//对象释放空间时默认调用此方法  System.out.println("对象被释放 -->"+this);//直接打印对象调用toString }  public static void main(String[] args) {  Person per = new Person("张三",30);  per = null;//断开引用释放空间  //以上代码不会在显示器显示输出  System.gc();//强制性释放空间，，会调用fianlize()方法 } }

结果：

对象被释放 -->年龄：age=30,姓名： name=张三

5）：日期操作类

Date类：实例化对象  Date date = new Date();------输出当前日期

Calendar类，可以将取得的时间精确到毫秒，但是他是一个抽象类，依靠其子类GregorianCalendar类。

Dateformat类

SimpleDateFormat类

6）Math类

7）：Random类

8）：NumberFormat类

9）：BigInteger类

10）：Bigdecimal类

11）：对象克隆技术

12）：Arrays类

package library;import java.util.Arrays;public class ArraysDemo { public static void main(String[] args) {  int temp[] = {3,5,7,9,1,2,6,8};  Arrays.sort(temp); //数组排序  System.out.println("排序后数组：");  System.out.println(Arrays.toString(temp));//以字符串输出数组  int point = Arrays.binarySearch(temp, 3);//检索数据位置  System.out.println("元素3的位置在："+point);  Arrays.fill(temp, 3);     //填充数组  System.out.println("数组填充：");  System.out.println(Arrays.toString(temp));//一字符串输出数组 }}

结果：

排序后数组：[1, 2, 3, 5, 6, 7, 8, 9]元素3的位置在：2数组填充：[3, 3, 3, 3, 3, 3, 3, 3]

13）：Comparable接口

比较器主要是针对对象数组的操作

package library.comparabledemo;import java.util.Arrays;public class Student implements Comparable { private String name; private int age; private float score;  public Student(String name, int age, float score) {  super();  this.name = name;  this.age = age;  this.score = score; } @Override public String toString() {  return "Student [age=" + age + ", name=" + name + ", score=" + score    + "]"; } @Override public int compareTo(Student o) {  if (this.score>o.score) {   return -1;  }else if (this.scoreo.age) {    return 1;   }else if (this.age
结果：
Student [age=22, name=孙七, score=100.0]Student [age=20, name=王五, score=99.0]Student [age=20, name=张三, score=90.0]Student [age=20, name=赵六, score=70.0]Student [age=22, name=李四, score=9.0]
分析比较器的排序原理
使用的是二叉树排序方法，即通过二叉树进行排序，然后利用中序遍历的方式把内容依次读取出来。
二叉树排序的基本原理就是：将第1个内容作为根节点保持，如果后面的值比根节点的值小，则放在根节点的左子树，如果后面的值比根节点的值大，则放在根节点的右子树。
找这样的思路，如果给出了一下数字：8、3、10、14、6、4、7、1、13
在根据中序遍历的原理（左子树---根节点---右子树的方式），排序后的结果：1、3、4、6、7、8、10、13、14
package library.comparabledemo;public class BinaryTree { class Node{           //申明一个节点类  private Comparable data;      //保存具体类容  private Node left;        //保存左子树  private Node right;        //保存右子树    public void addNode(Node newNode){   if(newNode.data.compareTo(this.data)<0 xss=removed this.left = newNode;>=0){    if (this.right==null) {     //放在右子树     this.right = newNode;    }else {     this.right.addnode(newnode); >
结果：
排序后的结果：1 3 4 6 7 8 10 13 14 
15）：Observable类和Observer接口，
他们可实现观察者模式（详情请移步：https://blog.csdn.net/weixin_42476601/article/details/84262436）
16）：正则表达式
常用正则规则
序号
规范
描述
序号
规范
描述
1
\\
表示反斜线（\）字符
9
\w
字母、数字、下划线
2
\t
制表符
10
\W
非字母、数字、下划线
3
\n
换行
11
\s
所有的空白字符（如：换行，空格等）
4
[abc]
字符a、b 或c
12
\S
所有非空白字符
5
[^abc]
除了abc以外的任意字符
13
^
行的开头
6
[a-zA-Z0-9]
由字母、数字组成
14
$
行的结尾
7
\d
数字
15
.
匹配除换行符之外的任意字符
8
\D
非数字



数量表示（X表示一组规范）
序号
规范
描述
序号
规范
描述
1
X
必须出现依次
5
X{n}
必须出现n次
2
X?
出现0或1次
6
X{n,}
必须出现n次以上
3
X*
出现0、1次或多次
7
X{n,m}
必须出现n~m次
4
X+
可以出现1次或多次



逻辑运算符（X、Y表示一组规范）
序号
规范
描述
序号
规范
描述
1
XY
X规范后跟着Y规范
5
(X)
作为一个捕获组规范
2
X|Y
X规范或Y规范



package library.regex;public class RegexDemo1 { public static void main(String[] args) {  String info = "LXH:98|MLDN:90|LI:100";  String s[] = info.split("|");   //按照“|”拆分  System.out.println("字符串的拆分：");  for (int i = 0; i < s.length; i++) {   System.out.print(s[i]+"、");  } }}结果：字符串的拆分：、L、X、H、:、9、8、|、M、L、D、N、:、9、0、|、L、I、:、1、0、0、
package library.regex;public class RegexDemo2 { public static void main(String[] args) {  String info = "LXH:98|MLDN:90|LI:100";  String s[] = info.split("\\|");   //按照“|”拆分,需要转义  System.out.println("字符串的拆分：");  for (int i = 0; i < s.length; i++) {   String s2[] = s[i].split(":");   System.out.println("\t|--"+s2[0]+"\t"+s2[1]);  } }}字符串的拆分： |--LXH 98 |--MLDN 90 |--LI 100
17）：定时调度---Timer类、TimerTask类
Timer类是一个线程设施，可以用来实现在某一个时间或某一段时间后按排某一个任务执行一次或定期重复执行。该功能要与TimerTask配合使用。
package library.timer;import java.text.SimpleDateFormat;import java.util.Date;import java.util.TimerTask;public class MyTask extends TimerTask {   //任务调度类要继承TimmerTask类  @Override public void run() {  // TODO Auto-generated method stub  SimpleDateFormat sdf = null;  sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSSS");  System.out.println("当前系统时间："+sdf.format(new Date())); }}
package library.timer;import java.util.Timer;public class TestTask { public static void main(String[] args) {  Timer t = new Timer();    //建立Timer对象  MyTask mt = new MyTask();   //定义任务  t.schedule(mt, 1000,2000);   //设置任务的执行，1秒后开始，每2秒重复 }}部分结果：当前系统时间：2018-11-22 00:09:27:0842当前系统时间：2018-11-22 00:09:29:0816当前系统时间：2018-11-22 00:09:31:0826当前系统时间：2018-11-22 00:09:33:0840
要点：
字符串频繁修改使用StringBuffer类，线程安全
Runtime表示运行时，在JVM中只有一个Runtime，所以想取得Runtime类的对象，直接使用Runtime类中提供的静态方法getRuntime()即可
国际化程序实现的基本原理：所有的语言信息已key-->value的形式保存在资源文件中，程序通过key找到相应的value，根据其所设置国家的Locale对象不同，找到的资源文件也不同，要想实现国际化必须依靠Locale、ResourceBundle两类共同完成
System是系统类，可以取得系统的相关信息，使用System.gc()方法可以强制性进行垃圾回收操作，调用此方法实际上就是调用Runtime类中的gc()方法
Format类为格式操作类，主要的3个子类是Messageformat、NumberFormat、DateFormat。
使用Date类可以方便的取得时间，但取得时间格式不符合低于的习惯，所有可以使用SimpleDateFormat类进行日期的格式化操作
处理大数字可以使用BigInteger、BigDecimal，当需要精确小数点操作位数时，使用Bigdecimal类即可
通过Random类可以取得指定范围的随机数字
如果一个类的对象要箱被克隆，则此对象所在的类必须实现Cloneable接口
要箱对一组对象进行排序，则必须使用比较器。比较器接口Comparable中定义了一个compareTo()的比较方法，用来设置比较规则。
正则表达式是在开发中最常使用的一种验证方法，String类中的replaceAll()、split()、matches()方法都是对正则有所支持
可以使用Timer类和TimerTask类完成系统的定时操作。

                                                                    

                                                        
            

常用类库有：

    java.lang包中的类：

                如：Object、String、StringBuilder、StringBuffer、Math、异常部分等。

                这个包中的类不需要导入，可以直接使用，此外其他包中的类在使用时都需要导入。

   

    java.util包中的类：

               如：集合框架部分(Collection /Map)、Date等。

   java.io包中的类：

              如：InputStream、OutputSream、Reader、Writer等。

   

java.net包 java.net包提供网络开发的支持，包括封装了Socket套接字功能的服务器Serversocket类、客户端Socket类以及访问互联网上的各种资源的URL类。

一、日志相关类库

   日志库是很常见的，因为你在每一个项目中都需要他们。打印日志是服务器端应用中最重要的事情，因为日志是你了解你的程序发生了什么的唯一途径。尽管JDK附带自己的日志库，但是还是有很多更好的选择可用，例如 Log4j 、 SLF4j 和 LogBack。

二、JSON解析库

   在当今世界的web服务和物联网中(IoT)，JSON已经取代了XML，成为从客户端到服务器传送信息的首选协议。有一个好消息和一个坏消息。坏消息 是JDK没有提供JSON库。好消息是有许多优秀的第三方库可以用来解析和创建JSON消息，如 Jackson 和 Gson

三、单元测试库

   单元测试技术的使用，是区分一个一般的开发者和好的开发者的重要指标。程序员经常有各种借口不写单元测试，但最常见的借口就是缺乏经验和知识。常见的单测框架有 JUnit , Mockito 和PowerMock 。

四、通用类库

   有几个很好的第三方通用库可供Java开发人员使用，例如 Apache Commons 和 Google Guava 。我会经常在我的代码中使用这些通用类库，因为这些类库都是经过无数开发者实践过的，无论是实用性还是在性能等方面都是最佳的。

五、Http 库

   我不是很喜欢JDK的一个重要原因就包括他们缺乏对HTTP的支持。虽然可以使用java.net包类，但是这和直接使用像 Apache HttpClient 和 HttpCore 等开源类库比起来麻烦太多了。

   尽管JDK 9将开始HTTP 2.0，也对HTTP的支持做了优化，但是我还是强烈建议所有的Java开发人员熟悉流行的HTTP处理类库，例如HttpClient和HttpCore HTTP等库。

六、XML解析库

   市面上有很多XML解析的类库，如 Xerces , JAXB , JAXP , Dom4j , Xstream 等。 Xerces2是下一代高性能，完全兼容的XML解析工具。Xerces2定义了 Xerces Native Interface (XNI)规范，并提供了一个完整、兼容标准的 XNI 规范实现。该解析器是完全重新设计和实现的，更简单以及模块化。

七、Excel读写库

   许多应用程序需要提供把数据导出到Excel的功能，如果你要做相同的Java应用程序,那么你需要 Apache POI API 。

  这是一个非常丰富的类库，你可以从Java程序读写XLS文件。

八、字节码库

   如果你正在编写一个框架或者类库。有一些受欢迎的字节码库如 javassist 和 Cglib Nodep 可以供你选择，他们可以让你阅读和修改应用程序生成的字节码。

   Javassist使得JAVA字节码操作非常简单。它是一个为编辑Java字节码而生的类库。 ASM 是另一个有用的字节码编辑库。

九、数据库连接池库

   如果你的Java应用程序与数据库交互不是使用数据库连接池库的话，那么你就大错特错了。因为在运行时创建数据库连接非常耗时并且会拖慢你的程序。所以墙裂建议使用，有些好用的连接池可供选择，如 Commons Pool 和 DBCP 。

  在web应用程序中，web服务器通常提供了这些功能。但是在java项目中需要把数据库连接池的类库导入到应用中。

十、消息传递库

   像日志和数据库连接池一样，消息传递也是很多实际的Java项目中必备的。Java提供了JMS Java消息服务，但这不是JDK的一部分,你需要单独的引入jms.jar。类似地，如果您准备使用第三方消息传递协议， Tibco RV 是个不错的选择。

十一、PDF处理库

   除了Excel和Word，PDF也是一种常用的文件格式。如果你的应用程序要支持PDF格式的文件处理，你可以使用 iText 和 Apache FOP 类库。两者都提供了非常有用的PDF处理功能。

十二、日期和时间库

   在Java之前，JDK的日期和时间库一直被人们所诟病，比如其非线程安全的、不可变的、容易出错等。很多开发人员会选择更好用的 JodaTime 类库。

   但是在Java8推出之后，我们就可以彻底放弃JodaTime了，因为Java 8提供了其所有功能。但是，如果你的代码运行在一个低版本的JDK中，那么JodaTime还是值得使用的。

十三、集合类库

   虽然JDK有丰富的集合类，但还是有很多第三方类库可以提供更多更好的功能。如 Apache Commons Collections 、 Goldman Sachs collections 、 Google Collections 和 Trove 。Trove尤其有用，因为它提供所有标准Collections 类的更快的版本以及能够直接在原语（primitive）（例如包含int 键或值的Map 等）上操作的Collections 类的功能。

   FastUtil是另一个类似的API，它继承了Java Collection Framework，提供了数种特定类型的容器，包括映射map、集合set、列表list、优先级队列（prority queue），实现了java.util包的标准接口（还提供了标准类所没有的双向迭代器），还提供了很大的（64位）的array、set、list，以及快速、实用的二进制或文本文件的I/O操作类。

十四、邮件API

  javax.mail 和 Apache Commons Email 提供了发送邮件的api。它们建立在JavaMail API的基础上，提供简化的用法。

十五、HTML解析库

  和XML与JSON类似，HTML是另外一种我们可能要打交道的传输格式。值得庆幸的是，我们有jsoup可以大大简化Java应用程序使用HTML。你不仅可以使用 JSoup 解析HTML还可以创建HTML文档。

十六、加密库

  Apache Commons家族中的 Commons Codec 就提供了一些公共的编解码实现，比如Base64, Hex, MD5,Phonetic and URLs等等。

十七、嵌入式SQL数据库库

  我真的是非常喜欢像 H2 这种内存数据库，他可以嵌入到你的Java应用中。在你跑单测的时候如果你需要一个数据库，用来验证你的SQL的话，他是个很好的选择。顺便说一句,H2不是唯一嵌入式DB，你还有 Apache Derby 和 HSQL 可供选择。

十八、JDBC故障诊断库

   有不错的JDBC扩展库的存在使得调试变得很容易，例如P6spy，这是一个针对数据库访问操作的动态监测框架，它使得数据库数据可无缝截取和操纵，而不必对现有应用程序的代码作任何修改。 P6Spy 分发包包括P6Log，它是一个可记录任何 Java 应用程序的所有JDBC事务的应用程序。其配置完成使用时，可以进行数据访问性能的监测。

十九、序列化库

   Google Protocol Buffer是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交换格式。可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。

二十、网络库

   一些有用的网络库主要有 Netty 的和 Apache MINA 。如果您正在编写一个应用程序，你需要做的底层网络任务，可以考虑使用这些库。