tx資料庫下載

『壹』 請幫忙啊

Watching some children trying to catch butterflies one August afternoon, I was reminded of an incident in my own childhood.When I was a boy of twelve in South Carolina, something happened to me that made me never put any wild creature (living thing)in a cage(籠子).�
一個秋日的下午，我看見幾個孩子在捕捉蝴蝶，這讓我回想起童年的一件往事。那時我12歲，住在南加州。在那發生的一件事讓我再未抓過任何小動物。
We lived on the edge of a forest, and every evening at sk the mockingbirds would come and rest in the trees and sing.There isn t a musical instrument made by man that can proce a more beautiful sound than the song of the mockingbird.
那時我們住在森林邊上，每當薄暮籠罩的時候一種叫「嘲鳥」的鳥類就來棲息。它們的歌聲優美，勝似任何人造器械製造出來的旋律。
I decided that I would catch a young bird and keep it in a cage and in that way, I would have my own private musician.
那時我想，要是我抓只小鳥就好了，那它就能為我而歌唱了。
I finally succeeded in catching one and put it in a cage.At first, being scared, the bird fluttered(撲騰)about the cage, but finally it settled down in its new home.I felt very pleased with myself and looked forward to some beautiful singing from my little musician.
我終於抓到了一隻。一開始，小鳥很怕生，在籠子里撲騰，但漸漸地它適應了環境。我很滿意這樣的結局：我終於為自己抓了只「音樂家」。
On the second day of the bird's captivity, my new pet's mother flew to the cage with food in her mouth.The baby bird ate everything she brought to it.I was pleased to see this.Certainly the mother knew better than I how to feed her baby.
就在我抓住它的第2天，小鳥的母親嘴裡銜著事物飛到了籠子邊。看著小鳥吃了媽媽給的事物，我也感到很幸福。很明顯，鳥媽媽比我更會照顧它的寶寶。
The following morning when I went to see how my captive (caged)bird was doing, I discovered it on the floor of the cage, dead.I was terribly surprised! What had happened! I had taken extremely care of my little bird, or so I thought.
Arthur Wayne, the famous ornithologist, who happened to be visiting my father at the time, hearing me crying over the death of my bird, explained what had happened."A mother mockingbird, finding her young in a cage, will sometimes bring it poison berries(毒莓).She thinks it better for her young to die than to live in captivity."�
接下來的一天清晨，當我來看小鳥的時候，發現它躺在籠子邊上，身體已然僵硬。我很吃驚，這是怎麼一回事？那時一位叫亞瑟.韋恩的鳥類學者正在拜訪我父親，他聽見我的哭聲，就過來告訴了我小鳥死亡的原因：母鳥餵了它有毒的藍莓，因為它認為沒有自由的生存遠不如死亡來得有意義。
Never since then have I caught any living creature and put it in a cage.All living creatures have a right to live free.
從那時候起我再沒抓過任何小動物。因為我知道，每一種生物都有自由生存的權利。

本人筆譯的，希望對樓主有所幫助

（PS：這個故事不錯）

『貳』 跪求win10msde2000安裝包 家庭中文版軟體百度雲資源

《win10msde》網路網盤免費資源下載：

鏈接: https://pan..com/s/1w6CA5tXHP_3UX9hOCox3pw

介紹:win10msde2000安裝包具有相對穩定的資料庫系統，再成熟的設置中讓用戶體會到強大的工具體驗，該版本也挺經典的，極光下載站提供msde2000資料庫下載。

『叄』 關於QQ校友農場的問題

那是你QQ好友裡面的 刪了就可以了 玩農場集團QQ群51474857大量招人 招一名管理員 要求長期在線

『肆』 txrajnl.dat是什麼文件

.dat文件某個程序組的資料庫文件（data），是用來存放數據參數用的，比如說3D游戲中的3D模型，皮膚文件等。
.dat文件相當於.mpg文件，即視頻，可以用mediaplayer,mediaclassic,real(one)player、暴風影音等播放軟體打開。
dat並不是一種標准文件。許多文件都使用這個擴展名，但文件含義不同。而許多數據分析軟體也用這個擴展名保存數據。所以這要看具體的軟體情況來定。DAT文件，可以按照擴展名來看就是DATA的意思，即數據文件，這類文件並沒有進行絕對化的定義，例如VCD光碟中的dat文件就可以用一般的視頻播放器打開，而QQ的dat文件中則存儲了用戶信息，是不能使用常規方式打開的，只有QQ程序可以訪問。還有一些其他程序都有自己對dat文件的定義，要通過產生它的程序來打開與之相關聯的dat文件。dat文件一般是二進制文件，一般用來存儲數據的，無法獨立使用，針對各種程序有不同的作用。多數情況下，.dat文件是程序使用的數據，它只是開發者為了清楚文件的意思而自己定義的，也可以命名成別的擴展名。

