Java 为什么可以'；我的CSV文件是否在我的图表上显示内容？

基本上，我的程序所做的是，我有一个csv文件，可以在 毫秒（我已转换）和表示区域的字母。我试图将其显示为条形图，但每个字母（区域）都有不同的选项卡。我的 问题是试图将信件（从文件）发送到我在选项卡中创建的特定区域。也许我遗漏了什么，但我不确定。任何帮助都将不胜感激

这是我的密码：

@SuppressWarnings({ "serial", "deprecation" })
public class InductionTreeGraph extends JFrame {

static TimeSeries ts = new TimeSeries("data", Millisecond.class);

public static void add(JTabbedPane jtp, String label, int mnemonic, AbstractButton button1)
{
    int count = jtp.getTabCount();
    JButton button = new JButton(label);
    button.setBackground(Color.WHITE);
    jtp.addTab(label, null, button, null);
    jtp.setMnemonicAt(count, mnemonic);

}

public InductionTreeGraph() throws Exception {

        final XYDataset dataset = (XYDataset) createDataset();
        final JFreeChart chart = createChart(dataset);
        final ChartPanel chartPanel = new ChartPanel(chart);
        chartPanel.setPreferredSize(new Dimension(1000, 400));
        setContentPane(chartPanel);

        JFrame frame = new JFrame("Induction Zone Chart");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        final JTabbedPane jtp = new JTabbedPane();
        jtp.setTabLayoutPolicy(JTabbedPane.SCROLL_TAB_LAYOUT);
        String zones[] = {"Zone A", "Zone B", "Zone C", "Zone S",
                "Zone SH","Zone W"};
        int mnemonic[] = {KeyEvent.VK_A, KeyEvent.VK_B, KeyEvent.VK_C,
                KeyEvent.VK_S, KeyEvent.VK_H,KeyEvent.VK_W};

        for (int i = 0, n=zones.length; i<n; i++)
        {
            AbstractButton button1 = null;
            InductionTreeGraph.add(jtp, zones[i], mnemonic[i], button1);
        }

        final JPanel p = new JPanel(new FlowLayout(FlowLayout.RIGHT));
        p.add(new JButton(new AbstractAction("Update") {

             public void actionPerformed(ActionEvent e) {
                chartPanel.repaint();
             }

        }));

        frame.add(jtp, BorderLayout.NORTH);
        frame.add(p, BorderLayout.SOUTH);
        frame.getContentPane().add(chartPanel);
        frame.pack();
        frame.setVisible(true);
        frame.setLocationRelativeTo(null);

}

    @SuppressWarnings("deprecation")
    private XYDataset createDataset() {
        final TimeSeriesCollection dataset = new TimeSeriesCollection();
        dataset.addSeries(ts);

        TreeMap<String,TreeMap<Integer,Integer[]>> zoneMap = getInductions("","");
        // Iterate through all zones and print induction rates for every minute into
        // every hour by zone...
        Iterator<String> zoneIT = zoneMap.keySet().iterator();
        while (zoneIT.hasNext())
        {
            String zone = zoneIT.next();
            TreeMap<Integer,Integer[]> hourCountsInZoneMap = zoneMap.get(zone);
            System.out.println("ZONE " + zone + " : ");
            Iterator<Integer> hrIT = hourCountsInZoneMap.keySet().iterator();
            while (hrIT.hasNext())
            {
                int hour = hrIT.next();
                Integer [] indRatePerMinArray = hourCountsInZoneMap.get(hour);
                for (int i=0; i< indRatePerMinArray.length; i++)
                {
                    System.out.print(hour + ":");
                    System.out.print(i < 10 ? "0" + i : i);
                    System.out.println(" = " + indRatePerMinArray[i] + " induction(s)");
                }
            }
        }

        return dataset;
}

