一个java文件使用另一个java文件编译错误

ubuntu版本：12.04 java版本1.7

FPTree.java内容：

package fptree;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;


public class FPTree extends TreeNode {  


    private int minSuport;

    public int getMinSuport() {
        return minSuport;
    }

    public void setMinSuport(int minSuport) {
        this.minSuport = minSuport;
    }


    public List<List<String>> readTransRocords(String... filenames) {
        List<List<String>> transaction = null;
        if (filenames.length > 0) {
            transaction = new LinkedList<List<String>>();
            for (String filename : filenames) {
                try {
                    FileReader fr = new FileReader(filename);
                    BufferedReader br = new BufferedReader(fr);
                    try {
                        String line;
                        List<String> record;
                        while ((line = br.readLine()) != null) {
                            if(line.trim().length()>0){
                                String str[] = line.split(",");
                                record = new LinkedList<String>();
                                for (String w : str)
                                    record.add(w);
                                transaction.add(record);
                            }
                        }
                    } finally {
                        br.close();
                    }
                } catch (IOException ex) {
                    System.out.println("Read transaction records failed."
                            + ex.getMessage());
                    System.exit(1);
                }
            }
        }
        return transaction;
    }


    public void FPGrowth(List<List<String>> transRecords,
            List<String> postPattern) {

        ArrayList<TreeNode> HeaderTable = buildHeaderTable(transRecords);

        TreeNode treeRoot = buildFPTree(transRecords, HeaderTable);

        if (treeRoot.getChildren()==null || treeRoot.getChildren().size() == 0)
            return;

        if(postPattern!=null){
            for (TreeNode header : HeaderTable) {
                System.out.print(header.getCount() + "\t" + header.getName());
                for (String ele : postPattern)
                    System.out.print("\t" + ele);
                System.out.println();
            }
        }

        for (TreeNode header : HeaderTable) {

            List<String> newPostPattern = new LinkedList<String>();
            newPostPattern.add(header.getName());
            if (postPattern != null)
                newPostPattern.addAll(postPattern);

            List<List<String>> newTransRecords = new LinkedList<List<String>>();
            TreeNode backnode = header.getNextHomonym();
            while (backnode != null) {
                int counter = backnode.getCount();
                List<String> prenodes = new ArrayList<String>();
                TreeNode parent = backnode;

                while ((parent = parent.getParent()).getName() != null) {
                    prenodes.add(parent.getName());
                }
                while (counter-- > 0) {
                    newTransRecords.add(prenodes);
                }
                backnode = backnode.getNextHomonym();
            }

            FPGrowth(newTransRecords, newPostPattern);
        }
    }


    public ArrayList<TreeNode> buildHeaderTable(List<List<String>> transRecords) {
        ArrayList<TreeNode> F1 = null;
        if (transRecords.size() > 0) {
            F1 = new ArrayList<TreeNode>();
            Map<String, TreeNode> map = new HashMap<String, TreeNode>();

            for (List<String> record : transRecords) {
                for (String item : record) {
                    if (!map.keySet().contains(item)) {
                        TreeNode node = new TreeNode(item);
                        node.setCount(1);
                        map.put(item, node);
                    } else {
                        map.get(item).countIncrement(1);
                    }
                }
            }

            Set<String> names = map.keySet();
            for (String name : names) {
                TreeNode tnode = map.get(name);
                if (tnode.getCount() >= minSuport) {
                    F1.add(tnode);
                }
            }
            Collections.sort(F1);
            return F1;
        } else {
            return null;
        }
    }


    public TreeNode buildFPTree(List<List<String>> transRecords,
            ArrayList<TreeNode> F1) {
        TreeNode root = new TreeNode();
        for (List<String> transRecord : transRecords) {
            LinkedList<String> record = sortByF1(transRecord, F1);
            TreeNode subTreeRoot = root;
            TreeNode tmpRoot = null;
            if (root.getChildren() != null) {
                while (!record.isEmpty()
                        && (tmpRoot = subTreeRoot.findChild(record.peek())) != null) {
                    tmpRoot.countIncrement(1);
                    subTreeRoot = tmpRoot;
                    record.poll();
                }
            }
            addNodes(subTreeRoot, record, F1);
        }
        return root;
    }