『伍』 我的QQ頭像早就看不見了，我把手機恢復出廠設置，能看見QQ頭像嗎

可以，手機恢復出廠設置後重新安裝下QQ，登陸就應該沒問題了；如果還是看不到QQ頭像的話，看看是不是自己的頭像圖片丟了，還是QQ的版本頭像設置的問題！

『陸』 oracle TM和TX

• 資料庫是一個多用戶使用的共享資源。當多個用戶並發地存取數據時，在資料庫中就會產生多個事務同時存取同一數據的情況。若對並發操作不加控制就可能會讀取和存儲不正確的數據，破壞資料庫的一致性。 加鎖是實現資料庫並發控制的一個非常重要的技...

『柒』 急需C++實現的Apriori演算法代碼

用C++ 實現的 可以 到http://download.csdn.net/down/188143/chanjuanzz下載 不過要注冊扣積分的

演算法實現

（一）核心類

Apriori演算法的核心實現類為AprioriAlgorithm，實現的java代碼如下所示：

package org.shirdrn.datamining.association;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
* <B>關聯規則挖掘：Apriori演算法</B>
*
* <P>該演算法基本上按照Apriori演算法的基本思想來實現的。
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class AprioriAlgorithm {

private Map<Integer, Set<String>> txDatabase; // 事務資料庫
private Float minSup; // 最小支持度
private Float minConf; // 最小置信度
private Integer txDatabaseCount; // 事務資料庫中的事務數

private Map<Integer, Set<Set<String>>> freqItemSet; // 頻繁項集集合
private Map<Set<String>, Set<Set<String>>> assiciationRules; // 頻繁關聯規則集合

public AprioriAlgorithm(
Map<Integer, Set<String>> txDatabase,
Float minSup,
Float minConf) {
this.txDatabase = txDatabase;
this.minSup = minSup;
this.minConf = minConf;
this.txDatabaseCount = this.txDatabase.size();
freqItemSet = new TreeMap<Integer, Set<Set<String>>>();
assiciationRules = new HashMap<Set<String>, Set<Set<String>>>();
}

/**
* 掃描事務資料庫，計算頻繁1-項集
* @return
*/
public Map<Set<String>, Float> getFreq1ItemSet() {
Map<Set<String>, Float> freq1ItemSetMap = new HashMap<Set<String>, Float>();
Map<Set<String>, Integer> candFreq1ItemSet = this.getCandFreq1ItemSet();
Iterator<Map.Entry<Set<String>, Integer>> it = candFreq1ItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Set<String>, Integer> entry = it.next();
// 計算支持度
Float supported = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supported>=minSup) {
freq1ItemSetMap.put(entry.getKey(), supported);
}
}
return freq1ItemSetMap;
}

/**
* 計算候選頻繁1-項集
* @return
*/
public Map<Set<String>, Integer> getCandFreq1ItemSet() {
Map<Set<String>, Integer> candFreq1ItemSetMap = new HashMap<Set<String>, Integer>();
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計支持數，生成候選頻繁1-項集
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Set<String> itemSet = entry.getValue();
for(String item : itemSet) {
Set<String> key = new HashSet<String>();
key.add(item.trim());
if(!candFreq1ItemSetMap.containsKey(key)) {
Integer value = 1;
candFreq1ItemSetMap.put(key, value);
}
else {
Integer value = 1+candFreq1ItemSetMap.get(key);
candFreq1ItemSetMap.put(key, value);
}
}
}
return candFreq1ItemSetMap;
}

