一、Java基础以及面向对象编程
1、float类型的数自动转换成double类型时，可能会出现前后不相等的情况，因为有些数不能够用有限的二进制位精确表示。
2、右移
>>右移，左边空出位以符号位填充
>>>右移，左边空出位以0填充
3、计算阶乘
public class Factorial {
public Factorial(){
}
public long getFactorial(int n){
if((n<0)||(n>17)){
return -1;
}else if(n==0 || n==1){
return 1;
}else{
long result=n;
do{
result *=(--n);
}while(n>1);
return result;
}
}
}
4、System.exit(0) 该方法关闭Java虚拟机，退出应用程序，当exit方法的参数为0时表示程序正常退出，为其他值时异常退出。
5、重写equals、clone、hashCode方法
这几个方法在Object类中都是基于对象的地址来实现的，如果要实现符合实际意义的方法，则需要在Object的子类中进行重写。这里以复数类为例：
（1）重写equals方法
先判断传入对象与现有对象是否同一类，再对同一类的传入对象比较属性。
@Override
public boolean equals(Object obj) {
if(obj==null){
return false;
}
if(obj instanceof ComplexNumber){
ComplexNumber b=(ComplexNumber)obj;
if((this.realPart == b.realPart) && (this.imaginaryPart==b.imaginaryPart)){
return true;
}else{
return false;
}
}else{
return false;
}
}
（2）重写hashCode方法
找到一个能够代表对象的Key，如果这个key是int类型，可以直接返回该key，如果其他类型，则返回该key的hashCode。
@Override
public String toString() {
return "ComplexNumber{" + "realPart=" + realPart + ", imaginaryPart=" + imaginaryPart + '}';
} @Override
public int hashCode() {
return this.toString().hashCode();
}
（3）重写clone方法
首先，类要实现Cloneable方法，然后再重写clone方法。实现时，先调用父类的clone方法，然后将现有对象的属性值赋给新对象。
@Override
protected Object clone() {
try{
ComplexNumber newObject=(ComplexNumber) super.clone();
newObject.setRealPart(this.realPart);
newObject.setImaginaryPart(this.imaginaryPart);
return newObject;
}catch(CloneNotSupportedException e){
e.printStackTrace();
return null;
}
}
6、Java在传递参数时，如果参数是对象类型，则将“参数的引用”复制之后传给方法。
7、System的gc方法通知Java虚拟机进行垃圾回收，但何时回收由虚拟机决定，进行垃圾回收时，虚拟机会调用对象的finalize方法。
8、对于每个类，Java虚拟机只加载一次，加载时，对类的静态方法、静态变量、静态初始化块进行初始化。只有在新建一个对象时，才会按先父类后子类的顺序初始化类的初始化块、构造函数。
9、方法和变量在继承时的覆盖和隐藏
（1）同名的实例方法被覆盖，同名的类方法（静态方法）被隐藏。
（2）隐藏和覆盖的区别：子类对象转换成父类后，能够访问父类被隐藏的变量和方法，但不能访问被覆盖的变量和方法。
10、排序
（1）接口
public interface ISortNumber {
/**
* 升序排序
* @param intArray
* @return
*/
public int[] sortASC(int[] intArray);
}
（2）选择排序
public class SelectionSort implements ISortNumber{
public SelectionSort() {
}
@Override
public int[] sortASC(int[] intArray) {
if(intArray==null){
return null;
}
int[] srcDatas=(int[])intArray.clone();
int size=srcDatas.length;
for(int i=0;i<size;i++){
for(int j=i;j<size;j++){
if(srcDatas[i]>srcDatas[j]){
swap(srcDatas,i,j);
}
}
}
return srcDatas;
}
private void swap(int[] data,int src,int dest){
int temp=data[src];
data[src]=data[dest];
data[dest]=temp;
}
}
（3）冒泡排序
public class BubbleSort implements ISortNumber{
public BubbleSort() {
}
@Override
public int[] sortASC(int[] intArray) {
if(intArray==null){
return null;
}
int[] srcDatas=(int[]) intArray.clone();
boolean changedPosition=true;
int comparedTimes=0;
int maxComparedTimes=srcDatas.length-1;
while((comparedTimes<maxComparedTimes) && (changedPosition)){
for(int i=0;i<(maxComparedTimes-comparedTimes);i++){
changedPosition=false;
if(srcDatas[i]>srcDatas[i+1]){
swap(srcDatas,i,i+1);
changedPosition=true;
}
}
comparedTimes++;
}
return srcDatas;
}
private void swap(int[] data,int src,int dest){
int temp=data[src];
data[src]=data[dest];
data[dest]=temp;
}
}
（4）线性插值排序
public class LinearInsertSort implements ISortNumber{
public LinearInsertSort() {
}
@Override
public int[] sortASC(int[] intArray) {
if(intArray==null){
return null;
}
int[] srcDatas=(int[])intArray.clone();
int size=srcDatas.length;
int temp=0;
int index=0;
for(int i=1;i<size;i++){
temp=srcDatas[i];
index=i;
while((index>0) && (temp<srcDatas[index-1])){
srcDatas[index]=srcDatas[index-1];
index--;
}
}
return srcDatas;
}
}
（5）快速排序
public class QuickSort implements ISortNumber{
public QuickSort() {
}
@Override
public int[] sortASC(int[] intArray) {
if(intArray==null){
return null;
}
int[] srcDatas=(int[])intArray.clone();
return this.quickSort(srcDatas,0,srcDatas.length-1);
}
private int[] quickSort(int[] srcDatas,int first,int last){
if(first<last){
int pos=partion(srcDatas,first,last);
quickSort(srcDatas,first,pos-1);
quickSort(srcDatas,pos+1,last);
}
return srcDatas;
}
//根据数组的第一个数分治
//比第一个数大的往后排，比第一个数小的往前排
private int partion(int[] srcDatas,int first,int last ){
int temp=srcDatas[first];
int pos=first;
for(int i=first+1;i<=last;i++){
if(srcDatas[i]<temp){
pos++;
swap(srcDatas,pos,i);
}
}
swap(srcDatas,first,pos);
return pos;
}
private void swap(int[] data,int src,int dest){
int temp=data[src];
data[src]=data[dest];
data[dest]=temp;
}
}
10、Singleton模式
（1）模式1
public class SingletonA {
private static int id=1;
private static SingletonA instance=new SingletonA();
private SingletonA() {
}
public static SingletonA getInstance(){
return instance;
}
public synchronized int getId(){
return id;
}
}
（2）模式2（lazy initialization）
public class SingletonA {
private static int id=1;
private static SingletonA instance=null;
private SingletonA() {
}
public static SingletonA getInstance(){
if(instance==null){
instance=new SingletonA();
}
return instance;
}
public synchronized int getId(){
return id;
}
}
在getInstance方法声明中使用synchronized(同步)关键字，以保证同一时刻只有一个进程进入该方法。保证只创建一个对象。
11、Factory模式
（1）用一个接口抽象产品功能，所有具体的产品都实现该接口
（2）Factory类定义一个创建产品的方法，参数为产品的具体类型，返回一个产品接口对象。用户通过产品接口使用产品功能。
如下面的例子，该Factory类可以根据用户需求创建不同的用于排序的产品。
public class Factory {
public static final String SELECTION_SORT="selection";
public static final String BUBBLE_SORT="bubble";
public static final String LINEARINSERT_SORT="linearinsert";
public static final String QUICK_SORT="quick";
public static ISortNumber getOrderNumber(String id){
if(SELECTION_SORT.equalsIgnoreCase(id)){
return new SelectionSort();
}else if(BUBBLE_SORT.equalsIgnoreCase(id)){
return new BubbleSort();
}else if(LINEARINSERT_SORT.equalsIgnoreCase(id)){
return new LinearInsertSort();
}else if(QUICK_SORT.equalsIgnoreCase(id)){
return new QuickSort();
}else{
return null;
}
}
}
12、Adapter类
public class Printer {
public static void printIntArray(int[] array){
if(array!=null){
for(int i=0;i<array.length;i++){
System.out.print(array[i]+" ");
}
System.out.println();
}
}
}
public class PrinterAdapter extends Printer implements ISortNumber{
private ISortNumber mySort;
public PrinterAdapter(ISortNumber mySort) {
super();
this.mySort = mySort;
}
@Override
public int[] sortASC(int[] intArray) {
if(this.mySort!=null){
return this.mySort.sortASC(intArray);
}
return null;
}
}
PrinterAdapter是Adapter，将Printer和ISortNumber进行适配，具有两者定义的所有功能。
ISortNumber是Adaptee。Adapter的构造方法中串入一个具体的Adaptee对象，在实现Adaptee接口定义的方法中，调用Adaptee的相应方法。
Printer是目标类。
二、数字
13、数字与数字封装类的相互转换
（1）byte与Byte
byte b1=5;
Byte b2=new Byte(b1); //或者 Byte b2=Byte.valueOf(b1);
byte b3=b2.byteValue();
(2)int与Integer
int i1=5;
Integer i2=new Integer(i1);//或者 Integer i2=Integer.valueof(i1);
int i3=i2.intValue();
14、格式化数字，使用DecimalFormat类。
DecimalFormat df=new DecimalFormat();
double data=1234.4650238903;
String pattern="0.0";//显示格式
df.applyPattern(pattern);
String str=df.format(data);//格式化后为1234.5
//pattern ="00000.000 kg" 格式化为001234.465 kg
//pattern ="##000.000 kg" 格式化为1234.465 kg
//pattern ="-000.000" 格式化为-1234.465
//pattern ="-0,000.000" 格式化为-1,234.465
//pattern ="0.00E000" 格式化为1.23E003
//pattern ="0.00%" 格式化为123446.50%
//pattern ="0.00\u2030" 格式化为1234465.02‰,显示为千分数
15、数字的舍入
用BigDecimal类的setScale方法来实现，支持不同的舍入模式。
16、数制的转换
Integer或Long的toString(int i,int radix)、toBinaryString()、toOctalString()、toHexString()等方法。
17、生成随机数，用Random类来实现。
18、高精度运算
使用BigInteger和BigDecimal类。
下例，计算阶乘。
public BigInteger getFactorial(int n){
if((n<0)||(n>17)){
return new BigInteger("-1");
}else if(n==0 || n==1){
return new BigInteger("1");
}else{
BigInteger result=new BigInteger("n");
do{
result.multiply(new BigInteger(new Integer(--n).toString()));
}while(n>1);
return result;
}
}
BigInteger和BigDecimal类都是不可变的，每一步运算都会产生一个新对象，不适合大量的数学运算。这两个类常常用在商业计算的精确大整数和小数。
要获得精确小数，应使用String来构造BigDecimal，避免使用double来构造，因为double类型并不精确。
从数值上比较两个BigDecimal的值时，应使用compareTo方法，而不是equals方法，因为后者会认为0.10和0.1不相等。
三、数组与集合
1、Arrays
填充数组,
int[] array0=new int[10];
Arrays.fill(array0,3);//给数组所有元素赋值为5
Arrays.fill(array0,2,5,7);//给array0[2]~array0[4]赋值为7
排序
Arrays.sort(array0,2,7);//将array0[2]~array0[6]排序
Arrays.sort(array0);//整个数组排序
2、求质数
/**
* 用筛选法求range范围内的质数
* @param range 范围的上限
* @return
*/
private boolean[] sieve(int range){
if(range<0){
return null;
} boolean[] isPrime=new boolean[range+1];
isPrime[1]=false;
Arrays.fill(isPrime, 2, range+1, true); int n=(int)Math.sqrt(range);
for(int i=1;i<=n;i++){
if(isPrime[i]){
//如果i是质数，则i的倍数不是质数
for(int j=2*i;j<=range;j+=i){
isPrime[j]=false;
}
}
}
return isPrime;
}
3、动态调整数组的长度
新建一个新的数组，然后将原数组的数据拷贝到新数组中。
Integer[] result=new Integer[src.length+length];
System.arraycopy(src,0,result,0,src.length);
4、矩阵
用double二维数组创建矩阵，并实现矩阵的加减乘除算法。
public class Matrix implements Cloneable{
private double[][] matrixData;
public Matrix() {
this.init();
}
public Matrix(double[][] matrixData) {
if(!this.canConvert2Matrix(matrixData)){
this.init();
} else{
this.matrixData = this.cloneArray(matrixData);
}
}
private void init(){
this.matrixData=new double[][]{
{1.0,0.0,0.0},
{0.0,1.0,0.0},
{0.0,0.0,1.0}};
}
private boolean canConvert2Matrix(double[][] matrixData){
if(matrixData==null){
return false;
}
for(int i=0;i<matrixData.length-1;i++){
if(matrixData[i].length!=matrixData[i+1].length){
return false;
}
}
return true;
}
private double[][] cloneArray(double[][] src){
if(src==null){
return null;
}
return (double[][]) src.clone();
}
/**
* 矩阵相加
* @param b
* @return
*/
public Matrix add(Matrix b){
if(b==null){
return null;
}
Matrix c=null;
double[][] bData=b.getMatrixData();
if(this.matrixData.length!=bData.length
|| this.matrixData[0].length!=bData[0].length){
System.out.println("两个矩阵长度不一致，不能相加");
return c;
}
double[][] cData=new double[this.matrixData.length][this.matrixData[0].length];
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<this.matrixData[0].length;j++){
cData[i][j]=this.matrixData[i][j]+bData[i][j];
}
}
c=new Matrix(cData);
return c;
}
/**
* 矩阵相减
* @param b
* @return
*/
public Matrix sub(Matrix b){
if(b==null){
return null;
}
Matrix c=null;
double[][] bData=b.getMatrixData();
if(this.matrixData.length!=bData.length
|| this.matrixData[0].length!=bData[0].length){
System.out.println("两个矩阵长度不一致，不能相减");
return c;
}
double[][] cData=new double[this.matrixData.length][this.matrixData[0].length];
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<this.matrixData[0].length;j++){
cData[i][j]=this.matrixData[i][j]-bData[i][j];
}
}
c=new Matrix(cData);
return c;
}
/**
* 矩阵数乘
* @param num
* @return
*/
public Matrix multiplyNum(double num){
double[][] cData=new double[this.matrixData.length][this.matrixData[0].length];
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<this.matrixData[0].length;j++){
cData[i][j]=this.matrixData[i][j] * num;
}
}
return new Matrix(cData);
}
/**
* 矩阵乘法
* @param b
* @return
*/
public Matrix multiply(Matrix b){
if(b==null)
return null;
double[][] bData=b.getMatrixData();
if(this.matrixData[0].length!=bData.length){
System.out.println("矩阵的A的列数不等于矩阵B的行数，不能相乘");
return null;
}
double[][] cData=new double[this.matrixData.length][bData[0].length];
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<bData[0].length;j++){
cData[i][j]=0;
for(int k=0;k<this.matrixData[0].length;k++){
cData[i][j]+=this.matrixData[i][k]*bData[k][j];
}
}
}
return new Matrix(cData);
}
/**
* 矩阵除法
* @param b
* @return
*/
public Matrix divide(Matrix b){
if(b==null){
return null;
}
if(!this.isSquareMatrix()
|| (!b.isSquareMatrix())
|| (this.matrixData.length!=b.getMatrixData().length)){
System.out.println("不能相除");
return null;
}
Matrix c=b.inverseMatrix();
if(c!=null)
return this.multiply(c);
else{
System.out.println("不能相除");
return null;
}
}
/**
* 逆矩阵
* @return
*/
public Matrix inverseMatrix() {
if(!this.isSquareMatrix()){
System.out.println("不是方阵，不能求逆");
return null;
}
Matrix tempM=this.appendUnitMatrix();
double[][] tempData=tempM.getMatrixData();
int line=0;
double bs=0;
double swap=0;
for(int i=0;i<tempData.length;i++){
if(tempData[i][i]==0){
if(++line>=tempData.length){
System.out.println("没有逆矩阵");
return null;
}
for(int j=0;j<tempData[0].length;j++){
swap=tempData[i][j];
tempData[i][j]=tempData[line][j];
tempData[line][j]=swap;
}
continue;
}
if(tempData[i][i]!=1){
bs=tempData[i][i];
for(int j=tempData[0].length-1;j>=0;j--){
tempData[i][j]/=bs;
}
for(int iNow=i+1;iNow<tempData.length;iNow++){
for(int j=tempData[0].length-1;j>=i;j--){
tempData[iNow][j]-=tempData[i][j]*tempData[iNow][i];
}
}
}
}
//将左边矩阵变为单位矩阵
for(int i=0;i<tempData.length-1;i++){
for(int iNow=i;iNow<tempData.length-1;iNow++){
for(int j=tempData[0].length-1;j>=0;j--){
tempData[i][j]-=tempData[i][iNow+1]*tempData[iNow+1][j];
}
}
}
//右边部分为逆矩阵
double[][] cData=new double[this.matrixData.length][this.matrixData[0].length];
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<this.matrixData[0].length;j++){
cData[i][j] =tempData[i][j+this.matrixData[0].length];
}
}
return new Matrix(cData);
}
/**
* 给矩阵右边加上单位矩阵
* @return
*/
private Matrix appendUnitMatrix(){
double[][] cData=new double[this.matrixData.length][this.matrixData[0].length*2];
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<this.matrixData[0].length*2;j++){
if(j<this.matrixData[0].length){
cData[i][j]=this.matrixData[i][j];
}else{
if((j-this.matrixData[0].length)==i){
cData[i][j]=1.0;
}else{
cData[i][j]=0.0;
}
}
}
}
return new Matrix(cData);
}
/**
* 转置矩阵
* @return
*/
public Matrix transposeMatrix(){
double[][] cData=new double[this.matrixData[0].length][this.matrixData.length];
for(int i=0;i<this.matrixData[0].length;i++){
for(int j=0;j<this.matrixData.length;j++){
cData[i][j]=this.matrixData[j][i];
}
}
return new Matrix(cData);
}
/**
* 矩阵是否为方阵
* @return
*/
public boolean isSquareMatrix(){
if(this.matrixData.length==this.matrixData[0].length){
return true;
}
return false;
}
public double[][] getMatrixData(){
return this.cloneArray(this.matrixData);
}
public void setMatrixData(double[][] matrixData){
if(this.canConvert2Matrix(matrixData)){
this.matrixData=this.cloneArray(matrixData);
}
}
@Override
public String toString() {
DecimalFormat df=new DecimalFormat("0.00");
StringBuffer sb=new StringBuffer("");
for(int i=0;i<this.matrixData.length;i++){
for(int j=0;j<this.matrixData[0].length;j++){
sb.append(df.format(this.matrixData[i][j])).append(" ");
}
sb.append("\n");
}
return sb.toString();
}
@Override
public int hashCode() {
return this.toString().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Matrix other = (Matrix) obj;
if (!Arrays.deepEquals(this.matrixData, other.matrixData)) {
return false;
}
return true;
}
@Override
protected Object clone(){
try{
Matrix matrix=(Matrix) super.clone();
matrix.setMatrixData(this.matrixData);
return matrix;
}catch(CloneNotSupportedException e){
}
return null;
}
}
5、ArrayList、Vector和LinkedList
（1）ArrayList、Vector都是用数组实现，不同的是Vector支持线程同步
（2）LinkedList使用链表结构存储数据，方便操作列表头和列表尾元素。
（3）可以为List生成ListIterator，支持双向遍历。
6、生成不重复的随机数序列
（1）排除法
如果新生成的数字不包含在结果列表中，则将数字添加到列表，否则，重新生成随机数。
（2）筛选法
将所有可能的数字放到候选列表中，将生成的随机数k作为下标，对应的候选列表中的数字添加到结果列表中，并从候选列表中删除。
7、用LinkedList可以方便地实现Queue
8、对List进行排序，用Collections.sort()方法，可以设置自定义的比较器(实现Comparator接口)。
9、HashSet
采用散列函数对元素进行排序。存入HashSet中的对象必须定义hashCode方法。
10、TreeSet
采用红黑树的数据结构进行排序，可以提取有序的序列。存入TreeSet中的自定义类对象需要实现Comparable接口并定义compareTo方法。
11、LinkedHashSet
使用链表维护元素的插入次序。元素的次序就是插入时的次序。
12、数组、List和Set之间的相互转化
(1)List转化为数组
String[] strArray=(String[])list.toArray(new String[list.size()]);
(2)Set转化为数组
String[] strArray=(String[])set.toArray(new String[set.size()]);
(3)数组转化为List
list=Arrays.asList(strArray);
(4)数组转化为Set，先转为List，再构造Set
set=new HashSet(Arrays.asList(strArray));
13、Map 键值对存储
（1）HashMap
不支持线程同步，键或值可以为null。
（2）HashTable
键或值都不能为null。支持线程同步。
（3）LinkedHashMap
保存记录的插入次序。
（4）TreeMap
记录按照Key来排序。
14、对Map排序
（1）其他Map转换成TreeMap，便可以进行按Key排序。
（2）TreeMap默认升序排列，可以指定比较器。
15、Properties属性文件
能从输入流(文件)中获取键值对信息，也可以将键值对信息存放到输出流（文件）中。
Properties props=new Properties();
//存放数据
props.setProperty("name","zhangsan");
//读取数据
String str=props.getProperty("name");
//保存到输出流
FileOutputStream out=new FileOutputStream("C:/test.properties");
props.store(out,"test");
out.close();
//从输出流中加载数据
Properties newProps=new Properties();
FileInputStream in=new FileInputStream("C:/test.properties");
newProps,load(in);
in.close();
四、字符串
1、String是不变类，修改String会得到新的String对象，如果要频繁修改字符串，应使用StringBuilder类。
2、IP地址转换为整数
public static long ipToLong(String strIP){
long[] ip=new long[4];
int position1=strIP.indexOf(".");
int position2=strIP.indexOf(".",position1+1);
int position3=strIP.indexOf(".",position2+1);
ip[0]=Long.parseLong(strIP.substring(0, position1));
ip[1]=Long.parseLong(strIP.substring(position1+1, position2));
ip[2]=Long.parseLong(strIP.substring(position2+1, position3));
ip[3]=Long.parseLong(strIP.substring(position3+1));
return (ip[0]<<24)+(ip[1]<<16)+(ip[2]<<8)+ip[3];
}
public static String longToIP(long longIP){
StringBuilder sb=new StringBuilder("");
sb.append(String.valueOf(longIP>>>24)).append(".");
sb.append(String.valueOf((longIP&0x00FFFFFF)>>>16)).append(".");
sb.append(String.valueOf((longIP&0x0000FFFF)>>>8)).append(".");
sb.append(String.valueOf(longIP&0x000000FF));
return sb.toString();
}
3、更改字符串的编码
先调用String的getBytes方法对字符串进行解码，再用得到的字节数组和新的字符编码构造一个新的String对象。
4、对字符串进行MD5编码
MD5是一种不可逆的加密方式，常用于管理账户信息数据库，数据库存储的是用户密码的MD5编码，这样可以防止用户的密码信息被管理员知道。
public static String encodeByMD5(String originString){
String[] hexDigits={"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
if(originString!=null){
try{
MessageDigest md=MessageDigest.getInstance("MD5");
byte[] result=md.digest(originString.getBytes());
StringBuilder sb=new StringBuilder();
for(int i=0;i<result.length;i++){
int n=result[i];
if(n<0)
n=256+n;
int d1=n/16;
int d2=n%16;
sb.append(hexDigits[d1]+hexDigits[d2]);
}
return sb.toString();
}catch(Exception e){
}
}
return null;
}
5、制作命令行程序
难点在于解析命令行参数，可以使用Apache组织的cli项目的类库来完成。
6、StringTokenizer可以使字符串分写成多个标记。
7、使用正则表达式操作字符串
（1）java.util.regex.Pattern类 对正则表达式字符串进行编译
（2）java.util.regex.Matcher类，通过解释Pattern对字符串进行匹配，find方法返回查找匹配的结果，matches方法返回精确匹配的结果。
8、使用正则表达式验证电话号码格式
public static boolean isMatch(String phoneNum){
String patternStr="^([0-9]{3}-?[0-9]{8}) |([0-9]{4}-?[0-9]{7})$";
if(phoneNum!=null){
return phoneNum.matches(patternStr);
}
return false;
}
五、异常处理
1、避免使用异常
可以提前检测语句的使用条件，避免异常出现
2、不要为每个可能出现异常的语句单独设置try catch，尽量将这些语句都放在一个try块中。
3、避免在方法中抛出或捕获RuntimeException和Error
4、尽量catch具体的异常，不要总是catch Exception
5、不能处理的异常要往外抛
6、不要在循环体中使用try...catch
六、线程
1、线程的互斥
在某一个时刻，只允许一个线程访问对象的临界区
。如果一个对象有多个方法都要修改同一个变量的值，应将这些方法置为synchronized。
2、线程协作
wait、notify、notifyAll等关键字必须放在synchronized代码块中。
static class Printer extends Thread{
Vector task=new Vector();
boolean running=false;
public void start(){
this.running=true;
super.start();
}
@Override
public void run() {
try{
while(running){
synchronized(this){
while((task.size()==0)&&running){
//如果任务为空，线程允许运行，则等待任务
//进入等待状态，释放对象锁
wait();
}
}
//执行任务
System.out.println("print the task:"+task.remove(0));
}
}catch(InterruptedException e){
e.printStackTrace();
}
}
//添加打印任务
public void adddTask(String str){
synchronized(this){
this.task.add(str);
//唤醒等待的线程
notify();
}
}
//停止线程
public void stopPrinter(){
this.running=false;
synchronized(this){
//唤醒其他等待的线程
notify();
}
}
}
3、join
调用子线程的join方法，表示当前线程必须等待子线程运行结束，才能继续运行。
4、消费者与生产者
用线程模拟消费者和生产者，不断从仓库类中消费/生产产品。
在仓库类中，消费产品时，如果产品数量为0，则wait，使消费线程等待，当有新产品存入时，notify，唤醒等待的消费线程。同理，生产产品时，如果产品数量达到上限，则wait，使生产线程等待，当有产品被消费后，notify，唤醒等待的生产线程。
注意:调用某个对象的wait、notify、notifyAll等方法时，必须用synchronized先获得对象锁，否则会抛出IllegalMonitorStateException异常。
//(1)产品
public class Product {
private String name; public Product(String name) {
this.name = name;
}
}
//(2)消费者线程
public class Consumer extends Thread {
private Warehouse warehouse;
private boolean running=false; public Consumer(Warehouse warehouse, String name) {
super(name);
this.warehouse = warehouse;
} public boolean isRunning() {
return running;
} @Override
public synchronized void start() {
this.running=true;
super.start();
} @Override
public void run() {
Product product;
try{
while(running){
product=warehouse.getProduct();
sleep(500);
}
}catch(InterruptedException e){
e.printStackTrace();
}
} public void stopConsumer(){
synchronized(warehouse){
this.running=false;
warehouse.notifyAll();
}
}
}
//（3）生产者线程
public class Producer extends Thread{ private Warehouse warehouse;
private static int productName=0;
private boolean running=false; public Producer(Warehouse warehouse, String name) {
super(name);
this.warehouse = warehouse;
} public boolean isRunning() {
return running;
} @Override
public synchronized void start() {
this.running=true;
super.start();
} @Override
public void run() {
Product product;
try{
while(running){
product=new Product("pro"+(++productName));
this.warehouse.storageProduct(product);
sleep(300);
}
}catch(InterruptedException e){
e.printStackTrace();
}
} public void stopProducer(){
synchronized(warehouse){
this.running=false;
warehouse.notifyAll();
}
} }
//(4)仓库类
public class Warehouse {
private static int CAPACITY=11;//仓库容量
private Product[] products; private int front=0;//当前第一个未被消费的产品下标
private int rear=0;//当前最后一个未被消费的产品下标+1; public Warehouse() {
this.products = new Product[CAPACITY];
} public Warehouse(int capacity) {
this();
if(capacity>0){
CAPACITY=capacity+1;
this.products = new Product[CAPACITY];
}
} public Product getProduct() throws InterruptedException {
synchronized(this){
boolean consumerRunning=true;
Thread currentThread=Thread.currentThread();
if(currentThread instanceof Consumer){
consumerRunning=((Consumer)currentThread).isRunning();
}else{
return null;
}
//仓库中没有产品，则消费线程等待
while((front==rear) && consumerRunning){
wait();
consumerRunning=((Consumer)currentThread).isRunning();
} if(!consumerRunning){
return null;
} Product product=products[front];
front=(front+1+CAPACITY) % CAPACITY;
System.out.println("Concumer"+Thread.currentThread().getName());
System.out.println("剩余产品"+(rear+CAPACITY-front)%CAPACITY);
notify();
return product;
}
} public void storageProduct(Product product) throws InterruptedException {
synchronized(this){
boolean producerRunning=true;
Thread currentThread=Thread.currentThread();
if(currentThread instanceof Producer){
producerRunning=((Producer)currentThread).isRunning();
}else{
return;
}
//仓库中没有产品，则消费线程等待
while(((rear+1)%CAPACITY==front) && producerRunning){
wait();
producerRunning=((Producer)currentThread).isRunning();
} if(!producerRunning){
return;
} products[rear]=product;
rear=(rear+1)%CAPACITY;
System.out.println("Producer"+Thread.currentThread().getName());
System.out.println("剩余产品"+(rear+CAPACITY-front)%CAPACITY);
notify();
}
} }
5、两个同时启动的线程，通常优先级高的线程会先运行。
6、守护线程(Daemon线程)
Thread的setDaemon方法设置线程是否为守护线程。必须在调用start之前调用该方法，否则无效。
只有当程序中所有的非守护线程都结束时，守护线程才会无条件地立即结束，并且不会调用finally中的语句。
7、线程池
将执行某一类任务的线程放在线程池中，有任务要执行时，从池中取出一个空闲线程来处理任务，处理结束后，再将线程池放入池中。
自定义线程池
（1）任务接口
public interface Task {
public void perform() throws Exception;
}
（2）自定义任务类
public class MyTask implements Task {
private int taskId=0;
public MyTask(int id) {
this.taskId=id;
}
@Override
public void perform() throws Exception {
System.out.println("task "+taskId+" begin");
try{
Thread.sleep(1000);
}catch(InterruptedException e){
}
System.out.println("task "+taskId+" end");
}
}
（3）线程池
public class MyThreadPool extends ThreadGroup{
private boolean isAlive;
private LinkedList taskQueue;
private int threadId;
private static int threadPoolId;
public MyThreadPool(int numThreads) {
super("ThreadPool-"+(threadPoolId++));
super.setDaemon(true); //线程池中所有线程被销毁时，线程池自动销毁
this.isAlive=true;
this.taskQueue=new LinkedList();
for(int i=0;i<numThreads;i++){
new PooledThread().start();
}
}
//内部类，工作线程
private class PooledThread extends Thread{
public PooledThread() {
super(MyThreadPool.this,"PooledThread-"+(threadId++));
}
@Override
public void run() {
while(!isInterrupted()){
Task task=null;
try{
task=getTask();
}catch(InterruptedException e){
}
if(task==null){
return;
}
try{
task.perform();
}catch(Throwable t){
uncaughtException(this,t);
}
}
}
}
protected synchronized Task getTask() throws InterruptedException{
if(!this.isAlive){
return null;
}
while(this.taskQueue.size()==0){
wait();
}
return (Task)this.taskQueue.removeFirst();
}
public synchronized void performTask(Task task){
if(!this.isAlive){
throw new IllegalStateException();
}
if(task!=null){
this.taskQueue.add(task);
notify();
}
}
//关闭线程池，所有线程停止，不再执行任务
public synchronized void close(){
if(isAlive){
this.isAlive=false;
this.taskQueue.clear();
this.interrupt();
}
}
//关闭线程池，等待所有任务执行完成
public void join(){
synchronized(this){
this.isAlive=false;
this.notifyAll();
}
Thread[] threads=new Thread[this.activeCount()];
//将线程池中活动线程拷贝到新的线程组中
int count=this.enumerate(threads);
for(int i=0;i<count;i++){
try{
threads[i].join();
}catch(InterruptedException e){
}
}
}
}
8、当线程进入对象的synchronized代码块时，占有了该资源，直到退出该代码块或者调用wait方法，才会释放该资源，在此期间，其他线程将不能进入该代码块。synchronized尝试占有对象资源，如果不能占有，将一直等待。
线程相互占有对方等待的资源且都不主动释放所占有的资源时，将发生线程死锁。
9、定时器的使用
（1）实现一个继承TimerTask抽象类的自定义类MyTimerTask
（2）结合Timer实现定时执行任务的功能
Timer timer=new Timer();
TimerTask myTask1=new MyTimerTask();
timer.schedule(myTask1,200,300);//200ms后执行myTask1，之后每隔300ms执行一次myTask1
（3）中止定时任务
timer.cancle();
六、反射
1、反射（Reflection）允许Java程序对自身进行检查，并能直接操作程序的内部属性。
2、instanceof 在运行时判断对象的类型
3、java.lang.reflect包实现了java的反射机制。
七、网络编程
1、URL通信
2、Socket通信
3、UDP通信