Apriori算法-java

package com.yang;

import java.util.*;

public class Apriori {

private double minsup = 0.2;// 最小支持度
    private double minconf = 0.2;// 最小置信度

// 注意使用IdentityHashMap，否则由于关联规则产生存在键值相同的会出现覆盖
    private IdentityHashMap ruleMap = new IdentityHashMap();

//private String[] transSet = { "abc", "abc", "acde", "bcdf", "abcd", "abcdf" };// 事务集合
                                                                                    // ，
                                                                                    // 可以根据需要从构造函数里传入
    private String[] transSet = { "abe", "bd", "bc", "abd", "ac", "bc","ac","abce","abc" };// 事务集合
    private int itemCounts = 0;// 候选1项目集大小,即字母的个数
    private TreeSet[] frequencySet = new TreeSet[40];// 频繁项集数组，[0]:代表1频繁集...，TreeSet（）使用元素的自然顺序对元素进行排序
    private TreeSet maxFrequency = new TreeSet();// 最大频繁集[所有频繁的]
    private TreeSet candidate = new TreeSet();
    private TreeSet candidateSet[] = new TreeSet[40];// 候选集数组[0]:代表1候选集
    private int frequencyIndex;

public Apriori() {

maxFrequency = new TreeSet();
        itemCounts = counts();// 初始化1候选集的大小6个
        System.out.printf("1项集的大小"+itemCounts);
        // 初始化其他两个
        for (int i = 0; i < itemCounts; i++) {
            frequencySet[i] = new TreeSet();//初始化频繁项集数组
            candidateSet[i] = new TreeSet();//初始化候选集数组
        }
        candidateSet[0] = candidate;// 1候选集
    }

//主函数入口
    public static void main(String[] args) {
        Apriori ap = new Apriori();
        ap.run();
    }
    
    //方法运行
    public void run() {
        int k = 1;
        item1_gen();

do {
            k++;
            canditate_gen(k);
            frequent_gen(k);
        } while (!is_frequent_empty(k));
        frequencyIndex = k - 1;
        print_canditate();
        maxfrequent_gen();
        print_maxfrequent();
        ruleGen();
        rulePrint();
    }
    //记录每个事务中的元素出现次数，x在事务中出现的总次数。
    public double count_sup(String x) {
        int temp = 0;
        for (int i = 0; i < transSet.length; i++) {
            for (int j = 0; j < x.length(); j++) {
                if (transSet[i].indexOf(x.charAt(j)) == -1)//返回指定字符在此字符串中第一次出现处的索引，如果不作为一个字符串，返回-1
                    break;
                else if (j == (x.length() - 1))
                    temp++;
            }
        }
        return temp;
    }
    
