求教高手如何java绘画出一条趋势线？ 为什么我用Java写的画图软件画出来的图线条是折线，有没有更...

import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.event.ComponentEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Arc2D;
import java.awt.geom.GeneralPath;
import java.awt.geom.Rectangle2D;

import javax.swing.ImageIcon;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Charts2D extends JFrame {

public Charts2D() {
super("2D Charts");
setSize(720, 280);
getContentPane().setLayout(new GridLayout(1, 3, 10, 0));
getContentPane().setBackground(Color.white);

int[] xData = new int[8];
int[] yData = new int[8];
for (int i = 0; i < xData.length; i++) {
xData[i] = i;
yData[i] = (int) (Math.random() * 100);
if (i > 0)
yData[i] = (yData[i - 1] + yData[i]) / 2;
}

JChart2D chart = new JChart2D(JChart2D.LineChart, xData.length, xData, yData,
"Line Chart");
chart.setStroke(new BasicStroke(5f, BasicStroke.CAP_ROUND,
BasicStroke.JOIN_MITER));
chart.setLineColor(new Color(0, 28, 28));
getContentPane().add(chart);

chart = new JChart2D(JChart2D.ColumnChart, xData.length, xData, yData,
"Column Chart");
GradientPaint gp = new GradientPaint(0, 100, Color.white, 0, 300,
Color.blue, true);
chart.setGradient(gp);
chart.setEffectIndex(JChart2D.Gradientffect);
chart.setDrawShadow(true);
getContentPane().add(chart);

chart = new JChart2D(JChart2D.PieChart, xData.length, xData, yData,
"Pie Chart");
ImageIcon icon = new ImageIcon("largeJava2slogo.GIF");
chart.setForegroundImage(icon.getImage());
chart.setEffectIndex(JChart2D.ImageEffect);
chart.setDrawShadow(true);
getContentPane().add(chart);

WindowListener wndCloser = new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
};
addWindowListener(wndCloser);

setVisible(true);
}

public static void main(String argv[]) {
new Charts2D();
}

}

