数据挖掘 挖掘关联规则 Apriori算法

package apriori;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.junit.Test;

/**
* @author code
*/
//simulation Apriori
public class Ariori
{
private File file; //transaction 数据库文件
public static final int min_support = 2; //设置最小支持度
private Map<String,List<String>> map = new HashMap<String,List<String>>(); //存储 原始数据库数据
private Map<Integer,ArrayList<ArrayList<String>>> frequentSet = 
new HashMap<Integer,ArrayList<ArrayList<String>>>(); //存储 频繁项集 1->L[1] 2->L[2]

ArrayList<ArrayList<String>> cadidate = new ArrayList<ArrayList<String>>();//存放候选项集[[1,2],[3,4],[3,2]]
//存放支持度计数 
//[1,2,3]:5
//[2,3,4]:5
Map<ArrayList<String>,Integer> countMap = new HashMap<ArrayList<String>,Integer>(); 

public void setFile(String path)
{
this.file = new File(path);
}
public File getFile()
{
return this.file;
}

//将文件的内容存储到map中
public void getAllItems() throws Exception
{
//遍历文件每一行
InputStream ins = new FileInputStream(file);
InputStreamReader insr = new InputStreamReader(ins);
BufferedReader br = new BufferedReader(insr);
String content = null;
String[] contents = null;
while(null != (content = br.readLine()))
{
contents = content.substring(content.indexOf(":")+1).split(",");
//将t1:1,2,3 加入到map中
map.put(content.substring(0,content.indexOf(":")), Arrays.asList(contents));
}
br.close();
}

//查找一项集 [[1],[2],[3],[4]]
public void find_frequent_1_items()
{
HashSet<String> set = new HashSet<String>();
Set<String> keys = this.map.keySet();
for(String key:keys)
{
List<String> list = this.map.get(key);
for(String s:list)
{
set.add(s);
}
}

//this.cadidate=[[1],[2],[3],[4],[5]]
for(String s:set)
{
ArrayList<String> list = new ArrayList<String>();
list.add(s);
this.cadidate.add(list);
}

this.removeLessThanSupport();
this.frequentSet.put(1, new ArrayList<ArrayList<String>>(this.cadidate));
this.cadidate.clear();
}

//第二步 对当前的候选集中 进行支持度的修改
public void removeLessThanSupport()
{
//countMap{[1]:0 [2]:0 [3]:0 [4]:0 [5]:0}
//遍历数据库 文件map
Set<String> keys = this.map.keySet();
for(String key:keys)
{
List<String> list = this.map.get(key);
//this.cadidate=[[1],[2],[3],[4]]
for(ArrayList<String> ca_list:this.cadidate)
{
//[1,2,3] 包含 [2,3]
if(list.containsAll(ca_list))
{
if(this.countMap.get(ca_list) == null)
{
this.countMap.put(ca_list, 1);
}
else
{
this.countMap.put(ca_list, this.countMap.get(ca_list)+1);
}
}
}
}
//如果countMap没有被计数的，说明 这一对值计数为0 countMap.size() < this.cadidate.size()
if(countMap.size() < this.cadidate.size())
{
HashSet<ArrayList<String>> set = new HashSet<ArrayList<String>>(this.cadidate);
set.removeAll(this.countMap.keySet());

for(ArrayList<String> list:set)
{
this.countMap.put(list, 0);
}
}

//比较最小支持度
for(List<String> list:this.countMap.keySet())
{
if(this.countMap.get(list) < min_support)
{
this.cadidate.remove(list);
}
}

//比较完成之后 将其写到文件中
if(!this.cadidate.isEmpty())
{
int k = this.cadidate.get(0).size();
File file = new File("L" + k + ".txt");
//内存 -> 文件
try
{
OutputStream ous = new FileOutputStream(file);
OutputStreamWriter osw = new OutputStreamWriter(ous);
BufferedWriter bw = new BufferedWriter(osw);

for(ArrayList<String> list:this.cadidate)
{
bw.write(list + ":" + this.countMap.get(list) + "\n");
}
this.countMap.clear();
bw.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}


}
//处理过程
public void main()
{
this.find_frequent_1_items();
for(int i = 2;!this.frequentSet.get(i-1).isEmpty();i++)
{
this.apriori_gen(i-1);
}
}
//候选集[k] = L[k-1] 连接 L[k-1] index:k-1
public void apriori_gen(int index)
{
//[[1],[2],[3],[4],[5]]
ArrayList<ArrayList<String>> list_index = this.frequentSet.get(index);
ArrayList<ArrayList<String>> newList = new ArrayList<ArrayList<String>>();
boolean flag = true;//标    志前index 位是否相同
for(int k = 0;k < list_index.size();k++)
{
ArrayList<String> list1 = list_index.get(k);
for(int j = k+1;j < list_index.size();j++)
{
ArrayList<String> list2 = list_index.get(j);
int i;
for(i = 0;i < index-1;i++)
{
if(!list1.get(i).equals(list2.get(i)))
{
flag = false;
}
}

if(i == 0)
{
ArrayList<String> subList = new ArrayList<String>();
if(!list1.get(i).equals(list2.get(i)))
{
subList.add(list1.get(i));
subList.add(list2.get(i));
//对每一个产生的subList进行分析
//[1,2,3] k-1 子集 受否在L[k-1]中
Collections.sort(subList);
if(!this.has_infrequent_subset(subList, list_index))
{
newList.add(subList);
}
}
}
//前k-2位全部相同
if(flag && i!= 0)
{
//[3,4] [3,5] index=2 list=[3]
List<String> list = list1.subList(0, index-1);
ArrayList<String> subList = new ArrayList<String>();
subList.addAll(list);
subList.add(list1.get(index-1));
subList.add(list2.get(index-1));
Collections.sort(subList);
if(!this.has_infrequent_subset(subList, list_index))
{
newList.add(subList);
}
}

flag = true;
}
flag = true;
}
this.cadidate = newList;
this.removeLessThanSupport();
//对当前的候选键 min_support进行比较修改
this.frequentSet.put(index+1, new ArrayList<ArrayList<String>>(this.cadidate));
this.cadidate.clear();
}

//对于新产生的[]元素L[K] 是否在L[k-1]中 
//list 是L[k-1] 频繁集
//[1,3,5] [1,3],[1,5],[3,5] 
public boolean has_infrequent_subset(ArrayList<String> subList,ArrayList<ArrayList<String>> list)
{
int k = subList.size();
//查找subList的k-1子集
//[1,2,3,4] [1,2,3] [1,2,4] [1,3,4]
for(int i = 0;i < k;i++)
{
ArrayList<String> k_subList = new ArrayList<String>(subList);
k_subList.remove(i);
if(!list.contains(k_subList))
{
return true;
}
}
return false;
}
@Test
public void test() throws Exception
{
this.setFile("transaction.txt");
this.getAllItems();
this.main();
}

}