    //统计1候选集的个数a,b,c,d,e,f,return值为6
    public int counts() {

String temp1 = null;
        char temp2 = 'a';
        // 遍历所有事务集String 加入集合，set自动去重了
        for (int i = 0; i < transSet.length; i++) {
            temp1 = transSet[i];
            for (int j = 0; j < temp1.length(); j++) {
                temp2 = temp1.charAt(j);//返回位置为j的temp1的值a
                candidate.add(String.valueOf(temp2));//treeSet添加会去掉重复的值
            }
        }
        return candidate.size();//中元素个数不重复，且递增排序
    }

//求1频繁集
    public void item1_gen() {
        String temp1 = "";
        double m = 0;

Iterator temp = candidateSet[0].iterator();//使用方法iterator()要求容器返回一个Iterator。
        while (temp.hasNext()) {//遍历temp（1候选集）
            temp1 = (String) temp.next();
            m = count_sup(temp1);//调用下面的方法，统计1候选集中每个元素个数，计算支持度时，用此m/transSet.length

// 符合条件的加入 1候选集
            if (m >= minsup * transSet.length) {//minsup * transSet.length的值为记录每个事务中的元素出现次数,判断是否1频繁集
                frequencySet[0].add(temp1);//1频繁集加入频繁项集数组，自动出去重复的集合
            }
        }
    }
    //求K候选集
    public void canditate_gen(int k) {
        String y = "", z = "", m = "";
        char c1 ,c2 ;

Iterator temp1 = frequencySet[k - 2].iterator();//iterator迭代器，用于数组遍历
        Iterator temp2 = frequencySet[0].iterator();//遍历频繁项集数组，[0]:代表1频繁集
        TreeSet h = new TreeSet();

while (temp1.hasNext()) {
            y = (String) temp1.next();//
            c1 = y.charAt(y.length() - 1);//返回指定y.length() - 1（数组的最后一个）的char值

while (temp2.hasNext()) {
                z = (String) temp2.next();

c2 = z.charAt(0);//c2=a,b,c,d,e,f
                if (c1 >= c2)
                    continue;//大于最后一个字符才拼上。abd，而无adb
                else {
                    m = y + z;//m为字符串组合yz
                    h.add(m);//m加入TreeSet
                }
            }
            temp2 = frequencySet[0].iterator();
        }
        candidateSet[k - 1] = h;
    }

// k候选集=>k频繁集
    public void frequent_gen(int k) {
        String s1 = "";

Iterator ix = candidateSet[k - 1].iterator();//遍历K候选集ix
        while (ix.hasNext()) {
            s1 = (String) ix.next();//ix中的值s1
            if (count_sup(s1) >= (minsup * transSet.length)) {//s1项集支持度大于最小支持度
                frequencySet[k - 1].add(s1);//s1加入K频繁集中
            }
        }
    }
    //判断频繁集为空
    public boolean is_frequent_empty(int k) {
        if (frequencySet[k - 1].isEmpty())
            return true;
        else
            return false;
    }
    //打印候选集 频繁集
    public void print_canditate() {

for (int i = 0; i < frequencySet[0].size(); i++) {
            Iterator ix = candidateSet[i].iterator();
            Iterator iy = frequencySet[i].iterator();
            System.out.print("候选集" + (i + 1) + ":");
            while (ix.hasNext()) {
                System.out.print((String) ix.next() + "\t");
            }
            System.out.print("\n" + "频繁集" + (i + 1) + ":");
            while (iy.hasNext()) {
                System.out.print((String) iy.next() + "\t");
            }
            System.out.println();
        }
    }

//求关联项集合
    public void maxfrequent_gen() {
        int i;
        for (i = 1; i < frequencyIndex; i++) {
            maxFrequency.addAll(frequencySet[i]);
        }
    }
    //打印频繁项集
    public void print_maxfrequent() {
        Iterator iterator = maxFrequency.iterator();
        System.out.print("频繁项集：");
        while (iterator.hasNext()) {
            System.out.print(((String) iterator.next()) + "\t");
        }
        System.out.println();
        System.out.println();
    }
    //关联规则项集
    public void ruleGen() {
        String s;
        Iterator iterator = maxFrequency.iterator();
        while (iterator.hasNext()) {
            s = (String) iterator.next();
            subGen(s);
        }
    }

//求关联规则
    //将1左移多少位，将s分成不重叠的两部分。生成所有关联规则。再判断支持度
    public void subGen(String s) {
        String x = "", y = "";
        for (int i = 1; i < (1 << s.length()) - 1; i++) {
            for (int j = 0; j < s.length(); j++) {
                if (((1 << j) & i) != 0) {
                    x += s.charAt(j);
                }
            }

for (int j = 0; j < s.length(); j++) {
                if (((1 << j) & (~i)) != 0) {

y += s.charAt(j);

}
            }
            if (count_sup(x + y) / count_sup(x) >= minconf) {
                ruleMap.put(x, y);
            }
            x = "";
            y = "";

}
    }

//打印关联规则
    public void rulePrint() {
        String x, y;
        float temp = 0;

Set hs = ruleMap.keySet();//迭代后只能用get取key，Set不包含重复元素的collection
        Iterator iterator = hs.iterator();
        System.out.println("关联规则：");
        while (iterator.hasNext()) {
            x = (String) iterator.next();

y = (String) ruleMap.get(x);

temp = (float) (count_sup(x + y) / count_sup(x));

System.out.println(x + (x.length() < 5 ? "\t" : "") + "-->" + y+ "\t" + "置信度: " + temp);
            
        }
    }
}
学习点：1.TreeSet.add自动去重

2.TreeSet[] frequencySet; TreeSet frequencySet[];两种方法定义的都是数组，似乎是相同的。

3.canditate_gen中，大于最后一个字符的时候才拼上，adb即abd，所以不存在adb这种。

4.生成关联规则时，是将1左移多少位。能够将所有的组合都生成。x与y不会重叠。

效果图：