class JChart2D extends JPanel {
public static final int LineChart = 0;

public static final int ColumnChart = 1;

public static final int PieChart = 2;

public static final int PLainEffect = 0;

public static final int Gradientffect = 1;

public static final int ImageEffect = 2;

protected int m_chartType = LineChart;

protected JLabel titleLabel;

protected ChartPanel chartPanel;

protected int dataLength;

protected int[] xData;

protected int[] yData;

protected int xMin;

protected int xMax;

protected int yMin;

protected int yMax;

protected double[] pieData;

protected int m_effectIndex = PLainEffect;

protected Stroke stroke;

protected GradientPaint gradient;

protected Image foregroundImage;

protected Color lineColor = Color.black;

protected Color columnColor = Color.blue;

protected int columnWidth = 12;

protected boolean drawShadow = false;

public JChart2D(int type, int nData, int[] yData, String text) {
this(type, nData, null, yData, text);
}

public JChart2D(int type, int nData, int[] xD, int[] yD, String text) {
super(new BorderLayout());
setBackground(Color.white);
titleLabel = new JLabel(text, JLabel.CENTER);
add(titleLabel, BorderLayout.NORTH);

m_chartType = type;

if (xData == null) {
xData = new int[nData];
for (int k = 0; k < nData; k++)
xData[k] = k;
}
if (yD == null)
throw new IllegalArgumentException("yData can't be null");
if (nData > yD.length)
throw new IllegalArgumentException("Insufficient yData length");
if (nData > xD.length)
throw new IllegalArgumentException("Insufficient xData length");
dataLength = nData;
xData = xD;
yData = yD;

xMin = xMax = 0; // To include 0 into the interval
yMin = yMax = 0;
for (int k = 0; k < dataLength; k++) {
xMin = Math.min(xMin, xData[k]);
xMax = Math.max(xMax, xData[k]);
yMin = Math.min(yMin, yData[k]);
yMax = Math.max(yMax, yData[k]);
}
if (xMin == xMax)
xMax++;
if (yMin == yMax)
yMax++;

if (m_chartType == PieChart) {
double sum = 0;
for (int k = 0; k < dataLength; k++) {
yData[k] = Math.max(yData[k], 0);
sum += yData[k];
}
pieData = new double[dataLength];
for (int k = 0; k < dataLength; k++)
pieData[k] = yData[k] * 360.0 / sum;
}

chartPanel = new ChartPanel();
add(chartPanel, BorderLayout.CENTER);
}

public void setEffectIndex(int effectIndex) {
m_effectIndex = effectIndex;
repaint();
}

public int getEffectIndex() {
return m_effectIndex;
}

public void setStroke(Stroke s) {
stroke = s;
chartPanel.repaint();
}

public void setForegroundImage(Image img) {
foregroundImage = img;
repaint();
}

public Image getForegroundImage() {
return foregroundImage;
}

public Stroke getStroke() {
return stroke;
}

public void setGradient(GradientPaint g) {
gradient = g;
repaint();
}

public GradientPaint getGradient() {
return gradient;
}

public void setColumnWidth(int c) {
columnWidth = c;
chartPanel.calcDimensions();
chartPanel.repaint();
}

public int setColumnWidth() {
return columnWidth;
}

public void setColumnColor(Color c) {
columnColor = c;
chartPanel.repaint();
}

public Color getColumnColor() {
return columnColor;
}

public void setLineColor(Color c) {
lineColor = c;
chartPanel.repaint();
}

public Color getLineColor() {
return lineColor;
}

public void setDrawShadow(boolean d) {
drawShadow = d;
chartPanel.repaint();
}

public boolean getDrawShadow() {
return drawShadow;
}

class ChartPanel extends JComponent {
int xMargin = 5;

int yMargin = 5;

int pieGap = 10;

int m_x;

int m_y;

int m_w;

int m_h;

ChartPanel() {
enableEvents(ComponentEvent.COMPONENT_RESIZED);
}

protected void processComponentEvent(ComponentEvent e) {
calcDimensions();
}

public void calcDimensions() {
Dimension d = getSize();
m_x = xMargin;
m_y = yMargin;
m_w = d.width - 2 * xMargin;
m_h = d.height - 2 * yMargin;
if (m_chartType == ColumnChart) {
m_x += columnWidth / 2;
m_w -= columnWidth;
}
}

public int xChartToScreen(int x) {
return m_x + (x - xMin) * m_w / (xMax - xMin);
}

public int yChartToScreen(int y) {
return m_y + (yMax - y) * m_h / (yMax - yMin);
}

public void paintComponent(Graphics g) {
int x0 = 0;
int y0 = 0;
if (m_chartType != PieChart) {
g.setColor(Color.black);
x0 = xChartToScreen(0);
g.drawLine(x0, m_y, x0, m_y + m_h);
y0 = yChartToScreen(0);
g.drawLine(m_x, y0, m_x + m_w, y0);
}

Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
RenderingHints.VALUE_ANTIALIAS_ON);
g2.setRenderingHint(RenderingHints.KEY_RENDERING,
RenderingHints.VALUE_RENDER_QUALITY);

if (stroke != null)
g2.setStroke(stroke);

GeneralPath path = new GeneralPath();
switch (m_chartType) {
case LineChart:
g2.setColor(lineColor);
path.moveTo(xChartToScreen(xData[0]),
yChartToScreen(yData[0]));
for (int k = 1; k < dataLength; k++)
path.lineTo(xChartToScreen(xData[k]),
yChartToScreen(yData[k]));
g2.draw(path);
break;

case ColumnChart:
for (int k = 0; k < dataLength; k++) {
xMax++;
int x = xChartToScreen(xData[k]);
int w = columnWidth;
int y1 = yChartToScreen(yData[k]);
int y = Math.min(y0, y1);
int h = Math.abs(y1 - y0);
Shape rc = new Rectangle2D.Double(x, y, w, h);
path.append(rc, false);
xMax--;
}

if (drawShadow) {
AffineTransform s0 = new AffineTransform(1.0, 0.0, 0.0,
-1.0, x0, y0);
s0.concatenate(AffineTransform.getScaleInstance(1.0, 0.5));
s0.concatenate(AffineTransform.getShearInstance(0.5, 0.0));
s0.concatenate(new AffineTransform(1.0, 0.0, 0.0, -1.0,
-x0, y0));
g2.setColor(Color.gray);
Shape shadow = s0.createTransformedShape(path);
g2.fill(shadow);
}

if (m_effectIndex == Gradientffect && gradient != null) {
g2.setPaint(gradient);
g2.fill(path);
} else if (m_effectIndex == ImageEffect
&& foregroundImage != null)
fillByImage(g2, path, 0);
else {
g2.setColor(columnColor);
g2.fill(path);
}
g2.setColor(lineColor);
g2.draw(path);
break;

case PieChart:
double start = 0.0;
double finish = 0.0;
int ww = m_w - 2 * pieGap;
int hh = m_h - 2 * pieGap;
if (drawShadow) {
ww -= pieGap;
hh -= pieGap;
}

for (int i = 0; i < dataLength; i++) {
finish = start + pieData[i];
double f1 = Math.min(90 - start, 90 - finish);
double f2 = Math.max(90 - start, 90 - finish);
Shape shp = new Arc2D.Double(m_x, m_y, ww, hh, f1, f2 - f1,
Arc2D.PIE);
double f = (f1 + f2) / 2 * Math.PI / 180;
AffineTransform s1 = AffineTransform.getTranslateInstance(
pieGap * Math.cos(f), -pieGap * Math.sin(f));
s1.translate(pieGap, pieGap);
Shape piece = s1.createTransformedShape(shp);
path.append(piece, false);
start = finish;
}

if (drawShadow) {
AffineTransform s0 = AffineTransform.getTranslateInstance(
pieGap, pieGap);
g2.setColor(Color.gray);
Shape shadow = s0.createTransformedShape(path);
g2.fill(shadow);
}

if (m_effectIndex == Gradientffect && gradient != null) {
g2.setPaint(gradient);
g2.fill(path);
} else if (m_effectIndex == ImageEffect
&& foregroundImage != null)
fillByImage(g2, path, 0);
else {
g2.setColor(columnColor);
g2.fill(path);
}

g2.setColor(lineColor);
g2.draw(path);
break;
}
}

protected void fillByImage(Graphics2D g2, Shape shape, int xOffset) {
if (foregroundImage == null)
return;
int wImg = foregroundImage.getWidth(this);
int hImg = foregroundImage.getHeight(this);
if (wImg <= 0 || hImg <= 0)
return;
g2.setClip(shape);
Rectangle bounds = shape.getBounds();
for (int i = bounds.x + xOffset; i < bounds.x + bounds.width; i += wImg)
for (int j = bounds.y; j < bounds.y + bounds.height; j += hImg)
g2.drawImage(foregroundImage, i, j, this);
}
}
}
来源http://www.java2java.com/CN/Code/Java/2D-Graphics-GUI/Demobarchartandpiechart.htm
非常好的一个网站

