Combinationsimport java.io.File;
import java.io.Serializable;


public class Combinations implements Serializable{
	/**
	 * 
	 */
	private static final long serialVersionUID = 6509436857839528414L;
	
	private int min;
	private int max;
	private char[] chars;// 字符数组
	private int charLen;// 字符串长度

	private String path ;
	private String trueStr ;
	private IOUtil iou;
	

	public Combinations() {
		this.min = 1;
		this.max = trueStr.length() ;
		this.charLen = trueStr.length();
		this.chars = trueStr.toCharArray();
	}


	public Combinations(String str, int min, int max, String path) {
		this.min = min;
		this.max = max;
		this.trueStr = str ;
		this.charLen = str.length();
		this.chars = str.toCharArray();
		iou = IOUtil.getInstence(path);
	}

	public void combination() {
		if (min > max) {
			int t = max;
			max = min;
			min = t;
		}
		for (int i = min; i <= max; i++) {
			combination(new StringBuffer(""), i);
		}
	}

	public void combination(StringBuffer str, int length) {
		if (length < 1) {
			System.out.println("长度小于1");
		}
		
		if (length == 1) {
			for (int i = 0; i < charLen; i++) {
				StringBuffer result = new StringBuffer(str);
				result.append(chars[i]);
				iou.put(result.toString(), 
						MD5Util.getMD5Str(result.toString()));
			}
		}

		if (length > 1) {
			for (int i = 0; i < charLen; i++) {
				StringBuffer temp = new StringBuffer(str);
				 combination(temp.append(chars[i]), length - 1);
			}
		}

	}
	
	/**
	 *setter getter  
	 */
	public IOUtil getIou() {
		return iou;
	}

	public void setIou(IOUtil iou) {
		this.iou = iou;
	}

	public int getMin() {
		return min;
	}

	public void setMin(int min) {
		this.min = min;
	}

	public int getMax() {
		return max;
	}


	public void setMax(int max) {
		this.max = max;
	}


	public char[] getChars() {
		return chars;
	}


	public void setChars(char[] chars) {
		this.chars = chars;
	}


	public int getCharLen() {
		return charLen;
	}


	public void setCharLen(int charLen) {
		this.charLen = charLen;
	}


	public String getPath() {
		return path;
	}


	public void setPath(String path) {
		this.path = path;
	}


	public String getTrueStr() {
		return trueStr;
	}


	public void setTrueStr(String trueStr) {
		this.trueStr = trueStr;
	}


	public static void main(String[] args) {
		String path = "F:"+File.separator+"md5"
						+File.separator+"md5.txt";
		Combinations ct = new Combinations("123456",1,4,path);
		ct.combination() ;
		ct.getIou().close() ;
	}


}

md5Utilimport java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


public class MD5Util {
	/**
	 * MD5 加密
	 */
	public static String getMD5Str(String str) {
		MessageDigest messageDigest = null;

		try {
			messageDigest = MessageDigest.getInstance("MD5");
			messageDigest.reset();
			messageDigest.update(str.getBytes("UTF-8"));
		} catch (NoSuchAlgorithmException e) {
			System.out.println("NoSuchAlgorithmException caught!");
			System.exit(-1);
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}

		byte[] byteArray = messageDigest.digest();

		StringBuffer md5StrBuff = new StringBuffer();

		for (int i = 0; i < byteArray.length; i++) {
			if (Integer.toHexString(0xFF & byteArray[i]).length() == 1)
				md5StrBuff.append("0").append(
						Integer.toHexString(0xFF & byteArray[i]));
			else
				md5StrBuff.append(Integer.toHexString(0xFF & byteArray[i]));
		}

		return md5StrBuff.toString();
	}

}

IO工具包