    public LinkedList<String> sortByF1(List<String> transRecord,
            ArrayList<TreeNode> F1) {
        Map<String, Integer> map = new HashMap<String, Integer>();
        for (String item : transRecord) {

            for (int i = 0; i < F1.size(); i++) {
                TreeNode tnode = F1.get(i);
                if (tnode.getName().equals(item)) {
                    map.put(item, i);
                }
            }
        }
        ArrayList<Entry<String, Integer>> al = new ArrayList<Entry<String, Integer>>(
                map.entrySet());
        Collections.sort(al, new Comparator<Map.Entry<String, Integer>>() {
            @Override
            public int compare(Entry<String, Integer> arg0,
                    Entry<String, Integer> arg1) {

                return arg0.getValue() - arg1.getValue();
            }
        });
        LinkedList<String> rest = new LinkedList<String>();
        for (Entry<String, Integer> entry : al) {
            rest.add(entry.getKey());
        }
        return rest;
    }


    public void addNodes(TreeNode ancestor, LinkedList<String> record,
            ArrayList<TreeNode> F1) {
        if (record.size() > 0) {
            while (record.size() > 0) {
                String item = record.poll();
                TreeNode leafnode = new TreeNode(item);
                leafnode.setCount(1);
                leafnode.setParent(ancestor);
                ancestor.addChild(leafnode);

                for (TreeNode f1 : F1) {
                    if (f1.getName().equals(item)) {
                        while (f1.getNextHomonym() != null) {
                            f1 = f1.getNextHomonym();
                        }
                        f1.setNextHomonym(leafnode);
                        break;
                    }
                }

                addNodes(leafnode, record, F1);
            }
        }
    }

    public static void main(String[] args) {
        FPTree fptree = new FPTree();
        fptree.setMinSuport(3);
        List<List<String>> transRecords = fptree
                .readTransRocords("/home/steven/automata/test.txt");
        fptree.FPGrowth(transRecords, null);
    }
}

1,2,3,5
2,3,5
4,5,6
2,4,6
1,3,5,8

---

如何解决这个问题？请帮助我

如果您真的想手动调用编译器，请确保在适当的输出目录中构建（而不是

），将其与

-classpath

参数一起使用，并按照正确的顺序编译类（

FPTree

之前的

TreeNode

）

---

或者使用

ant

、

maven

或IDE。

尝试从上面的一个文件夹编译代码：

javac parent/FPTree.java

也可以使用以下命令：

javac -classpath . *.java

---

首先尝试编译

TreeNode.java

，因为

FPTree.java

依赖于它。你不应该这样做（IIRC），但见鬼。另外，在编译FPTree时，使用

-cp.

选项告诉编译器在哪里可以找到TreeNode的类文件

当然，你也可以使用Maven，让你的生活变得更加轻松……

一些值得注意和提醒的东西：

摆弄包裹时，不要坐在这样的包裹里！你必须在外面

编译命令

javac-d。java

包含一个关于您所在位置的小提示。选项

-d.

可能意味着您位于一个名为

fptree

的目录中，该目录表示包

有这样的目录结构

<project_root>
      |
      |--- src/
      |     |--- fptree/
      |     |       |--- TreeNode.java
      |     |       |--- FPTree.java
      |
      |--- bin/

|
|---src/
||--fptree/
|||--TreeNode.java
|||--FPTree.java
|
|---垃圾箱/

那么编译程序的最佳方法如下：更改项目根目录。从这里，您可以使用

javac-d bin-sourcepath src TreeNode.java FPTree.java

---

你的JDK版本是什么？你用的是什么IDE？尝试Eclipse？Ctrl+Shift+O可以正常工作：）当然，如果您使用Eclipse…请确保所有必需的类都在类路径上。@Kieveli jdk版本是不相关的，就像IDE一样。文件在同一目录中吗？如果你的答案是否定的，那就把它们放在同一个目录中。使用Maven不会让他的生活因为这个小问题变得更容易。@DaveNewton：显然，如果他使用Maven，他根本不会有这个问题。表面上，建议Maven作为Java程序员入门的解决方案是愚蠢的。在使用Maven之前，您必须了解实际情况，否则您将无法解决Maven问题。即使是一个空的Maven原型，对于一个编程新手来说也是难以理解的。向一个甚至不知道如何从命令行编译两个文件的人扔Maven没有什么“更容易”的了。@DaveNewton:那么，有多少教程（和大学课程）用它来编写初级程序员呢？还有什么比轻视别人的建议更具建设性的事情吗？@DaveNewton：从一个不那么好斗的角度来说，你的论点的问题是，在教授事物如何真正工作是好的，如果你同时做每件事，你就会冒着“太多运动部件”压倒初学者的风险。这就是为什么许多课程让学生一开始就使用Maven或IDE来对学生隐藏这些细节。老实说，许多教授从不教这些细节。他们的理由是，他们在这里教授计算机科学概念，而不是“职业学校”。

javac -classpath . *.java

<project_root>
      |
      |--- src/
      |     |--- fptree/
      |     |       |--- TreeNode.java
      |     |       |--- FPTree.java
      |
      |--- bin/