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);
}