自己写的一点代码(双色球)

import java.io.File;
import java.io.IOException;

import com.analysis.abs.Analyze;
import com.analysis.impl.AnalyzeImpl;
import com.analysis.strategy.Filter;
import com.analysis.strategy.impl.FilterSerial6;
import com.analysis.strategy.impl.OutStrategyImpl;
import com.analysis.strategy.impl.Strategy;

public class RUN {

	/**
	 * @param args
	 * @throws IOException 
	 */
	public static void main(String[] args) throws IOException {
		Filter filter = new FilterSerial6(null);
		Analyze analyze = new AnalyzeImpl(new Strategy(filter), new OutStrategyImpl());
		analyze.analyze(new File("E:\\Mon\\History Data.txt"));
		
//		Class cls = int[].class;
		//if(cls.getSuperclass() != Object.class){
//			System.out.println(cls.getInterfaces()[0]);
		//}
		
	}

}

package com.analysis.abs;

import java.io.File;
import java.io.IOException;

public interface Analyze {

	public void analyze(File file)throws IOException;
}

package com.analysis.impl;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import com.analysis.abs.Analyze;
import com.analysis.strategy.IStrategy;
import com.analysis.strategy.OutStrategy;

public class AnalyzeImpl implements Analyze {
	private IStrategy strategy;
	
	private OutStrategy out;
	
	public AnalyzeImpl(IStrategy strategy, OutStrategy out){
		this.strategy = strategy;
		this.out = out;
	}
	
	@Override
	public void analyze(File file) throws IOException {
		List<int[]> historyData = analyzeFile(file);
		
		List<int[]> data = strategy.generate(historyData);
		
		out.write(data);
	}

	private List<int[]> analyzeFile(File file) throws IOException{
		
		BufferedReader reader = new BufferedReader(new FileReader(file));
		String line = reader.readLine();
		List<int[]> records = new ArrayList<int[]>();
		while(line != null){
			int[] record = analyzeRecord(line);
			records.add(record);
			line = reader.readLine();
		}
		return records;
	}
	
	private int[] analyzeRecord(String line){
		String record = line.substring(0, 39);
		String[] arr = record.split(" ");
		
		int[] data = new int[7];
		
		for(int index = 0; index < 7; index ++){
			data[index] = Integer.parseInt(arr[2 + index]);
		}
		
		return data;
	}
}

package com.analysis.strategy;

import java.util.List;

public interface Filter {

	public List<int[]> filter(List<int[]> data);
	
	public int[] filter(int[] data);
}

package com.analysis.strategy;

import java.util.List;

public interface IStrategy {
	
	public List<int[]> generate(List<int[]> historyData);
}

package com.analysis.strategy;

import java.util.List;

public interface OutStrategy {

	public void write(List<int[]> data);
}

package com.analysis.strategy.impl;

import java.util.ArrayList;
import java.util.List;

import com.analysis.strategy.Filter;

public abstract class FilterAbs {

	private Filter filter;
	
	public FilterAbs(Filter filter){
		this.filter = filter;
	}
	
	public List<int[]> filter(List<int[]> data){
		if(filter != null){
			data = filter.filter(data);
		}
		
		return doFilter(data);
	}
	
	public int[] filter(int[] data){
		List<int[]> arr = new ArrayList<int[]>();
		arr.add(data);
		List<int[]> result = filter(arr);
		if(result.size() > 0){
			return result.get(0);
		}
		return null;
	}
	
	private List<int[]> doFilter(List<int[]> data){
		List<int[]> result = new ArrayList<int[]>();
		for(int[] record : data){
			if(!isSerial(record)){
				result.add(record);
			}
		}
		return result;
	}
	
	protected abstract boolean isSerial(int[] record);
	
}

package com.analysis.strategy.impl;

import com.analysis.strategy.Filter;

public class FilterSerial5 extends FilterAbs implements Filter {

	public FilterSerial5(Filter filter) {
		super(filter);
	}

	@Override
	protected boolean isSerial(int[] record) {
		boolean flag = true;
		
		for(int num : record){
			
		}
		
		return flag;
	}

	
}

package com.analysis.strategy.impl;

import com.analysis.strategy.Filter;

public class FilterSerial6 extends FilterAbs implements Filter {

	public FilterSerial6(Filter filter) {
		super(filter);
	}

	@Override
	protected boolean isSerial(int[] record) {
		boolean flag = true;
		for(int index = 0; index < record.length - 2; index ++){
			if(record[index] != record[index] - 1){
				flag = false;
				break;
			}
		}
		
		return flag;
	}

//	@Override
//	public List<int[]> filter(List<int[]> data) {
//		List<int[]> result = new ArrayList<int[]>();
//		
//		for(int[] records : data){
//			boolean flag = true;
//			for(int index = 0; index < records.length - 1; index ++){
//				if(records[index] != records[index] - 1){
//					flag = false;
//				}
//			}
//			
//			if(flag){
//				result.add(records);
//			}
//		}
//		
//		return result;
//	}
}

package com.analysis.strategy.impl;

import java.util.List;

import com.analysis.strategy.OutStrategy;

public class OutStrategyImpl implements OutStrategy {

	@Override
	public void write(List<int[]> data) {
		for(int[] record : data){
			for(int num : record){
				System.out.print(num + " - ");
			}
			System.out.println();
		}
		
	}

}

package com.analysis.strategy.impl;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import com.analysis.strategy.Filter;
import com.analysis.strategy.IStrategy;

public class Strategy extends StrategyAbs implements IStrategy {


	public static final int NUM = 500;
	
	public Strategy(Filter filter) {
		super(filter);
	}

	@Override
	protected List<int[]> create(List<int[]> historyData) {
		List<int[]> result = new ArrayList<int[]>();
		
		do{
			int[] data = create();
			if(filter.filter(data) != null && !historyData.contains(data)){
				result.add(data);
			}
		}while(result.size() < NUM);
		return result;
	}
	
	private int[] create(){
		List<Integer> result = new ArrayList<Integer>();
		while(result.size() < 7){
			int rad = (int) (Math.random() * 32);
			
			if(rad == 0 || result.contains(rad) || (result.size() == 6 && rad > 16)){
				continue;
			}
			
			result.add(rad);
		}
		
		return toArray(result);
	}
	
	private int[] toArray(List<Integer> arg){
		int[] res = new int[7];
		for(int index = 0; index < 7; index ++){
			res[index] = arg.get(index);
		}
		int temp = res[6];
		res[6] = 32;
		Arrays.sort(res);
		res[6] = temp;
		
		return res;
	}
}

package com.analysis.strategy.impl;

import java.util.List;

import com.analysis.strategy.Filter;

public abstract class StrategyAbs {

	protected Filter filter;
	
	protected final static int[] red = new int[32];
	
	protected final static int[] blue = new int[16];
	static{
		for(int index = 1; index <= 32; index ++){
			red[index - 1] = index;
		}
		
		for(int index = 1; index <= 16; index ++){
			blue[index - 1] = index;
		}
	}
	
	public StrategyAbs(Filter filter){
		this.filter = filter;
	}
	
	public List<int[]> generate(List<int[]> historyData){
		List<int[]> result = create(historyData);
		
		return filter.filter(result);
	}
	
	protected abstract List<int[]> create(List<int[]> historyData);
}