精华内容
下载资源
问答
  • Java二维坐标动态曲线图绘制

    万次阅读 多人点赞 2016-11-18 21:21:36
    将一串随机数输入到二维坐标轴中,不断刷新JPanel,实现动态显示的效果 import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics...

    将一串随机数输入到二维坐标轴中,不断刷新JPanel,实现动态显示的效果微笑

    import java.awt.BasicStroke;
    import java.awt.BorderLayout;
    import java.awt.Color;
    import java.awt.Graphics;
    import java.awt.Graphics2D;
    import java.awt.RenderingHints;
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Random;
    
    import javax.swing.JFrame;
    import javax.swing.JPanel;
    
    public class Chart_test extends JFrame {
    
    	private List<Integer> values;// 保存接受的数据容器
    	private static final int MAX_VALUE = 180;// 接受到的数据最大值
    	private static final int MAX_COUNT_OF_VALUES = 50;// 最多保存数据的个数
    	// private
    	private MyCanvas trendChartCanvas = new MyCanvas();
    	// 框架起点坐标
    	private final int FREAME_X = 50;
    	private final int FREAME_Y = 50;
    	private final int FREAME_WIDTH = 600;// 横
    	private final int FREAME_HEIGHT = 250;// 纵
    
    	// 原点坐标
    	private final int Origin_X = FREAME_X + 50;
    	private final int Origin_Y = FREAME_Y + FREAME_HEIGHT - 30;
    
    	// X,Y轴终点坐标
    	private final int XAxis_X = FREAME_X + FREAME_WIDTH - 30;
    	private final int XAxis_Y = Origin_Y;
    	private final int YAxis_X = Origin_X;
    	private final int YAxis_Y = FREAME_Y + 30;
    
    	// X轴上的时间分度值(1分度=40像素)
    	private final int TIME_INTERVAL = 50;
    	// Y轴上值
    	private final int PRESS_INTERVAL = 30;
    
    	public Chart_test() {
    		super("前端界面显示:");
    		values = Collections.synchronizedList(new ArrayList<Integer>());// 防止引起线程异常
    		// 创建一个随机数线程
    		new Thread(new Runnable() {
    			public void run() {
    				Random rand = new Random();
    				try {
    					while (true) {
    						addValue(rand.nextInt(MAX_VALUE) + 90);
    						repaint();
    						Thread.sleep(100);
    					}
    				} catch (InterruptedException b) {
    					b.printStackTrace();
    				}
    			}
    
    		}).start();
    
    		this.setDefaultCloseOperation(EXIT_ON_CLOSE);
    		this.setBounds(300, 200, 900, 600);
    		this.add(trendChartCanvas, BorderLayout.CENTER);
    		this.setVisible(true);
    	}
    
    	public void addValue(int value) {
    		// 循环的使用一个接受数据的空间
    		if (values.size() > MAX_COUNT_OF_VALUES) {
    			values.remove(0);
    		}
    		values.add(value);
    	}
    
    	// 画布重绘图
    	class MyCanvas extends JPanel {
    		private static final long serialVersionUID = 1L;
    
    		public void paintComponent(Graphics g) {
    			Graphics2D g2D = (Graphics2D) g;
    
    			Color c = new Color(200, 70, 0);
    			g.setColor(c);
    			super.paintComponent(g);
    
    			// 绘制平滑点的曲线
    			g2D.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    			int w = XAxis_X;// 起始点
    			int xDelta = w / MAX_COUNT_OF_VALUES;
    			int length = values.size() - 10;
    
    			for (int i = 0; i < length - 1; ++i) {
    				g2D.drawLine(xDelta * (MAX_COUNT_OF_VALUES - length + i), values.get(i),
    						xDelta * (MAX_COUNT_OF_VALUES - length + i + 1), values.get(i + 1));
    			}
    			// 画坐标轴
    			g2D.setStroke(new BasicStroke(Float.parseFloat("2.0F")));// 轴线粗度
    			// X轴以及方向箭头
    			g.drawLine(Origin_X, Origin_Y, XAxis_X, XAxis_Y);// x轴线的轴线
    			g.drawLine(XAxis_X, XAxis_Y, XAxis_X - 5, XAxis_Y - 5);// 上边箭头
    			g.drawLine(XAxis_X, XAxis_Y, XAxis_X + 5, XAxis_Y + 5);// 下边箭头
    
    			// Y轴以及方向箭头
    			g.drawLine(Origin_X, Origin_Y, YAxis_X, YAxis_Y);
    			g.drawLine(YAxis_X, YAxis_Y, YAxis_X - 5, YAxis_Y + 5);
    			g.drawLine(YAxis_X, YAxis_Y, YAxis_X + 5, YAxis_Y + 5);
    
    			// 画X轴上的时间刻度(从坐标轴原点起,每隔TIME_INTERVAL(时间分度)像素画一时间点,到X轴终点止)
    			g.setColor(Color.BLUE);
    			g2D.setStroke(new BasicStroke(Float.parseFloat("1.0f")));
    
    			// X轴刻度依次变化情况
    			for (int i = Origin_X, j = 0; i < XAxis_X; i += TIME_INTERVAL, j += TIME_INTERVAL) {
    				g.drawString(" " + j, i - 10, Origin_Y + 20);
    			}
    			g.drawString("时间", XAxis_X + 5, XAxis_Y + 5);
    
    			// 画Y轴上血压刻度(从坐标原点起,每隔10像素画一压力值,到Y轴终点止)
    			for (int i = Origin_Y, j = 0; i > YAxis_Y; i -= PRESS_INTERVAL, j += TIME_INTERVAL) {
    				g.drawString(j + " ", Origin_X - 30, i + 3);
    			}
    			g.drawString("幅度/Amplitude", YAxis_X - 5, YAxis_Y - 5);// 血压刻度小箭头值
    			// 画网格线
    			g.setColor(Color.BLACK);
    			// 坐标内部横线
    			for (int i = Origin_Y; i > YAxis_Y; i -= PRESS_INTERVAL) {
    				g.drawLine(Origin_X, i, Origin_X + 10 * TIME_INTERVAL, i);
    			}
    			// 坐标内部竖线
    			for (int i = Origin_X; i < XAxis_X; i += TIME_INTERVAL) {
    				g.drawLine(i, Origin_Y, i, Origin_Y - 6 * PRESS_INTERVAL);
    			}
    
    		}
    	}
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		new Chart_test();
    	}
    }
    

     

     

     

     

     

     

     

    展开全文
  • 二维坐标两点距离公式 根号[(x1-x2)平方+(y1-y2)平方]3.JAVA Math.pow(变量,指数); 的运用4.JAVA Math.sqrt(); 求平方根的运用import java.util.Scanner; public class Test { public static void main...

    知识点:
    1.三角形的判断公式 两边之和大于第三边
    2.二维坐标两点距离公式 根号[(x1-x2)平方+(y1-y2)平方]
    3.JAVA Math.pow(变量,指数); 的运用
    4.JAVA Math.sqrt(); 求平方根的运用

    import java.util.Scanner;
    
    public class Test {
    
        public static void main(String[] args) {
            System.out.println("选择输入 选择要使用的功能:");
            System.out.println("1.计算坐标到(0,0)的距离");
            System.out.println("2.计算两个坐标之间的距离");
            System.out.println("3.判断三个坐标是否构成三角形");
            //键入选择
            int i =0;
            int x1;
            int y1;
    
            int x2;
            int y2;
    
            int x3;
            int y3;
    
            //实例化对象
            Point p = new Point();
            boolean k = true;
            while (k){
                try {
                    Scanner scan = new Scanner(System.in);
                    i = scan.nextInt();
                    if (i   < 0 || i > 3){
                        System.out.println("选择错误,请正确选择!");
                    }else {
    
                    if (i == 1){
                        System.out.println("# 1 #");
                        System.out.println("请输入坐标X1:");
                        x1 =scan.nextInt();
                        System.out.println("请输入坐标Y1:");
                        y1 =scan.nextInt();
                        p.distance(x1,y1);
                    }else if (i == 2){
                        System.out.println("# 2 #");
                        System.out.println("请输入坐标X1:");
                        x1 =scan.nextInt();
                        System.out.println("请输入坐标Y1:");
                        y1 =scan.nextInt();
    
                        System.out.println("请输入坐标X2:");
                        x2 =scan.nextInt();
                        System.out.println("请输入坐标Y2:");
                        y2 =scan.nextInt();
                        p.distanceOfPoint(x1,y1,x2,y2);
                    }else {
                        System.out.println("# 3 #");
                        System.out.println("请输入坐标X1:");
                        x1 =scan.nextInt();
                        System.out.println("请输入坐标Y1:");
                        y1 =scan.nextInt();
    
                        System.out.println("请输入坐标X2:");
                        x2 =scan.nextInt();
                        System.out.println("请输入坐标Y2:");
                        y2 =scan.nextInt();
    
                        System.out.println("请输入坐标X3:");
                        x3 =scan.nextInt();
                        System.out.println("请输入坐标Y3:");
                        y3 =scan.nextInt();
    
                        p.traingle(x1,y1,x2,y2,x3,y3);
                    }
    
                        k = false;}
    
                } catch (Exception e) {
                    System.out.println("输入有误,请重新输入!");
    
                }
            }
    
    
    
    
        }
    }
    
    class Point{
    
        public int x,y;//横纵坐标
    
        //无参构造方法
        public Point(){
            this(0,0);
        }
        //带有两个参数的构造方法
        public Point(int x,int y){
            this.x = x;
            this.y = y;
        }
        //移动坐标
        public void moveTo(int x,int y){
            this.x = x;
            this.y = y;
        }
        //计算给定点到0,0坐标的距离
        //二维坐标两点之间的距离计算公式 #根号 [(x1-x2)²+(y1-y2)²]#
        public void distance(int x,int y){
            double distance=0.0;
    
            distance = Math.sqrt(      Math.pow(x-0,2)      +     Math.pow(y-0,2)    );
    
            System.out.println("您输入的坐标:\t"+"("+x+","+y+")");
            System.out.println();
            System.out.println("它到 (0,0)之间的距离是:\t"+distance);
    
            return;
        }
    
        //计算给点两个点之间的距离
        //二维坐标两点之间的距离计算公式 #根号 [(x1-x2)²+(y1-y2)²]#
        public void distanceOfPoint(int x1,int y1,int x2,int y2){
            double distanceOfPoint = 0.0;
    
            distanceOfPoint = Math.sqrt(  Math.pow(x1-x2,2) +   Math.pow(y1-y2,2)  );
    
    
            System.out.println("您输入的坐标:\t"+"("+x1+","+y1+")"+"\t"+"("+x2+","+y2+")");
            System.out.println();
            System.out.println("它们之间的距离是:\t"+distanceOfPoint);
    
            return;
    
        }
    
        //判断三个点是否能构成一个三角形
        public void traingle(int x1,int y1,int x2,int y2,int x3,int y3){
            double dis1 = 0.0;
            double dis2 = 0.0;
            double dis3 = 0.0;
            //计算各点之间距离 既是边长
    
            dis1 = Math.sqrt(   Math.pow(x1-x2,2) + Math.pow(y1-y2,2)   );
    
    
            dis2 = Math.sqrt(   Math.pow(x1-x3,2) + Math.pow(y1-y3,2)   );
    
    
            dis3 = Math.sqrt(   Math.pow(x2-x3,2) + Math.pow(y2-y3,2)   );
            //两边之和大于第三边判断是否构成三角形
            if (dis1 + dis2 > dis3 && dis1 + dis3 > dis2 && dis2 + dis3 > dis1){
                System.out.println("您输入的坐标:\t"+"("+x1+","+y1+")"+"("+x2+","+y2+")"+"("+x3+","+y3+")"+"\t构成一个三角形");
            }else{
                System.out.println("您输入的坐标:\t"+"("+x1+","+y1+")"+"("+x2+","+y2+")"+"("+x3+","+y3+")"+"\t不构成一个三角形");
            }
            return;
        }
    }
    展开全文
  • 不知道有没有人有这样的java源码,就是输入希尔伯特曲线的阶数,能返回一个希尔伯特曲线每个编号所在的x、y的二维坐标,当然这个坐标是一个数据集。或者输入希尔伯特曲线的阶数和编号,得到一个二维坐标。希望大神有...
  • 三角形用三个而坐标点表示, 每个点的坐标都是 double 类型 方法 应当能够判断对应点是否在三角形内 应当能够得到三角形的面积 应当能够得到三角形的周长 代码 import org.junit.Assert; import java.awt.geom.Line...

    三角形应用

    需求

    字段

    三角形用三个而坐标点表示, 每个点的坐标都是 double 类型

    方法

    应当能够判断对应点是否在三角形内

    应当能够得到三角形的面积

    应当能够得到三角形的周长

    代码

    
    import org.junit.Assert;
    
    import java.awt.geom.Line2D;
    
    /**
     * @author LeXin Huang
     * @date 2021年04月16日 8:07
     */
    
    public class MyPoint2D {
        private final Double x;
    
        private final Double y;
    
        public MyPoint2D(Double x, Double y) {
            this.x = x;
            this.y = y;
        }
    
        static class MyTriangle2D {
            private MyPoint2D p1;
            private MyPoint2D p2;
            private MyPoint2D p3;
    
            public MyTriangle2D() {
                this.p1 = new MyPoint2D(0.0, 0.0);
                this.p2 = new MyPoint2D(1.0, 1.0);
                this.p3 = new MyPoint2D(2.0, 5.0);
            }
    
            public MyTriangle2D(MyPoint2D p1, MyPoint2D p2, MyPoint2D p3) {
                this.p1 = p1;
                this.p2 = p2;
                this.p3 = p3;
            }
    
    //        利用海伦公式
            public double getArea() {
                double p = getPerimeter() * 0.5;
                return Math.sqrt(p*(p - getSide1Len())*(p - getSide2Len())*(p - getSide3Len()));
            }
    
            /**
             * @return p1, p2 点之间的线段长度
             */
            private double getSide1Len() {
                return Math.sqrt(Math.pow((p1.x - p2.x), 2) + Math.pow((p1.y - p2.y), 2));
            }
    
            /**
             * @return p1, p3 点之间的线段长度
             */
            private double getSide2Len() {
                return Math.sqrt(Math.pow((p1.x - p3.x), 2) + Math.pow((p1.y - p3.y), 2));
            }
    
            /**
             * @return p2, p3 点之间的线段长度
             */
            private double getSide3Len() {
                return Math.sqrt(Math.pow((p2.x - p3.x), 2) + Math.pow((p2.y - p3.y), 2));
            }
    
            public double getPerimeter() {
                double sideLength1 = getSide1Len();
                double sideLength2 = getSide2Len();
                double sideLength3 = getSide3Len();
                return sideLength1 + sideLength2 + sideLength3;
            }
    
            /**
             * 重心法判断点是否在三角形内部, v0,v1和v2是向量
             * v0 = C – A, v1 = B – A, v2 = P – A,则v2 = u * v0 + v * v1
             * 当 u == 1 且 v == 0 时, 则在 C点上, u == 0 且 v == 0 则在 B点上
             * @param p 二维点
             * @return 点在三角形内部的真值
             */
            public boolean contains(MyPoint2D p) {
                Vector v0 = new Vector(p3.x - p1.x, p3.y - p1.y);
                Vector v1 = new Vector(p2.x - p1.x, p2.y - p1.y);
                Vector v2 = new Vector(p.x - p1.x, p.y - p1.y);
                double dot00 = dot(v0, v0);
                double dot01 = dot(v0, v1);
                double dot02 = dot(v0, v2);
                double dot11 = dot(v1, v1);
                double dot12 = dot(v1, v2);
                double invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
                double u = (dot11 * dot02 - dot01 * dot12) * invDenom;
                double v = (dot00 * dot12 - dot01 * dot02) * invDenom;
                if ((0.0 == u && 1.0 == v) || (0.0 == v && 1.0 == u)) {
                    return true;
                }
                return (u >= 0) && (v >= 0) && (u + v < 1);
            }
    
            private double dot(Vector v1, Vector v2) {
                return (v1.x * v2.x) + (v1.y * v2.y);
            }
    
            public boolean contains(MyTriangle2D triangle2D) {
                return contains(triangle2D.p1) && contains(triangle2D.p2) && contains(triangle2D.p3);
            }
    
    //      枚举
            public boolean overlaps(MyTriangle2D triangle) {
                if (Line2D.linesIntersect(p1.x, p1.y, p2.x, p2.y,
                        triangle.p1.x, triangle.p1.y, triangle.p2.x, triangle.p2.y)) {
                    return true;
                }
                if (Line2D.linesIntersect(p2.x, p2.y, p3.x, p3.y,
                        triangle.p2.x, triangle.p2.y, triangle.p3.x, triangle.p3.y)) {
                    return true;
                }
                return Line2D.linesIntersect(p3.x, p3.y, p1.x, p1.y,
                        triangle.p3.x, triangle.p3.y, triangle.p1.x, triangle.p1.y);
            }
    
        }
    
        static class Line{
    
            MyPoint2D p1;
    
            MyPoint2D p2;
    
    
            public Line(MyPoint2D p1, MyPoint2D p2) {
                this.p1 = p1;
                this.p2 = p2;
            }
    
            boolean contains(MyPoint2D point) {
                return 0 == multiply(point, p2, p2);
            }
    
            public static double multiply(MyPoint2D target, MyPoint2D p1, MyPoint2D p2) {
                return ((p1.x - target.x)*(p2.y - target.y) - (p2.x - target.x)*(p1.y - target.y));
            }
        }
    
    
        static class Vector{
            double x;
            double y;
    
            public Vector(double x, double y) {
                this.x = x;
                this.y = y;
            }
        }
    
        public static void main(String[] args) {
            MyTriangle2D original = new MyTriangle2D();
            System.out.println("original.getArea() = " + original.getArea());
            System.out.println("original.getPerimeter() = " + original.getPerimeter());
            MyTriangle2D self = new MyTriangle2D();
            System.out.println("original.contains(self) = " + original.contains(self));
    
    
            MyPoint2D p1 = new MyPoint2D(0.0, 0.0);
            MyPoint2D p2 = new MyPoint2D(1.0, 1.0);
            MyPoint2D p3 = new MyPoint2D(2.0, 5.0);
            MyPoint2D p4 = new MyPoint2D(0.5, 0.5);
            MyPoint2D p5 = new MyPoint2D(12.9, 12.1);
            
           //        true in the triangle
            Assert.assertTrue(original.contains(p1));
            Assert.assertTrue(original.contains(p2));
            Assert.assertTrue(original.contains(p3));
            Assert.assertTrue(original.contains(p4));
            //        false
            Assert.assertFalse(original.contains(p5));
    
            MyPoint2D sonPoint1 = new MyPoint2D(0.0, 0.0);
            MyPoint2D sonPoint2 = new MyPoint2D(0.5, 0.5);
            MyPoint2D sonPoint3 = new MyPoint2D(1.0, 2.5);
            MyTriangle2D son = new MyTriangle2D(sonPoint1, sonPoint2, sonPoint3);
            System.out.println("=============边长缩小两倍后=============");
            System.out.println("son.getArea() = " + son.getArea());
            System.out.println("son.getPerimeter() = " + son.getPerimeter());
            System.out.println("original.contains(son) = " + original.contains(son));
        }
    }
    
    

    运行测试截图

    在这里插入图片描述

    代码解释

    思路

    面积使用海伦公式即可, 周长根据平方的开放得到各个边的长度

    判断点是否在三角形的内部, 使用三角形重心参照方法资料

    即平面内的一点的坐标, 可以用三角形的两条边的向量, 通过乘积相加的形式得到

    步骤

    1. 构建 MyPoint2D 类, 指定 double 类型的 x, y 变量
    2. 构建 MyTriangle2D 类, 指定三个 final MyPoint2D 类型的变量, 用于表示三个点
    3. 依次增加方法, 分别用于计算三角形的周长, 面积等
    4. 构建 Vector 类. 表示向量, 在 MyTriangle2D 类中, 增加用于向量点积的方法 dot(Vector v1, Vector v2);
    5. 写出判断点是否在三角形内的方法 contains(MyPoint2D p) (难点), 而判断三角形是否在内部, 只需要连续判断三个点是否在三角形内部即可
    展开全文
  • 关键字: Java基本语法 输入输出 算术运算 关系运算 选择语句 内容要求: 编写程序,实现如下功能: 提示用户输入2个圆的圆心坐标和各自的半径值,判断并输出这两个圆之前的位置关系。 两个圆之间的位置关系有如下三种...

    关键字: Java基本语法 输入输出 算术运算 关系运算 选择语句

    内容要求:

    编写程序,实现如下功能:

    提示用户输入2个圆的圆心坐标和各自的半径值,判断并输出这两个圆之前的位置关系。

    两个圆之间的位置关系有如下三种:
    ⚪

    两个圆包含时输出:圆 (x1, y1) - r1 包含 圆 (x2, y2) - r2

    两个圆相交时输出:圆 (x1, y1) - r1 与 圆 (x2, y2) - r2 相交

    两个圆无关时输出:圆 (x1, y1) - r1 与 圆 (x2, y2) - r2 无关


    运行实例1:

    输入第1个圆 x y r : 0.0 1.0 5.0

    输入第2个圆 x y r : 0.0 0.0 10.0

    (0.00,0.00)-10.00 包含 (0.00,1.00)-5.00


    运行实例2:

    输入第1个圆 x y r : 0.0 0.0 3.0

    输入第2个圆 x y r : 1.0 1.0 4.0

    (0.00,0.00)-3.00 与 (1.00,1.00)-4.00 相交


    运行实例3:

    输入第1个圆 x y r : 1.0 1.0 1.0

    输入第2个圆 x y r : 15.0 -3.0 5.0

    (1.00,1.00)-1.00 与 (15.00,-3.00)-5.00 无关



    备注

    提交要求:包含源程序文件的JAR


    实现代码:

    package Experience1124;
    
    import java.util.Scanner;
    
    public class Circle {
        public static void main(String[] args) {
            System.out.print("输入第1个圆 x y r :");
            Scanner sc=new Scanner(System.in);
            double x1=sc.nextDouble();
            double y1=sc.nextDouble();
            double r1=sc.nextDouble();
            System.out.print("输入第2个圆 x y r :");
            double x2=sc.nextDouble();
            double y2=sc.nextDouble();
            double r2=sc.nextDouble();
            sc.close();//   eclipse下添加此句,以防报错
            Relationship(x1,y1,r1,x2,y2,r2);
    
        }
    
        public static void Relationship(double x1,double y1,double r1,double x2,double y2,double r2){
            double x=Math.abs(x2-x1);
            double y=Math.abs(y2-y1);
            double min=r1<r2?r1:r2;
            double l=Math.sqrt(x*x+y*y);
            //包含
            if(l+min<r1+r2-min){
                if(r1<r2){
                    System.out.println("("+String.format("%.2f",x2)+","+String.format("%.2f",y2)+")-"+String.format("%.2f",r2)+
                            " 包含 ("+String.format("%.2f",x1)+","+String.format("%.2f",y1)+")-"+String.format("%.2f",r1)+" ");
                } else{
                    System.out.println("("+String.format("%.2f",x1)+","+String.format("%.2f",y1)+")-"+String.format("%.2f",r1)+
                            " 包含 ("+String.format("%.2f",x2)+","+String.format("%.2f",y2)+")-"+String.format("%.2f",r2)+" ");
                }
            }
            //无关
            else if(l>r1+r2){
                System.out.println("("+String.format("%.2f",x1)+","+String.format("%.2f",y2)+")-"+String.format("%.2f",r2)+
                        " 与 ("+String.format("%.2f",x2)+","+String.format("%.2f",y2)+")-"+String.format("%.2f",r2)+" 无关");
            }
            //相交
            else{
                System.out.println("("+String.format("%.2f",x1)+","+String.format("%.2f",y2)+")-"+String.format("%.2f",r2)+
                        " 与 ("+String.format("%.2f",x2)+","+String.format("%.2f",y2)+")-"+String.format("%.2f",r2)+" 相交");
            }
        }
    }
    
    
    展开全文
  • 2.二维坐标两点距离公式 根号[(x1-x2)平方+(y1-y2)平方] 3.JAVA Math.pow(变量,指数); 的运用 4.JAVA Math.sqrt(); 求平方根的运用 import java.util.Scanner; public class Test { public static void main...
  • throw new IllegalArgumentException("坐标点coordinates长度必须是偶数"); for (int i = 0; i ; i++) ptsIdx.add(i); } public double[] run() { List<Integer> res = getMaxPolygon(ptsIdx); double[] ...
  • 思想就是取最小的x,当x一样取最小的y,取每个点与当前比对点的正切值从大到小排序得到顺时针的顺序 ... import java.util.*; /** * @version 1.0.0 ... * 离散二维坐标的顺时针方向排序工具类 */ public class...
  • // + TIMA_INTERVAL,纵坐标为数组第个,依次类推画出各线段 for (int i = 1, CurrentLowPressStart_X = Origin_X; i ; i++, CurrentLowPressStart_X += TIME_INTERVAL) { g.drawLine...
  • java swing 如何实现动态曲线图(在二维坐标里显示),饼状图! 用swing来实现像任务管理器中那样的动态曲线图,还要饼状图,使用java2D可以实现吗? ------解决方案-------------------- 用开源工具 你可以看...
  • Java 二维数组

    2017-12-01 08:46:00
    在生活中,比如坐标等等,我们需要用二维数组来表示。通过行号和列好来定位数据。 定义:类型 数组[][] 类型[][] 数组名  例如:float a[3][4]; //定义a为3行4列的数组 二维数组的声明和初始化 二维数组的...
  • java 二维数组的遍历

    2020-03-09 18:00:23
    二维数组的元素布局成平面状,对应二维坐标,即元素布局成若干行和若干列。 动态初始化: 例: int a[][] = new int[2][3]; 静态初始化: 例:int[][] arr = {{1,2},[2,3,4]} public class Test { public static ...
  • 先上代码,再来填坑 public class demo008_array2 { ... //创建一个二维数组 int [][] array_zero = new int[5][5]; //初始化二维数组 for (int i = 0; i < array_zero.length; i++) { for (int j = 0; j
  • java 二维数组

    2014-03-12 23:53:52
    数组只有一个属性,就是长度,就一位数组而言,array.length表示数组的长度,数组不同于常识,是从坐标为零开始的,例:数组的第一个元素可记为array[0];数组一般用循环来取出值,就java类型,数组可以储...
  • 二维数组逆时针打印,如下图: 解决思路:观察坐标变化和遍历方向变化 public static void main(String[] args) { Integer[][] arrays = new Integer[4][4]; arrays[0][0] = 0;arrays[0][1] = 1;arrays[0][2] =...
  • 五子棋是我们生活中一个经常玩的小游戏,游戏分为黑棋、白棋,游戏开始时,黑棋先落子,白棋随后落子,若某种颜色的棋子在横向、竖向、上斜向(坐标轴中y=x)、下斜向(坐标轴中y=-x)的某个方向形成五个相同的棋子...
  • import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Comparator; public class test { static class one{ private int x; private int y; private int
  • 利用二维数组的遍历去实现,代码如下: package qaq; import java.util.Scanner; public class GPS { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println...
  • 二维坐标间的线性变换

    千次阅读 2012-12-10 09:06:21
    开始做模拟时钟的bean了,看dW上Java 2D的那个例子很有意思,比JDK自带的applet要简单,因为用到了仿射变换(Affine Transformation),只用简单得多的运算就可以绘制较高质量的动画。乘SUN的JavaDoc中文化之东风...
  • flash.display.DisplayObject  类包含 z 属性和新的旋转和缩放属性,这些属性用于操作 3D 空间中的显示对象。DisplayObject.local3DToGlobal  () 方法提供了一种将...// 屏幕坐标系和3D坐标系:     ...
  • 二维坐标系变换为原点在左上角(测试用)   * GLES * JOGL * LWJGL * libgdx(使用g2d与pixmap)     package com.iteye.weimingtom.testgl; import java.nio.ByteBuffer; import java.nio.ByteOrder...
  • 如题: //for循环拿到平面所有点的坐标 double x; double y; List<Point2D.Double> pointList=new ArrayList();... 我用for循环拿到了100个点坐标,我要将其转化为二维数组,请问应该怎么写?
  • 将一串随机数输入到二维坐标轴中,不断刷新JPanel,实现动态显示的效果 import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D...
  • import java.util.HashMap; class Point { int x; int y; Point() { x = 0; y = 0; } Point(int a, int b) { x = a; y = b; } } public class Solution { //解法一:存在问题 public i...
  • Time Limit: 9000/4500 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 1206 Accepted Submission(s): 368 Problem Description TanBig, a friend o
  • public static void main(String[] args... System.out.printf("最大值是"+a[x][y]+"它的坐标是"+"["+x+"]"+"["+y+"]"); } }   转载于:https://www.cnblogs.com/loufangcheng/p/10530507.html
  • Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 262144/262144 K (Java/Others) Total Submission(s): 96 Accepted Submission(s): 77 Problem Description Have you ever pla
  • Java-二维数组最大值查找

    千次阅读 2019-05-26 17:12:51
    找出这个二维数组里,最大的那个值,并打印出其二维坐标。 程序 public class HelloWorld { public static void main(String[] args) { int[][] c=new int[5][5];//定义5*5的数组 int a=0,b=0,d...
  • 目前能想到的最完美的方案 重点思路:将xy捆绑到一块排序,因为y是倒叙需要计算下对应正序时的值,...import java.util.Arrays; public class Test { public static void main(String[] args) { Test test = new T

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 501
精华内容 200
关键字:

java二维坐标

java 订阅