md5Utilimport java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class IOUtil implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1611785226109373473L;
	
	/*
	 * 接收key 和 value，然后写入一个map，计数器count++如果count>30，IOWrite进入flush；
	 * 判断文件是否大于30MB，则新建另一文件将map清空，将count设置为0；
	 */
	private String sourcePath;
	private String newPath;
	private int MAXSIZE = 30000;
	private int fileCount = 0; // 文件计数器
	private PrintWriter pw = null;
	private List<String> list = new ArrayList<String>();
	private static IOUtil instance = new IOUtil();

	private IOUtil() {
	}

	public static IOUtil getInstence(String path) {
		if (null == instance) {
			instance = new IOUtil();
		}
		instance.setSourcePath(path);
		instance.setNewPath(path);
		return instance;
	}

	public void put(String key, String value) {
		//判断path中的文件
		File file = new File(newPath) ;
		if(!file.exists()){
			try {
				file.createNewFile();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}else{
		}
		
		
		try {
			pw = new PrintWriter(new FileWriter(file));
		} catch (IOException e) {
			System.out.println("找不到文件" + e.getMessage());
		}
		
		if (list.size() <= MAXSIZE) {
			list.add(key + "  " + value);
		} else {
			Iterator<String> it = list.iterator();
			while (it.hasNext()) {
				pw.println(it.next());
			}
			// 刷新
			pw.flush();
			list.clear();
			this.fileCount++;
			this.newPath = this.sourcePath.substring(0, this.sourcePath
					.lastIndexOf('.'))
					+ "_"
					+ this.fileCount
					+ this.sourcePath.substring(this.sourcePath
							.lastIndexOf('.'));

		}
	}

	@SuppressWarnings("unchecked")
	public void close() {
		Iterator itor = null;
		if (list.size() > 0 && this.pw != null) {
			itor = list.iterator();
			while (itor.hasNext()) {
				pw.println(itor.next());
			}
			pw.close();
		}
		itor = null;
		pw = null;
	}

	/*******************
	 * getter setter
	 *******************/
	public String getSourcePath() {
		return sourcePath;
	}

	public void setSourcePath(String sourcePath) {
		this.sourcePath = sourcePath;
	}

	public String getNewPath() {
		return newPath;
	}

	public void setNewPath(String newPath) {
		this.newPath = newPath;
	}

	public PrintWriter getPw() {
		return pw;
	}

	public void setPw(PrintWriter pw) {
		this.pw = pw;
	}

}

1、参数顺序

public void info(int i, String str);

public void info(String str, int i);

2、以返回值区分重载方法

void f(){}

int f(){return 1;}

当int i = f();时就会调用int f(){return i;}方法

b、基本类型的重载

1、基本类型从一个“较小”的类型自动提提升成“较大”的类型

2、如果找不到有char型的方法，就会把char型提升为int型

2）不要使用受保护的域

3）使用继承实现“is-a”关系

4）除非所有继承的方法都有意义，否则不要使用继承

5）在覆盖方法的时候，不要心迹预期的行为

6）使用多态，而非类型信息

7）不要过多地使用反射

次序为:

1、static块内代码

2、自上而下的运行代码

3、在try{}catch(){}finally{}内，在try{}内遇到return关键字的时候，就马上跳到finally块内执行。

4、执行完毕finally{}块后就执行刚才的return语句

注意：finally内有return后，方法的其他地方就不能存在return。

public class Main {

	static{
		System.out.println("static");
	}
	
	public int test(){
		try{
			System.out.println("try") ;
			return 1 ;
		}catch(Exception e){
			System.out.println(e.getMessage()) ;
		}finally{
			System.out.println("finally") ;
		}
		return 3 ;
	}
	
	public static void main(String[] args) {
	    int i = new Main().test() ;
	    System.out.println("test:" + i );
	}
}

输出结果为：

static
try
finally
test:1

public class Hello{
  public static void main(String[] args ){
     System.out.println("hello world") ;
  }
}

使用文本编辑器输入以上内容，保存为java源文件扩展名:Hello.java
需要注意以下几点:
JAVA对大小写敏感(main 与 Main 代表不同的概念)
源代码的文件名必须与公有类的名字相同，并用.java作为扩展名
类的标准命名规范：类名是以大写字母开关的名词。
程序总是从main方法开始运行
一对花括号表示方法的开始与结束语。程序中每条语句都以分号结束（就算分号前没有写任何，一个分号也算一句语句）。
点号用来调用一个方法如 System.out.println() ;println()是一个方法。方法后的括号是必须，即便里什么也没有。