    @SuppressWarnings("deprecation")
    private JFreeChart createChart(XYDataset dataset) {
        final JFreeChart chart = ChartFactory.createXYBarChart(
                "Induction Zone Chart", 
                "Hour", 
                true,
                "Inductions Per Minute", 
                (IntervalXYDataset) dataset, 
                PlotOrientation.VERTICAL,
                false, 
                true, 
                false
        );

        XYPlot plot = (XYPlot)chart.getPlot();
        XYBarRenderer renderer = (XYBarRenderer)plot.getRenderer();
        renderer.setBarPainter(new StandardXYBarPainter());
        renderer.setDrawBarOutline(false);
        ValueAxis axis = plot.getDomainAxis();
            axis.setAutoRange(true);
            axis.setFixedAutoRange(60000.0);

        // Set an Induction target of 30 per minute
        Marker target = new ValueMarker(30);
        target.setPaint(java.awt.Color.blue);
        target.setLabel("Induction Rate Target");
        plot.addRangeMarker(target);

        return chart;
    }

private TreeMap<String, TreeMap<Integer, Integer[]>> getInductions(String mills, String zone) {

    // TreeMap of Inductions for Every Minute in Day Per Zone...
    // Key = Zone
    // Value = TreeMap of Inductions per Minute per Hour:
    //          Key = Hour
    //          Value = Array of 60 representing Induction Rate Per Minute
    //                  (each element is the induction rate for that minute)
    TreeMap<String, TreeMap<Integer, Integer[]>> zoneMap = new TreeMap<String, TreeMap<Integer, Integer[]>>();

    // Input file name...
    String fileName = "/home/a002384/ECLIPSE/IN070914.CSV";

    try 
    {
        BufferedReader br = new BufferedReader(new FileReader(fileName));
        String line;
        try
        {
            // Read a line from the csv file until it reaches to the end of the file...
            while ((line = br.readLine()) != null)
            {
                // Parse a line of text in the CSV...
                String [] indData = line.split("\\,");
                long millisecond = Long.parseLong(indData[0]);
                String zone1 = indData[1];

                // The millisecond value is the number of milliseconds since midnight.
                // From this, we can derive the hour and minute of the day as follows:
                int secOfDay = (int)(millisecond / 1000);
                int hrOfDay = secOfDay / 3600;
                int minInHr = secOfDay % 3600 / 60;

                // Obtain the induction rate TreeMap for the current zone.
                // If this is a "newly-encountered" zone, create a new TreeMap.
                TreeMap<Integer, Integer[]> hourCountsInZoneMap;
                if (zoneMap.containsKey(zone1))
                    hourCountsInZoneMap = zoneMap.get(zone1);
                else
                    hourCountsInZoneMap = new TreeMap<Integer, Integer[]>();

                // Obtain the induction rate array for the current hour in the current zone.
                // If this is a new hour in the current zone, create a new array,
                // and initialize this array with all zeroes.
                // The array is size 60, because there are 60 minutes in the hour.
                // Each element in the array represents the induction rate for that minute.
                Integer [] indRatePerMinArray;
                if (hourCountsInZoneMap.containsKey(hrOfDay))
                    indRatePerMinArray = hourCountsInZoneMap.get(hrOfDay);
                else
                {
                    indRatePerMinArray = new Integer[60];
                    Arrays.fill(indRatePerMinArray, 0);
                }

                // Increment the induction rate for the current minute by one.
                // Each line in the csv file represents a single induction at a
                // single point in time.
                indRatePerMinArray[minInHr]++;

                // Add everything back into the TreeMaps if these are newly-created.
                if (!hourCountsInZoneMap.containsKey(hrOfDay))
                    hourCountsInZoneMap.put(hrOfDay, indRatePerMinArray);
                if (!zoneMap.containsKey(zone1))
                    zoneMap.put(zone1, hourCountsInZoneMap);

            }
        }
        finally
        {
            br.close();
        }
    }
    catch (Exception e)
    {
        e.printStackTrace();
    }

    return zoneMap;
}

@SuppressWarnings("deprecation")
public static void main(String[] args) throws Exception {
    try {
        InductionTreeGraph dem = new InductionTreeGraph();
        dem.pack();
        dem.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        while(true) {
            double millisecond = 2;
            double num = millisecond;
            System.out.println(num);
            ts.addOrUpdate(new Millisecond(), num);
            try {
                Thread.sleep(20);
            } catch (InterruptedException ex) {
                System.out.println(ex);
            }
        }

    }
    catch (Exception e)
    {
        e.printStackTrace();
    }
}

}

@SuppressWarnings（{“串行”，“弃用”}）
公共类归纳图扩展JFrame{
静态时间序列ts=新时间序列（“数据”，毫秒.class）；
公共静态void add（JTabbedPane jtp、字符串标签、int助记符、AbstractButton按钮1）
{
int count=jtp.getTabCount（）；
JButton按钮=新JButton（标签）；
按钮。背景（颜色。白色）；
jtp.addTab（标签，空，按钮，空）；
设置助记符（计数，助记符）；
}
public InjectionTreeGraph（）引发异常{
最终XYDataset数据集=（XYDataset）createDataset（）；
最终JFreeChart图表=createChart（数据集）；
最终图表面板图表面板=新图表面板（图表）；
chartPanel.setPreferredSize（新尺寸（1000400））；
setContentPane（图表面板）；
JFrame=新JFrame（“感应区图”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
最终JTabbedPane jtp=新JTabbedPane（）；
jtp.可设置的输出策略（JTabbedPane.滚动选项卡布局）；
字符串区域[]={“区域A”、“区域B”、“区域C”、“区域S”，
“SH区”、“W区”}；
int助记符[]={KeyEvent.VK_A，KeyEvent.VK_B，KeyEvent.VK_C，
KeyEvent.VK_S，KeyEvent.VK_H，KeyEvent.VK_W}；
对于（int i=0，n=zones.length；i我的第一个建议是关于这条线：

setContentPane(chartPanel);

不要弄乱内容窗格。请改用此行：

getContentPane().add(chartPanel);


我在您的代码中看到的问题是，
inclusiontreegraph
从
JFrame
扩展而来，您将此
chartPanel
设置为此框架的内容窗格，但随后使用新的
JFrame
局部变量（称为
frame
），并将此
chartPanel
添加到此框架：

JFrame frame = new JFrame("Induction Zone Chart");
...
frame.getContentPane().add(chartPanel);

 Swing组件旨在“按原样使用”，因此最好是继承而不是继承。已经说过，应该在类声明中考虑删除<代码>扩展jFrase>代码，并将所有组件（图表面板、按钮等）添加到本地“代码>帧< /COD>”。

相关的
您可能需要查看中所示的示例。此示例或任何@trashgood在堆栈溢出中关于
JFreeChart
（f.e.）的示例可能会帮助您更好地构造代码。
+1@user38414请参阅