/**
* 根據頻繁(k-1)-項集計算候選頻繁k-項集
*
* @param m 其中m=k-1
* @param freqMItemSet 頻繁(k-1)-項集
* @return
*/
public Set<Set<String>> aprioriGen(int m, Set<Set<String>> freqMItemSet) {
Set<Set<String>> candFreqKItemSet = new HashSet<Set<String>>();
Iterator<Set<String>> it = freqMItemSet.iterator();
Set<String> originalItemSet = null;
while(it.hasNext()) {
originalItemSet = it.next();
Iterator<Set<String>> itr = this.getIterator(originalItemSet, freqMItemSet);
while(itr.hasNext()) {
Set<String> identicalSet = new HashSet<String>(); // 兩個項集相同元素的集合(集合的交運算)
identicalSet.addAll(originalItemSet);
Set<String> set = itr.next();
identicalSet.retainAll(set); // identicalSet中剩下的元素是identicalSet與set集合中公有的元素
if(identicalSet.size() == m-1) { // (k-1)-項集中k-2個相同
Set<String> differentSet = new HashSet<String>(); // 兩個項集不同元素的集合(集合的差運算)
differentSet.addAll(originalItemSet);
differentSet.removeAll(set); // 因為有k-2個相同，則differentSet中一定剩下一個元素，即differentSet大小為1
differentSet.addAll(set); // 構造候選k-項集的一個元素(set大小為k-1,differentSet大小為k)
candFreqKItemSet.add(differentSet); // 加入候選k-項集集合
}
}
}
return candFreqKItemSet;
}

/**
* 根據一個頻繁k-項集的元素(集合)，獲取到頻繁k-項集的從該元素開始的迭代器實例
* @param itemSet
* @param freqKItemSet 頻繁k-項集
* @return
*/
private Iterator<Set<String>> getIterator(Set<String> itemSet, Set<Set<String>> freqKItemSet) {
Iterator<Set<String>> it = freqKItemSet.iterator();
while(it.hasNext()) {
if(itemSet.equals(it.next())) {
break;
}
}
return it;
}

/**
* 根據頻繁(k-1)-項集，調用aprioriGen方法，計算頻繁k-項集
*
* @param k
* @param freqMItemSet 頻繁(k-1)-項集
* @return
*/
public Map<Set<String>, Float> getFreqKItemSet(int k, Set<Set<String>> freqMItemSet) {
Map<Set<String>, Integer> candFreqKItemSetMap = new HashMap<Set<String>, Integer>();
// 調用aprioriGen方法，得到候選頻繁k-項集
Set<Set<String>> candFreqKItemSet = this.aprioriGen(k-1, freqMItemSet);

// 掃描事務資料庫
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計支持數
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Iterator<Set<String>> kit = candFreqKItemSet.iterator();
while(kit.hasNext()) {
Set<String> kSet = kit.next();
Set<String> set = new HashSet<String>();
set.addAll(kSet);
set.removeAll(entry.getValue()); // 候選頻繁k-項集與事務資料庫中元素做差元算
if(set.isEmpty()) { // 如果拷貝set為空，支持數加1
if(candFreqKItemSetMap.get(kSet) == null) {
Integer value = 1;
candFreqKItemSetMap.put(kSet, value);
}
else {
Integer value = 1+candFreqKItemSetMap.get(kSet);
candFreqKItemSetMap.put(kSet, value);
}
}
}
}
// 計算支持度，生成頻繁k-項集，並返回
return support(candFreqKItemSetMap);
}

/**
* 根據候選頻繁k-項集，得到頻繁k-項集
*
* @param candFreqKItemSetMap 候選k項集(包含支持計數)
*/
public Map<Set<String>, Float> support(Map<Set<String>, Integer> candFreqKItemSetMap) {
Map<Set<String>, Float> freqKItemSetMap = new HashMap<Set<String>, Float>();
Iterator<Map.Entry<Set<String>, Integer>> it = candFreqKItemSetMap.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Set<String>, Integer> entry = it.next();
// 計算支持度
Float supportRate = new Float(entry.getValue().toString())/new Float(txDatabaseCount);
if(supportRate<minSup) { // 如果不滿足最小支持度，刪除
it.remove();
}
else {
freqKItemSetMap.put(entry.getKey(), supportRate);
}
}
return freqKItemSetMap;
}

/**
* 挖掘全部頻繁項集
*/
public void mineFreqItemSet() {
// 計算頻繁1-項集
Set<Set<String>> freqKItemSet = this.getFreq1ItemSet().keySet();
freqItemSet.put(1, freqKItemSet);
// 計算頻繁k-項集(k>1)
int k = 2;
while(true) {
Map<Set<String>, Float> freqKItemSetMap = this.getFreqKItemSet(k, freqKItemSet);
if(!freqKItemSetMap.isEmpty()) {
this.freqItemSet.put(k, freqKItemSetMap.keySet());
freqKItemSet = freqKItemSetMap.keySet();
}
else {
break;
}
k++;
}
}