是画到jsp页面的话可以参考下jqplot这个jquery插件，
如果想单机程序实现的话下面有段程序是画曲线的，如果用类似方法画趋势线的话，可以出效果，但是估计画出来都没什么适用价值：

import java.awt.geom.QuadCurve2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
public class DrawLine {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
BufferedImage image=new BufferedImage(100,100,BufferedImage.TYPE_INT_RGB);
QuadCurve2D.Double quXian=new QuadCurve2D.Double(50,50,0,100,0,0);
image.createGraphics().draw(quXian);
File file=new File("c:\\abc.jpg");
try {
javax.imageio.ImageIO.write(image, "jpg", file);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

楼主，把你的单线程服务放在servlet中实现就行，
tomcat ,weblogic等web容器会内部自动实现多线程（不需要你担心）

为什么我用Java写的画图软件画出来的图线条是折线，有没有更好的方法变成平滑曲线~

折线的每一条线段都很短、转折角度比较圆滑的话，就OK了。

　　方式：
　　1.打开表格，输入需要制表的数据。如图

　　2.点击【插入】选择【图表】。如图

　　3.在【图表】里选择【X Y散点图】，点击完成。如图


　　4.选择图表里面的一个点，鼠标右击，选择【添加趋势线】。如图

　　5.在【添加趋势线】界面里面点【选择】进入界面。如图

　　6.在【选项】里面勾选【显示公式】和【显示R平均值】，点完就可以了。如图

　　7.最后完成。

相关要点总结：

17371906188：求教高手如何java绘画出一条趋势线?
陶终答：import java.awt.BorderLayout;import java.awt.Color;import java.awt.Dimension;import java.awt.GradientPaint;import java.awt.Graphics;import java.awt.Graphics2D;import java.awt.GridLayout;import java.awt.Image;import java.awt.Rectangle;import java.awt.RenderingHints;import java.awt.Shape;import java.a...

17371906188：java怎么画出一条直线呢?高手进吧。
陶终答：tc1.setBorder(BorderFactory.createLineBorder(Color.BLUE));tc2 = new TestComponent();tc2.setBorder(BorderFactory.createLineBorder(Color.PINK));contentPane.add(tc1);contentPane.add(tc2);} } class TestComponent extends JComponent { public void paintComponent(Graphics g1) { Graphics2D g...

17371906188：请教高手:java画图问题
陶终答：一定要用java画图的话，我可以提供最简单的思路。JAVA中有一个画图函数paint(Graphics g)。例如先绘制出一个坐标轴可用如下代码 public void paint(Graphics g){ int startx = 50;int starty = 500;int endx = 500;int endy = 500;g.setColor(Color.black);g.drawLine(startx, starty, star...

17371906188：请教JAVA编程高手一个问题,如何在面板上绘图?
陶终答：绘图的奇妙之处在于能够将某一个给定数据值从一个范围按比例缩放到另一个范围中,也就是说,如果给定一组值,如 {10,20,30},那么您应该能够确定 2-D 飞机上具体哪些点(X 坐标和 Y 坐标)表示的是 10、20 和 30 这些数据值。 绘制总是在按照某一个限定缩放比例进行的。换句话说,在同一限定区域内,可以绘制...

17371906188：高中生想成为JAVA软件编程高手要怎样做?
陶终答：8.架构设计。架构设计在程序设计中是相当关键的一步，需不断摸索和研究，总结出自己的方法。9.软件工程。开发软件的过程，我经历过公司从CMM到敏捷的转变，我个人是比较推崇敏捷开发的，这里想与大家站在工程的角度聊一聊软件开发。10.质量管理。越往后其实越偏向管理了，开始是个人修炼，后面是站在组织...

17371906188：如何挑战成为java高手?
陶终答：1、扎实的基础 数据结构、离散数学、编译原理，这些是所有计算机科学的基础，如果不掌握它们，很难写出高水平的程序。程序人人都会写，但当你发现写到一定程度很难再提高的时候，就应该想想是不是要回过头来学学这些基本的理论。不要一开始就去学OOP，即使你再精通OOP，遇到一些基本算法的时候可能也会束...

17371906188：java求教~如何规划java学习之路
陶终答：1. 师资力量雄厚 要想有1+1>2的实际效果，很关键的一点是师资队伍，你接下来无论是找个工作还是工作中出任哪些的人物角色，都越来越爱你本身的技术专业java技术性，也许的技术专业java技术性则绝大多数来自你的技术专业java教师，一个好的java培训机构必须具备雄厚的师资力量。2. 就业保障完善 实现1+...

17371906188：请专业java大神给出 java高手进阶路线图
陶终答：新手最初学习的时候先要从JavaSE开始学起，所包含的内容主要分为：面向对象概念的理解、Java基本语法的学习，Java桌面图形界面应用程序的开发，掌握常用的Java API等（关键是要学会怎样查阅）。重点：Java基本语法（循环结构，数据类型，数组，运算符等）、Swing，awt，事件机制、文件输入输出流处理等；Java...

17371906188：java编程:怎么写进度条?高手进哈
陶终答：1.人为的划分某些标识，达到某个标识就是完成了百分之多少。2.如果是上传和下载附件，可以将文件大小作为100%，上传或下载百分之多少，就是百分之多少。3.对进度的类型所需时间进行分类。划出几种时间。属于某类，大概或平均完成时间是多少，那么就以这个时间作为100%。然后产生进度。但，完美的进度是...

17371906188：找个会swing的java高手帮忙给程序加个进度条
陶终答：定义个变量，记录当前加载了多少资源。每加载1个资源，就把这个变量++。然后根据这个变量的值，绘制进度条（要设置可视区域）这里要注意的是，加载资源一般要多起一条线程去加载。不然，你的资源加载完了，才去绘制进度条没任何意义。。。（LZ的程序是切割程序的话，原理是相同的。。。）...