3.2 注释
单行注释：   //
多行注释：  /**/
第三种注释：以/**开始 以*/结束。这种注释用来自动生成文档

单行注释，注释内容从//开始到本行结尾  
多行注释内不能再包括 /**/。意思是他们不能嵌套

3.3数据类型
java是一种强类型语言。这就意味每一个变量声明一种类型。
数据类型的大小与运行代码的机器无关。
java一共有8种基本类型，4个整型，2个浮点类型，1个char类型，1个boolean类型（表示真假）
整型
整型又按照长度分为4种：int(4 byte) short(2 byte) long(8 byte) byte(1 byte)
使用long类型需要加后缀L（400000000L），十六进制数值有一个前缀0x（如0xCAFE），八进制有一个前缀0（如010对应八进制中的8，建议不要使用八进制常数，因为他比较容易混淆）
浮点型
浮点类型有两种：float(4 byte) double(8 byte)
浮点类型有一个后缀F（如2.12F），没有加后缀的（如2.12）默认为double类型，double后缀为D。
使用浮点类型需要注意：浮点数的计算会有误差。用2.0-1.1不会得到0.9，有可能得到0.89999。原因是浮点数点值是采用二进制系统表示的，而在二进制里无法精确的表示分数1/10。就像二进制无法精确的表示1/3一样。如果需要在数值计算中不含舍入误差，就应该使用BigDecimal类。
char类型
在程序设计中尽量不要使用此类型
boolean类型
boolean（布尔）类型有两个值：flase 和 true ; 这两个值不能和整型相互转换。
3.4变量
声明变量方式为:
  double salary;
  int vacat ;
  long earth ;
变量名必须是一个公字母开关的字母或数字序列。但，变量名命名不能为java保留字。
3.4.1 初始化变量
int i ; //申明变量i
i = 1 ; //给变量i赋值
也可以这样赋值 int y = 10 ;
3.4.2 常量
关键字final用于声明常量。常量只能被赋值一次。一旦被赋值之后，就不能够再更改了。习惯上常量名使用大写。
有一种常量叫类常量，这种常量可以在各个类之间使用。定义方法: static final int sf = 90 ;
实例：
Changliang.java
    public class Changliang {
        static final int ZHAI = 90 ;
    }
IOtest.java
public class IOtest {
    public static void main(String[] args) {
        System.out.println(Changliang.ZHAI + "") ;
    }
}

3.5 运算符
JAVA中运算符包括：+（加）-（减）*（乘）/（除）%（取模或者叫求余）
/ 号两边如果是整型，运算的结果会截去小数点后的数字。如 15/2=7。如果是浮点型则是这样15.0/2=7.5 。
% 符使用如15%2=1
为简化编程，JAVA像C语言一样有两元运算符。
     如{int i = 1 ;i = i+2 ;}可以简化为{int i = 1; i += 2;}
3.5.1自增自减
以下源码便说明：
IOtest.java
public  class IOtest {
    public strictfp static void main(String[] args) {
        System.out.println("i++，是先用后加。当然是在同一语句中") ;
        int i = 1 ;
        int y = 4 * i++ ;
        System.out.println("i=" + i) ;
        System.out.println("y=" + y) ;
        System.out.println("++i，是先加后用。当然是在同一语句中") ;
        i =1 ;
        int x = 4 * ++i ;
        System.out.println("i=" + i) ;
        System.out.println("x=" + x) ;
//       
//        i++，是先用后加。当然是在同一语句中
//        i=2
//        y=4
//        ++i，是先加后用。当然是在同一语句中
//        i=2
//        x=8
        //以下使用自增自减的效果是一样的
        int p = 1 ;
        System.out.println("p="+ p) ;
        p++ ;
        System.out.println("p="+ p) ;
        int q = 1 ;
        System.out.println("q="+ q) ;
        q++ ;
        System.out.println("q="+ q) ;
//        p=1
//        p=2
//        q=1
//        q=2
    }
}