/**
* <P>挖掘頻繁關聯規則
* <P>首先挖掘出全部的頻繁項集，在此基礎上挖掘頻繁關聯規則
*/
public void mineAssociationRules() {
freqItemSet.remove(1); // 刪除頻繁1-項集
Iterator<Map.Entry<Integer, Set<Set<String>>>> it = freqItemSet.entrySet().iterator();
while(it.hasNext()) {
Map.Entry<Integer, Set<Set<String>>> entry = it.next();
for(Set<String> itemSet : entry.getValue()) {
// 對每個頻繁項集進行關聯規則的挖掘
mine(itemSet);
}
}
}

/**
* 對從頻繁項集集合freqItemSet中每迭代出一個頻繁項集元素，執行一次關聯規則的挖掘
* @param itemSet 頻繁項集集合freqItemSet中的一個頻繁項集元素
*/
public void mine(Set<String> itemSet) {
int n = itemSet.size()/2; // 根據集合的對稱性，只需要得到一半的真子集
for(int i=1; i<=n; i++) {
// 得到頻繁項集元素itemSet的作為條件的真子集集合
Set<Set<String>> properSubset = ProperSubsetCombination.getProperSubset(i, itemSet);
// 對條件的真子集集合中的每個條件項集，獲取到對應的結論項集，從而進一步挖掘頻繁關聯規則
for(Set<String> conditionSet : properSubset) {
Set<String> conclusionSet = new HashSet<String>();
conclusionSet.addAll(itemSet);
conclusionSet.removeAll(conditionSet); // 刪除條件中存在的頻繁項
confide(conditionSet, conclusionSet); // 調用計算置信度的方法，並且挖掘出頻繁關聯規則
}
}
}

/**
* 對得到的一個條件項集和對應的結論項集，計算該關聯規則的支持計數，從而根據置信度判斷是否是頻繁關聯規則
* @param conditionSet 條件頻繁項集
* @param conclusionSet 結論頻繁項集
*/
public void confide(Set<String> conditionSet, Set<String> conclusionSet) {
// 掃描事務資料庫
Iterator<Map.Entry<Integer, Set<String>>> it = txDatabase.entrySet().iterator();
// 統計關聯規則支持計數
int conditionToConclusionCnt = 0; // 關聯規則(條件項集推出結論項集)計數
int conclusionToConditionCnt = 0; // 關聯規則(結論項集推出條件項集)計數
int supCnt = 0; // 關聯規則支持計數
while(it.hasNext()) {
Map.Entry<Integer, Set<String>> entry = it.next();
Set<String> txSet = entry.getValue();
Set<String> set1 = new HashSet<String>();
Set<String> set2 = new HashSet<String>();
set1.addAll(conditionSet);

set1.removeAll(txSet); // 集合差運算：set-txSet
if(set1.isEmpty()) { // 如果set為空，說明事務資料庫中包含條件頻繁項conditionSet
// 計數
conditionToConclusionCnt++;
}
set2.addAll(conclusionSet);
set2.removeAll(txSet); // 集合差運算：set-txSet
if(set2.isEmpty()) { // 如果set為空，說明事務資料庫中包含結論頻繁項conclusionSet
// 計數
conclusionToConditionCnt++;

}
if(set1.isEmpty() && set2.isEmpty()) {
supCnt++;
}
}
// 計算置信度
Float conditionToConclusionConf = new Float(supCnt)/new Float(conditionToConclusionCnt);
if(conditionToConclusionConf>=minConf) {
if(assiciationRules.get(conditionSet) == null) { // 如果不存在以該條件頻繁項集為條件的關聯規則
Set<Set<String>> conclusionSetSet = new HashSet<Set<String>>();
conclusionSetSet.add(conclusionSet);
assiciationRules.put(conditionSet, conclusionSetSet);
}
else {
assiciationRules.get(conditionSet).add(conclusionSet);
}
}
Float conclusionToConditionConf = new Float(supCnt)/new Float(conclusionToConditionCnt);
if(conclusionToConditionConf>=minConf) {
if(assiciationRules.get(conclusionSet) == null) { // 如果不存在以該結論頻繁項集為條件的關聯規則
Set<Set<String>> conclusionSetSet = new HashSet<Set<String>>();
conclusionSetSet.add(conditionSet);
assiciationRules.put(conclusionSet, conclusionSetSet);
}
else {
assiciationRules.get(conclusionSet).add(conditionSet);
}
}
}

