精华内容
下载资源
问答
  • java常用类库

    2015-05-16 08:43:55
    java常用类库 主要方法分析 pdf 文件 实例讲解 StringBuffer类 Runtime类 Locable类 ResourceBundle类 System类 Date类 Calendar类 DateFormat类 Math类
  • java常用类库java常用类库java常用类库java常用类库java常用类库java常用类库java常用类库java常用类库
  • 收集的java李兴华老师的课件笔记。感觉还不错,适合回顾和新手补习。
  • Java常用类库

    万次阅读 多人点赞 2018-11-22 00:24:45
    java.util.Local-----java.util.ResourceBundle---MessageFormat 通过Locale类所指定的区域码,然后ResourceBundle根据Locale类所指定的区域码找到相应的资源文件,如果资源文件(属性文件)中存在动态文本,子...

    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最大内存量:66650112
    JVM空闲内存量:4934616
    HelloWorld!!!	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<Student> {
    
    	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.score<o.score) {
    			return 1;
    		} else {
    			if (this.age>o.age) {
    				return 1;
    			}else if (this.age<o.age) {
    				return -1;
    			}else {
    				return 0;
    			}
    		}
    	}
    	public static void main(String[] args) {
    		Student stu[] = {new Student("张三",20,90.0f),new Student("王五", 20, 99.0f),
    				new Student("孙七", 22, 100.0f),new Student("李四", 22, 9.0f),
    				new Student("赵六", 20, 70.0f),};
    		Arrays.sort(stu);
    		for (int i = 0; i < stu.length; i++) {
    			System.out.println(stu[i]);
    		}
    	}
    }
    

    结果:

    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){
    				if(this.left==null){					//放在左子树
    					this.left = newNode;
    				}else {
    					this.left.addNode(newNode);			//递归
    				}
    			}
    			if(newNode.data.compareTo(this.data)>=0){
    				if (this.right==null) {					//放在右子树
    					this.right = newNode;
    				}else {
    					this.right.addNode(newNode);		//递归
    				}
    			}
    		}
    		
    		public void printNode(){						//输出时采用中序遍历
    			if(this.left!=null){						//如果左子树有值,则递归调用该方法,该操作会将中序,root.data左边的数字现输出,而且时从小到大的顺序
    				this.left.printNode();
    			}
    			System.out.print(this.data+"\t");			//输出root.data--->根节点
    			if (this.right!=null) {						//如果右子树有值,则递归调用该方法,该操作会将中序,root.data左边的数字现输出,而且时从小到大的顺序
    				this.right.printNode();
    			}
    		}
    	}
    	
    	private Node root;									//根元素
    	
    	public void add(Comparable data){
    		Node newNode = new Node();						//每传入一个数值,就声明一个新的根节点
    		newNode.data = data;
    		if (root == null) {
    			root = newNode;								//如果是第1个元素,设置根节点
    		}else {
    			root.addNode(newNode);						//确定结点是放在左子树还是右子树
    		}
    	}
    	
    	public void print(){								//输出节点
    		this.root.printNode();
    	}
    	
    	public static void main(String[] args) {
    		BinaryTree bt = new BinaryTree();
    		bt.add(8);
    		bt.add(7);
    		bt.add(14);
    		bt.add(10);
    		bt.add(4);
    		bt.add(1);
    		bt.add(13);
    		bt.add(6);
    		bt.add(3);
    		System.out.println("排序后的结果:");
    		bt.print();
    	}
    }
    

    结果:

    排序后的结果:
    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 或c12\S所有非空白字符
    5[^abc]除了abc以外的任意字符13^行的开头
    6[a-zA-Z0-9]由字母、数字组成14$行的结尾
    7\d数字15.匹配除换行符之外的任意字符
    8\D非数字   
    数量表示(X表示一组规范)
    序号规范描述序号规范描述
    1X必须出现依次5X{n}必须出现n次
    2X?出现0或1次6X{n,}必须出现n次以上
    3X*出现0、1次或多次7X{n,m}必须出现n~m次
    4X+可以出现1次或多次   
    逻辑运算符(X、Y表示一组规范)
    序号规范描述序号规范描述
    1XYX规范后跟着Y规范5(X)作为一个捕获组规范
    2X|YX规范或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
    

    要点:

    1. 字符串频繁修改使用StringBuffer类,线程安全
    2. Runtime表示运行时,在JVM中只有一个Runtime,所以想取得Runtime类的对象,直接使用Runtime类中提供的静态方法getRuntime()即可
    3. 国际化程序实现的基本原理:所有的语言信息已key-->value的形式保存在资源文件中,程序通过key找到相应的value,根据其所设置国家的Locale对象不同,找到的资源文件也不同,要想实现国际化必须依靠Locale、ResourceBundle两类共同完成
    4. System是系统类,可以取得系统的相关信息,使用System.gc()方法可以强制性进行垃圾回收操作,调用此方法实际上就是调用Runtime类中的gc()方法
    5. Format类为格式操作类,主要的3个子类是Messageformat、NumberFormat、DateFormat。
    6. 使用Date类可以方便的取得时间,但取得时间格式不符合低于的习惯,所有可以使用SimpleDateFormat类进行日期的格式化操作
    7. 处理大数字可以使用BigInteger、BigDecimal,当需要精确小数点操作位数时,使用Bigdecimal类即可
    8. 通过Random类可以取得指定范围的随机数字
    9. 如果一个类的对象要箱被克隆,则此对象所在的类必须实现Cloneable接口
    10. 要箱对一组对象进行排序,则必须使用比较器。比较器接口Comparable中定义了一个compareTo()的比较方法,用来设置比较规则。
    11. 正则表达式是在开发中最常使用的一种验证方法,String类中的replaceAll()、split()、matches()方法都是对正则有所支持
    12. 可以使用Timer类和TimerTask类完成系统的定时操作。
    展开全文
  • Java常用类库和API

    千次阅读 2020-01-11 14:58:36
    如果不会总结,很多知识学习后想回顾就会花很多时间,这里总结一下Java常用类库,都是日常开发中常用到的库,并且之后用到比较好用的库也会再这里添加 日志类库 无论是开发,学习和运维,日志已经是每个环节都必须...

    简介

    如果不会总结,很多知识学习后想回顾就会花很多时间,这里总结一下Java常用的类库,都是日常开发中常用到的库,并且之后用到比较好用的库也会再这里添加

    日志类库

    无论是开发,学习和运维,日志已经是每个环节都必须的存在,不幸的是在java中日志体系比较混乱,这时我们需要去梳理一下这些类库,常用的有log4j、JUL、logback等等,以及后来出现的日志框架commons-logging、SLF4J,如果不知道怎么选,选择SLF4J就好,SLF4J(Simple logging Facade for Java)不是一个真正的日志实现,而是一个抽象层( abstraction layer),它允许你在后台使用任意一个日志类库。而不是直接使用 Log4j, commons logging, logback 或者 java.util.logging。
    在这里插入图片描述

    JSON解析库

    现在的web服务和物联网中(IoT),JSON已经取代了XML,成为从客户端到服务器传送信息的首选协议,但是Java并没有提供相应的解析库,但是有很多优秀的三方库可以用,常见的库有JSON.simple、GSON、Jackson、JSONP,如果你对JSON库的解析速度比较敏感的话,大文件选Jackson,小文件选GSON,两者则JSON.simple。做为一个Java开发人员,是必须要学会使用至少一种JSON解析库的。
    在这里插入图片描述

    单元测试库

    单元测试技术的使用,是区分一个一般的开发者和好的开发者的重要指标,只有测好了每一个最小单元(方法),才能保存之后组成的服务稳定可用。前期开发测试方便且快速,后期维护如果再有哪个方法出了问题,再想修改就很废时且很麻烦,这也是要写好自己功能模块测试的原因。在这里插入图片描述

    XML解析库

    Java开发难免会去解析XML文件,例如读配置文件信息等,市面上有很多XML解析的类库,如DOM,SAX,DOM4J,JDOM等。这些分析库各有优缺点,可以根据自己的需求来选择一个,例如:DOM采用的是整体读入,向前处理时很容易,且能修改文件,缺点是对于大文件的载入非常浪费资源,并且有内存溢出的风险。而SAX采用的事件处理,SAX不主动载入XML文档,优点在处理速度快,资源消耗最小,缺点是不能提供向前访问,只有重新载入,且不能修改文件。而JDOM采用的是DOM和SAX的综合体。
    在这里插入图片描述

    HTML解析库

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

    Excel读写库

    许多程序需要操作Excel的功能,而常用的解析Excel文件的工具库主要有JXL和POI,其中推荐使用POI,因为JXL有bug和版本不更新等问题
    在这里插入图片描述

    PDF处理库

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

    数据库连接池库

    运行时频繁创建数据库连接非常耗时并且会拖慢你的程序,所以在实际开发中,一定且必须要用数据库连接池,常见的数据库连接池有C3P0、DBCP、proxool、DBPool、Primrose、Druid那么,这么多的数据库连接池,怎么选呢,别选,选就是Druid,从各个方面都比别的数据库连接池好用,是目前最好用的数据库连接池,并且经受住阿里上百款的实际应用考验
    在这里插入图片描述

    集合类库

    虽然JDK有丰富的集合类,但还是有很多第三方类库可以提供更多更好的功能。如 Apache Commons Collections 、 Goldman Sachs collections 、 Google Collections 和 Trove 。
    在这里插入图片描述

    邮件API

    javax.mail 和 Apache Commons Email 提供了发送邮件的api。它们建立在JavaMail API的基础上,提供简化的用法。
    在这里插入图片描述

    加密库

    Apache Commons家族中的 Commons Codec 就提供了一些公共的编解码实现,比如Base64, Hex, MD5,Phonetic and URLs等等
    在这里插入图片描述

    嵌入式SQL数据库库

    可以嵌入到你的Java应用中。在你跑单测的时候如果你需要一个数据库,用来验证你的SQL的话,嵌入式数据库是个很好的选择,常见的嵌入式数据库有H2、 Apache Derby 和 HSQL
    在这里插入图片描述

    序列化库

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

    展开全文
  • Java 常用类库(20种)

    千次阅读 2019-05-30 16:48:37
    一个有经验的Java开发人员特征之一就是善于使用已有的轮子来造车。《Effective Java》的作者Joshua Bloch曾经说过:“建议使用现有的API来开发,而不是重复造轮子”。在本文中,我将分享一些Java开发人员应该熟悉的最...

    一个有经验的Java开发人员特征之一就是善于使用已有的轮子来造车。《Effective Java》的作者Joshua Bloch曾经说过:“建议使用现有的API来开发,而不是重复造轮子”。在本文中,我将分享一些Java开发人员应该熟悉的最有用的和必要的库和API。顺便说一句,这里不包括框架,如Spring和Hibernate因为他们非常有名,都有特定的功能。

    本文总结了日志、JSON解析、单测、XML解析、字节码处理、数据库连接池、集合类、邮件、加密、嵌入式SQL数据库、JDBC故障诊断以及序列化等20个方面的常用类库。都是你日常开发经常可能要用到的,现在不用不要紧,但是你要知道有这么一篇文章可以供你参考。

    不知道不可怕,可怕的是你不知道你不知道。

    一、日志相关类库

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

    Java开发人员应该熟悉日志记录的利弊, 并且了解为什么SLF4J要比Log4J要好。

    二、JSON解析库

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

    一个Java web开发人员应该熟悉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 。如果您正在编写一个应用程序,你需要做的底层网络任务,可以考虑使用这些库。

    这都是每位Java开发人员应该熟悉的,并且十分有用的库。Java生态系统非常庞大的,你会发现有很多不同的类库可以做不同的事情。每个你想到的东西,都可能有一个库可以做到。

    要相信,你遇到的问题,肯定不止你一个遇到过。
    要相信,也许有很多人比你更勤奋。
    要相信,你用或不用,轮子就在那里。
    要相信,使用这些类库,你和你的代码都会变得更好。

    转自:https://blog.csdn.net/u011001084/article/details/79216958

    展开全文
  • Java常用类库与技巧

    2019-05-11 01:18:22
    Java常用类库与技巧 导航 一. Java异常体系 二. Java集合框架 三. J.U.C知识点梳理 四. Java的IO机制 一. Java异常体系 1.1 异常处理机制主要回答了哪些问题 What:异常类型回答了什么被抛出 Where: 异常栈堆...

    Java常用类库与技巧

    一. Java异常体系

    1.1 异常处理机制主要回答了哪些问题

    • What:异常类型回答了什么被抛出
    • Where: 异常栈堆跟踪回答了在哪抛出
    • Why:异常信息回答了为什么被抛出

    1.2 Java异常体系

    • 图示
      在这里插入图片描述

    1.3 从概念角度解析Java的异常处理机制

    • Error:程序无法处理的系统错误,编译器不做检查
    • Exception:程序可以处理的异常,捕获后可能恢复

    总结:前者是程序无法处理的错误,后者是可以处理的异常
    RuntimeException: 不可预知的,程序应当自行避免; 非RuntimeException:可预知的,从编译器校验的异常

    • 从责任角度看:
      • Error属于JVM需要负担的责任
      • RuntimeExcepiton是程序应该负担的责任;
      • Checked Exception可检查异常是Java编译器应该负担的责任。

    1.4 常见Error以及Exception

    • RuntimeException

      1. NullPointerException: 空指针引用异常
      2. ClassCastException: 类型强制转换异常
      3. IllegalArgumentException:传递非法参数异常
      4. IndexOutOfBoundsException:下标越界异常
      5. NumberFormatException:数字格式异常
    • 非RuntimeException

      1. ClassCastNotFoundException: 找不到指定class异常
      2. IOException: IO操作异常
    • Error

      1. NoClassDefFoundError:找不到class定义的异常
        • 可能的原因: ①类依赖的class或jar不存在 ②类文件存在,但是存在不同的域中 ③大小写问题,javac编译的时候是无视大小写的,很有可能编译出来的class文件就与想要的不一样
      2. StackOverflowError: 深递归导致栈被耗尽而抛出的异常
      3. OutOfMemoryError:内存溢出异常;

    1.5 Java的异常处理机制

    • 抛出异常:创建异常对象,交由运行时系统处理
    • 捕获异常:寻找合适的异常处理器处理异常,否则终止运行;

    1.6 Java异常的处理原则

    • 具体明确:
      • 抛出的异常应能通过异常类名和message准确说明异常的类型和产生异常的原因;
    • 提早抛出:应尽可能早的发现并抛出异常,便于精确定位问题;
    • 延迟捕获:异常的捕获和处理应尽可能延迟,让掌握更多信息的作用域来处理异常;

    1.7 高效主流的异常处理框架

    • 在用户看来,应用系统发生的所有异常都是应用系统内部的异常
      • 设计一个通用的继承自RuntimeException的异常来统一处理
      • 其余异常都统一转译为上述异常AppException
      • 在catch之后,抛出上述异常的子类,并提供足以定位的信息
      • 由前端接收AppException做统一处理;

    1.8 Java异常处理消耗性能的地方

    • try-catch块影响JVM的优化
    • 异常对象实例需要保存栈快照等信息,开销较大

    二. Java集合框架

    2.1 工作中消失而面试却长存的算法与数据结构

    • 优秀的算法和数据结构被封装到了Java的集合框架之中;

    2.2 考点

    • 数据结构考点

      • 数组和链表的区别;
      • 链表的操作,如反转,链表环路检测,双向链表,循环链表相关操作;
      • 队列,栈的应用;
      • 二叉树的遍历方式及其递归和非递归的实现;
      • 红黑树的旋转;
    • 算法考点:

      • 内部排序:如递归排序、交换排序(冒泡、快排)、选择排序、插入排序;
      • 外部排序:应掌握如何利用有限的内存配合海量的外部存储来处理超大的数据集,写不出来也要有相关思路;
    • 考点扩展

      • 哪些排序是不稳定的,稳定意味着什么
      • 不同数据集,各种排序最好或最差的情况
      • 如何优化算法

    2.3 集合体系结构

    • 图示
      在这里插入图片描述

    2.4 集合之List和Set

    • 图示
      在这里插入图片描述

    2.5 集合之Map

    • HashMap:[数组+链表+红黑树]
      • 如何有效减少碰撞
        • 扰动函数:促使元素位置分布均匀,减少碰撞几率
        • 使用final对象,并采用合适的equals()和hashCode()方法
      • 扩容问题
        • 多线程环境下,调整大小会存在条件竞争,容易容易造成死锁;
        • rehashing是一个比较耗时的过程;
      • 链表与红黑树的相互转换:
        • 超过8转为红黑树少于6则转为链表
    • HashMap知识点回顾:
      • 成员变量:数据结构,树化阀值
      • 构造函数:延迟创建
      • put和get的流程
      • 哈希算法,扩容,性能

    2.6 如何让HashMap变成线程安全的?

    public class SafeHashMapDemo{
    	public static void main(String[] args){
    		Map hashMap=new HashMap();
    		Map safeHashMap=Collections.synchronizedMap(HashMap);		//通过此代码则会让其变成线程安全的,效果与HashTable一致,性能低下
    		safeHashMap.put("aa","1");
    		safeHashMap.put("bb","2");
    		System.out.println(safeHashMap.get("bb"));
    	}
    }
    
    

    2.7 如何优化Hashtable?

    • 通过锁细粒度化,将整锁拆解成多个锁进行优化;

    2.8 ConcurrentHashMap

    • 早期:
      • 分段锁:默认分成16个组,每个组都配一把锁,当一个组内的数据被锁的时候,不影响其他组内数据的读取;
      • 结构:数组+链表
    • 现在:
      • 不允许插入null
      • 分段锁
      • CAS+synchronized使锁更细化
      • 结构:数组+链表+红黑树
    • put方法的逻辑
      在这里插入图片描述

    2.9 HashMap、Hashtable、ConccurentHashMap之间的区别?

    • HashMap线程不安全,数组+链表+红黑树
    • Hashtable线程安全,锁住整个对象,数组+链表
    • ConccurentHashMap线程安全,CAS+同步锁,数组+链表+红黑树
    • HashMap的Key、value均可为null,而其他的两个类不支持;

    三. J.U.C知识点梳理

    3.1 java.util.concurrent:提供了并发编程的解决方案

    • CAS是java.util.concurrent.atomic包的基础
    • AQS是java.util.concurrent.locks包以及一些常用类比如Semophore,ReentrantLock等类的基础;

    3.2 J.U.C包的分类

    • 线程执行器executor

    • 锁locks

    • 原子变量类atomic

    • 并发工具类tools

    • 并发集合collections

    • 结构图示:
      在这里插入图片描述

    • 并发工具类:

      • 闭锁: CountDownLatch
      • 栅栏: CyclicBarrier
      • 信号量: Semaphore
      • 交换器: Exchanger

    3.3 常用

    • CountDownLatch:让主线程等待一组事件发生后继续执行

      • 事件指的是CountDownLatch里的countDown()方法;
    • CyclicBarrier:阻塞当前线程,等待其他线程

      • 等待其他线程,且会阻塞自己当前线程,所有线程必须同时到达栅栏位置后,才能继续执行;
      • 所有线程到达栅栏处,可以出发执行另外一个预先设置的线程;
    • Semaphore

      • 控制某个资源可被同时访问的线程个数
    • Exchange:

      • 两个线程到达同步点后,互相交互数据;
    • 代码示例:

    public static void main(String[]  args){
    	//代表男生和女生
    	ExecutorService service = Executors.newFixedThreadPool(2);
    	service.execute(()->{
    		try{
    			//男生对女生说的话
    			String girl=exchanger.exchange("我其实暗恋你很久了。。。");
    			System.out.println("女生说:"+girl);
    		}catch(InterruptedException e){
    			e.printStackTrace();
    		}
    	});
    	service.execute(()->{
    		try{
    			System.out.println("女生慢慢地从教室里走出来...");
    			TimeUnit.SECONDS.sleep(3);
    			//男生对女生说的话
    			String boy =exchanger.exchange("我很喜欢你...");
    			System.out.println("男生说"+boy);
    		}catch(InterruptedException e){
    			e.printStackTrace();
    		}
    	});
    }
    
    • BlockingQueue
      • 主要用于生产者-消费者模式,在多线程场景时生产者线程在队列尾部添加元素,而消费者线程则在队列头部消费元素,通过这种方式能够达到将任务的生产和消费进行隔离的目的;
      • 常用:
        1. ArrayBlockingQueue:一个由数组结构组成的有界阻塞队列;
        2. LinkedBlockingQueue:一个由链表结构组成的有界/无界阻塞队列
        3. PriorityBlockingQueue:一个支持优先级排序的无界阻塞队列
        4. DealyQueue:一个使用优先级队列实现的无界阻塞队列
        5. SynchronousQueue:一个不存储元素的阻塞队列
        6. LinkedTransferQueue:一个由链表结构组成的无界阻塞队列
        7. LinkedBlockingDeque:一个由链表结构组成的双向阻塞队列;

    有界的意思是容量是有限的,在初始化的时候我们必须指定它容量的大小,一旦指定就不可改变;无边界是有一个默认大小;支持优先级的那个值是必须要有可比性的;LinkedTransferQueue是5,2 的合体,它的性能比2更好;

    四. Java的IO机制

    4.1 BIO - Block-IO:InputStream和OutputStream,Reader和Writer

    在这里插入图片描述

    代码简单直观,但效率和扩展性存在瓶颈

    4.2 NonBlock-IO:构建多路复用的、同步非阻塞的IO操作

    在这里插入图片描述

    提供更贴近底层的高性能操作方式,发起第一次请求的时候不会被阻塞,而是一直被查询是否准备好;

    • NIO的核心

      • Channels
        • FileChannel:
          • transferTo()方法: 把FileChannel中的数据拷贝到另外一个Channel
          • transferFrom:把另外一个Channel中的数据拷贝到FileChannel
          • 避免了两次用户态和内核态间的上下文切换,即"零拷贝",效率较高
        • DatagramChannel
        • SocketChannel
        • ServerSocketChannel
      • Buffers
        • ByteBuffer
        • CharBuffer
        • DoubleBuffer
        • FloatBuffer
        • IntBuffer
        • LongBuffer
        • ShortBuffer
        • MappedByteBuffer
      • Selectors
        • 可以创建多个通道Channel
    • 消息传递方式:

      • select: 内核需要将消息传递到用户空间,需要内核的拷贝动作
      • poll:同上
      • epoll:通过内核和用户空间共享一块内存来实现,性能较高

    4.3 AIO- Asynchronous IO:基于事件和回调机制

    • 图示:
      在这里插入图片描述

    • AIO如何进一步加工处理结果?

      • 基于回调: 实现CompletionHandler接口,调用时触发回调函数
      • 返回Future:通过isDone()查看是否准备好,通过get()等待返回数据

    4.4 BIO、NIO、AIO对比

    • 图示:
      在这里插入图片描述

    BIO一个线程处理一个,NIO是一个server可以响应多个请求,BIO适用于连接数比较小且固定的架构,程序简单容易理解; NIO适用于连接数比较多且连接时间比较短的架构; AIO适用于连接数比较多且连接时间比较长的架构;

    展开全文
  • 日志库是很常见的,因为你在每一个项目中都需要他们。打印日志是服务器端应用中最重要的事情,因为日志是你了解你的程序发生了什么的唯一途径。尽管JDK附带自己的日志库,但是还是有很多更好的选择可用,例如 Log4j ...
  • java常用类库java常用类库java常用类库
  • 收集了28个Java开发常用的工具类库源码,比如Base64.java加密解密、FileHelper.java文件帮助类、FileUploadUtil.java文件上传类、MD5Encrypt.java MD5加密类、MyFileFilter.java文件滤镜类、DateHandler.java类、...
  • 主要介绍了Java常用类库StringBuffer,Runtime,日期操作类等类库总结,需要的朋友可以参考下
  • Java常用类库整理

    2020-06-25 07:33:44
    Java常用类库 目录 java.lang java.lang.System java.util.Scanner java.lang.String java.lang.StringBuffer java.lang.Math java.util.Date java.io 字节流 ( InputStream/OutputStream ) ...
  • java常用类库——math包

    千次阅读 2019-07-02 23:36:20
    对于常用的加,减,乘,除,BigDecimal类提供了相应的成员方法。 public BigDecimal add ( BigDecimal value ) ; //加法 public BigDecimal subtract ( BigDecimal value ) ; //减法 public ...
  • 收集了一些实用的Java类库文件集,全部都是Java源文件,比如加密解密类、文件帮助类、ftp二进制与ascii传输方式区别、文件上传类、MD5加密类、文件滤镜类、数据库连接类和操作类、StringHelper字符串处理类、功能...
  • 主要介绍了Java常用类库Apache Commons工具类说明及使用实例详解,需要的朋友可以参考下
  • Guava 中文是石榴的意思,该项目是 Google 的一个开源项目,包含许多 Google 核心的 Java 常用库。 目前主要包含: com.google.common.annotations com.google.common.base ...
  • JavaSE_3_Java常用类库

    2017-02-09 14:44:24
    StringBuffer类,国际化程序,日期操作类,比较器
  • 起因:由于之前经常会翻看JDK的源码,尤其是JUC包下面的一些类库,发现一些类中开头的大段英语注释写的非常好,很多时候都说明了设计思路以及这样做的原因,所以想把这些注释翻译成中文,便于自己温习的同时也方便...
  • Java 常用类库

    2020-03-10 23:00:37
    java.lang Object、基本数据类型封装类(Boolean、Integer、Long…)、异常、反射、注解、线程、 java.util 集合框架、并发工具、Stream、**Funtion(lambda)**日期及时间工具类、正则 java.io & java.nio 数据流...
  • 各种常用类库的中文介绍及下载地址,包含网络类、工具类及辅助类等
  • 031102_【第11章:Java常用类库】_Runtime类笔记
  • Java基础笔记---Java常用类库StringBuffer类基本介绍常用方法Runtime类基本介绍常用方法 StringBuffer类 基本介绍 String类使用final修饰的,所以字符串的内容一旦声明就不可改变,如果要改变也只能改变栈内存中的...
  • //判断参数年份是否是闰年 9.java.text.SimpleDateFormat (1)用途:时间格式化 (2)父类:DateFormat(抽象类) (3)构造器: SimpleDateFormat() SimpleDateFormat(String patten); (4)patten格式定义: ...
  • java常用类库手册

    2010-08-19 21:45:11
    java常用类库手册 类库就是Java API(Application Programming Interface,应用程序接口),是系统提供的已实现的标准类的集合。在程序设计中,合理和充分利用类库提供的类和接口,不仅可以完成字符串处理、绘图、网络...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,302
精华内容 33,720
关键字:

java常用类库

java 订阅