关于数据库范式理论的程序设计 - ArmstrongUtils

这里我使用的工具类全部都是使用接口，public interface ArmstrongUtils extends CollectionUtils是关于Armstrong公理的工具，因为后面算法都不用就算F+，所有这些性质都很少会直接用到重点内容。

Utils工具的继承关系

ArmstrongUtils接口

import com.ruoxing.dbs.bean.FunctionalDependency;

/** * @author :ruoxing * @type :Interface * @date :2018年5月 * @description :Armstrong公理 */
public interface ArmstrongUtils extends CollectionUtils {
}

自反律（reflexivity）

1. 方法代码

    /** * 描述:自反律: β包含于α => α → β * @param sequenceA α * @param sequenceB β * @return FunctionalDependency α → β */
    default FunctionalDependency reflexivity(CharSequence sequenceA, CharSequence sequenceB) {
        if (contains(sequenceA, sequenceB)) {
            return new FunctionalDependency(sequenceA, sequenceB);
        }
        return null;
    }

2. 测试代码（Junit）

import com.ruoxing.dbs.bean.FunctionalDependency;
import com.ruoxing.dbs.util.ArmstrongUtils;
import org.junit.Test;

import java.util.Arrays;

/** * 描述：测试Armstrong公理的实现 */
public class Test3 implements ArmstrongUtils {

}

    @Test
    public void test01() {
        System.out.println("自反律：");
        System.out.println(reflexivity("AB", "B"));//AB→B
        System.out.println(reflexivity("A", "BC"));//null
    }

增补律（augmentation）

1. 方法代码

    /** * 描述:增补律 * @param fd FunctionalDependency α → β * @param sequence CharSequence γ * @return FunctionalDependency γα → γβ */
    default FunctionalDependency augmentation(FunctionalDependency fd, CharSequence sequence) {
        return new FunctionalDependency("" + fd.getLeft() + sequence, "" + fd.getRight() + sequence);
    }

2. 测试代码

    @Test
    public void test02() {
        System.out.println("增补律:");
        final FunctionalDependency fd = new FunctionalDependency("α", "β");//α → β
        System.out.println(augmentation(fd, "γ"));//γα → γβ
    }

传递律（transitivity）

1. 方法代码

    /** * 描述:传递律 * @param fd1 FunctionalDependency α → β * @param fd2 FunctionalDependency β → γ * @return FunctionalDependency α → γ */
    default FunctionalDependency transitivity(FunctionalDependency fd1, FunctionalDependency fd2) {
        //α → β1,β2 → γ(β1包含β2) ==> α → γ
        if (contains(fd1.getRight(), fd2.getLeft())) {
            return new FunctionalDependency(fd1.getLeft(), fd2.getRight());
        }
        return null;
    }

2. 测试代码

    @Test
    public void test03() {
        System.out.println("传递律:");
        final FunctionalDependency fd1 = new FunctionalDependency("α", "β");//α → β
        final FunctionalDependency fd2 = new FunctionalDependency("β", "γ");//β → γ
        System.out.println(transitivity(fd1, fd2));//α→γ
    }

合并律（union）

1. 方法代码

    /** * 描述:合并律 * @param fd1 FunctionalDependency α → β * @param fd2 FunctionalDependency α → γ * @return FunctionalDependency α → βγ */
    default FunctionalDependency union(FunctionalDependency fd1, FunctionalDependency fd2) {
        if (fd1.getLeft().equals(fd2.getLeft())) {
            return new FunctionalDependency(fd1.getLeft(), "" + fd1.getRight() + fd2.getRight());
        }
        return null;
    }

2. 测试代码

@Test
    public void test03() {
        System.out.println("合并律：");
        final FunctionalDependency fd1 = new FunctionalDependency("α", "β");//α → β
        final FunctionalDependency fd2 = new FunctionalDependency("α", "γ");//α → γ
        System.out.println(union(fd1, fd2));//α→βγ
    }

分解律（decomposition）

1. 方法代码

    /** * 描述:分解律 * * @param fd FunctionalDependency α → βγ * @return FunctionalDependency {α → β,α → γ} */
    default FunctionalDependency[] decomposition(FunctionalDependency fd) {
        final CharSequence right = fd.getRight();
        FunctionalDependency[] fds = new FunctionalDependency[right.length()];
        for (int i = 0; i < fds.length; i++) {
            fds[i] = new FunctionalDependency(fd.getLeft(), "" + right.charAt(i));
        }
        return fds;
    }

2. 测试代码

    @Test
    public void test05() {
        System.out.println("分解律：");
        final FunctionalDependency fd = new FunctionalDependency("α", "βγ");//α → βγ
        final FunctionalDependency[] decomposition = decomposition(fd);
        System.out.println(Arrays.toString(decomposition));//[α→β, α→γ]
    }

伪传递律（pseudoTransitivity）

1. 方法代码

    /** * 描述:伪传递律 * * @param fd1 FunctionalDependency α → β * @param fd2 FunctionalDependency γβ → δ * @return FunctionalDependency αγ → δ */
    default FunctionalDependency pseudoTransitivity(FunctionalDependency fd1, FunctionalDependency fd2) {
        if (contains(fd2.getLeft(), fd1.getRight())) {
            return new FunctionalDependency(("" + fd1.getLeft() + fd2.getLeft()).replace(fd1.getRight(), ""), fd2.getRight());
        }
        return null;
    }

2. 测试代码

    @Test
    public void test06() {
        System.out.println("伪传递律：");
        final FunctionalDependency fd1 = new FunctionalDependency("α", "β");//α → β
        final FunctionalDependency fd2 = new FunctionalDependency("βγ", "δ");//βγ → δ
        System.out.println(union(fd1, fd2));//αγ → δ
    }