/**
* 經過挖掘得到的頻繁項集Map
*
* @return 挖掘得到的頻繁項集集合
*/
public Map<Integer, Set<Set<String>>> getFreqItemSet() {
return freqItemSet;
}

/**
* 獲取挖掘到的全部的頻繁關聯規則的集合
* @return 頻繁關聯規則集合
*/
public Map<Set<String>, Set<Set<String>>> getAssiciationRules() {
return assiciationRules;
}
}

（二）輔助類

ProperSubsetCombination類是一個輔助類，在挖掘頻繁關聯規則的過程中，用於生成一個頻繁項集元素的非空真子集，實現代碼如下：

package org.shirdrn.datamining.association;
import java.util.BitSet;
import java.util.HashSet;
import java.util.Set;

/**
* <B>求頻繁項集元素(集合)的非空真子集集合</B>
* <P>從一個集合（大小為n）中取出m(m屬於2~n/2的閉區間)個元素的組合實現類，獲取非空真子集的集合
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class ProperSubsetCombination {

private static String[] array;
private static BitSet startBitSet; // 比特集合起始狀態
private static BitSet endBitSet; // 比特集合終止狀態，用來控制循環
private static Set<Set<String>> properSubset; // 真子集集合

/**
* 計算得到一個集合的非空真子集集合
*
* @param n 真子集的大小
* @param itemSet 一個頻繁項集元素
* @return 非空真子集集合
*/
public static Set<Set<String>> getProperSubset(int n, Set<String> itemSet) {
String[] array = new String[itemSet.size()];
ProperSubsetCombination.array = itemSet.toArray(array);
properSubset = new HashSet<Set<String>>();
startBitSet = new BitSet();
endBitSet = new BitSet();

// 初始化startBitSet，左側占滿1
for (int i=0; i<n; i++) {
startBitSet.set(i, true);
}

// 初始化endBit，右側占滿1
for (int i=array.length-1; i>=array.length-n; i--) {
endBitSet.set(i, true);
}

// 根據起始startBitSet，將一個組合加入到真子集集合中
get(startBitSet);

while(!startBitSet.equals(endBitSet)) {
int zeroCount = 0; // 統計遇到10後，左邊0的個數
int oneCount = 0; // 統計遇到10後，左邊1的個數
int pos = 0; // 記錄當前遇到10的索引位置

// 遍歷startBitSet來確定10出現的位置
for (int i=0; i<array.length; i++) {
if (!startBitSet.get(i)) {
zeroCount++;
}
if (startBitSet.get(i) && !startBitSet.get(i+1)) {
pos = i;
oneCount = i - zeroCount;
// 將10變為01
startBitSet.set(i, false);
startBitSet.set(i+1, true);
break;
}
}
// 將遇到10後，左側的1全部移動到最左側
int counter = Math.min(zeroCount, oneCount);
int startIndex = 0;
int endIndex = 0;
if(pos>1 && counter>0) {
pos--;
endIndex = pos;
for (int i=0; i<counter; i++) {
startBitSet.set(startIndex, true);
startBitSet.set(endIndex, false);
startIndex = i+1;
pos--;
if(pos>0) {
endIndex = pos;
}
}
}
get(startBitSet);
}
return properSubset;
}

/**
* 根據一次移位操作得到的startBitSet，得到一個真子集
* @param bitSet
*/
private static void get(BitSet bitSet) {
Set<String> set = new HashSet<String>();
for(int i=0; i<array.length; i++) {
if(bitSet.get(i)) {
set.add(array[i]);
}
}
properSubset.add(set);
}
}

測試用例

對上述Apriori演算法的實現進行了簡單的測試，測試用例如下所示：

package org.shirdrn.datamining.association;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.shirdrn.datamining.association.AprioriAlgorithm;

import junit.framework.TestCase;

/**
* <B>Apriori演算法測試類</B>
*
* @author shirdrn
* @date 2009/07/22 22:56:23
* @msn shirdrn#hotmail.com(#→@)
* @qq 187071722
*/
public class TestAprioriAlgorithm extends TestCase {

private AprioriAlgorithm apriori;
private Map<Integer, Set<String>> txDatabase;
private Float minSup = new Float("0.50");
private Float minConf = new Float("0.70");

@Override
protected void setUp() throws Exception {
create(); // 構造事務資料庫
apriori = new AprioriAlgorithm(txDatabase, minSup, minConf);
}

/**
* 構造模擬事務資料庫txDatabase
*/
public void create() {
txDatabase = new HashMap<Integer, Set<String>>();
Set<String> set1 = new TreeSet<String>();
set1.add("A");
set1.add("B");
set1.add("C");
set1.add("E");
txDatabase.put(1, set1);
Set<String> set2 = new TreeSet<String>();
set2.add("A");
set2.add("B");
set2.add("C");
txDatabase.put(2, set2);
Set<String> set3 = new TreeSet<String>();
set3.add("C");
set3.add("D");
txDatabase.put(3, set3);
Set<String> set4 = new TreeSet<String>();
set4.add("A");
set4.add("B");
set4.add("E");
txDatabase.put(4, set4);
}

/**
* 測試挖掘頻繁1-項集
*/
public void testFreq1ItemSet() {
System.out.println("挖掘頻繁1-項集 : " + apriori.getFreq1ItemSet());
}

/**
* 測試aprioriGen方法，生成候選頻繁項集
*/
public void testAprioriGen() {
System.out.println(
"候選頻繁2-項集 ： " +
this.apriori.aprioriGen(1, this.apriori.getFreq1ItemSet().keySet())
);
}

/**
* 測試挖掘頻繁2-項集
*/
public void testGetFreq2ItemSet() {
System.out.println(
"挖掘頻繁2-項集 ：" +
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet())
);
}

/**
* 測試挖掘頻繁3-項集
*/
public void testGetFreq3ItemSet() {
System.out.println(
"挖掘頻繁3-項集 ：" +
this.apriori.getFreqKItemSet(
3,
this.apriori.getFreqKItemSet(2, this.apriori.getFreq1ItemSet().keySet()).keySet()
)
);
}

/**
* 測試挖掘全部頻繁項集
*/
public void testGetFreqItemSet() {
this.apriori.mineFreqItemSet(); // 挖掘頻繁項集
System.out.println("挖掘頻繁項集 ：" + this.apriori.getFreqItemSet());
}

/**
* 測試挖掘全部頻繁關聯規則
*/
public void testMineAssociationRules() {
this.apriori.mineFreqItemSet(); // 挖掘頻繁項集
this.apriori.mineAssociationRules();
System.out.println("挖掘頻繁關聯規則 ：" + this.apriori.getAssiciationRules());
}
}

測試結果：

挖掘頻繁1-項集 : {[E]=0.5, [A]=0.75, [B]=0.75, [C]=0.75}
候選頻繁2-項集 ： [[E, C], [A, B], [B, C], [A, C], [E, B], [E, A]]
挖掘頻繁2-項集 ：{[A, B]=0.75, [B, C]=0.5, [A, C]=0.5, [E, B]=0.5, [E, A]=0.5}
挖掘頻繁3-項集 ：{[E, A, B]=0.5, [A, B, C]=0.5}
挖掘頻繁項集 ：{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}
挖掘頻繁關聯規則 ：{[E]=[[A], [B], [A, B]], [A]=[[B]], [B]=[[A]], [B, C]=[[A]], [A, C]=[[B]], [E, B]=[[A]], [E, A]=[[B]]}

從測試結果看到，使用Apriori演算法挖掘得到的全部頻繁項集為：

{1=[[E], [A], [B], [C]], 2=[[A, B], [B, C], [A, C], [E, B], [E, A]], 3=[[E, A, B], [A, B, C]]}

使用Apriori演算法挖掘得到的全部頻繁關聯規則為：

{E}→{A}、{E}→{B}、{E}→{A,B}、{A}→{B}、{B}→{A}、{B,C}→{A}、{A,C}→{B}、{B,E}→{A}、{A,E}→{B}。

『捌』 什麼是資料庫連接池，有什麼作用

資料庫連接是一種有限的昂貴的資源，
資料庫連接影響到程序的性能指標。
資料庫連接池正是針對這個問題提出來的。資料庫連接池負責分配、
管理和釋放資料庫連接，
它允許應用程序重復使用一個現有的資料庫連接，
而再不是重新建立一個；
釋放空閑時間超過最大空閑時間的資料庫連接來避免因為沒有釋放數
據庫連接而引起的資料庫連接遺漏。
這項技術能明顯提高對資料庫操作的性能。

『玖』 QQ哪個版本升級最慢哪個最快

都一樣的 除非你是會員，超級QQ就會快點

『拾』 請問tx的資料庫保留qq多久的聊天記錄詳細說明。

漫遊的記錄才是存在伺服器上的，一般的記錄是保存在本地的。只要你不人為的去刪除記錄應該一直都有。