计算线段长度java代码 java求线段的长度

java线段类，两个顶点，求线段长度，哪里不对呢？

1) 本文列出的名单是根据计算线段长度java代码我自己的调查计算线段长度java代码，并结合个人的经验。有可能是它们不恰恰是最流行的，但至少众所周知的。

2) 我会不断更新这个列表，使之更加完整和准确。感谢您的意见。

一个典型的Java项目依赖于第三方库。本文总结的Java库适用于各种应用，比较流行并且广泛使用。其中一些还提供简单的示例（来自ProgramCreek）。

Java SDK 肯定是使用最广的库，所以本文的名单焦点是流行的第三方库。该列表可能并不完善，所以如果你觉得有什么应该出现在列表中的，请留下您的评论。非常感谢！

1、核心库

Apache Commons Lang：来自Apache的核心库，为java.lang API补充计算线段长度java代码了许多常用的工具类，如字符串操作、对象的创建等。

Google Guava：来自谷歌的核心库，包括集合（Collection）、缓存（Caching）、支持原语（Primitives）等。（示例）

2、HTML、XML Parser

Jsoup：一个简化计算线段长度java代码了的 HTML操作的库。（示例）

STaX：一组可以高效处理 XML的API。 （示例）

3、Web框架

Spring：Java平台上众所周知的开源框架和依赖注入容器。（示例）

Struts2：来自Apache的流行Web框架。 （示例）

Google Web Toolkit：Google提供的开发工具库，主要用于构建和优化复杂的Web程序用。 （示例）

Strips：使用最新Java技术构建的Web程序框架，推荐使用。

Tapestry：面向组件的框架，用于使用Java创建动态、健壮、扩展性高的Web应用程序。

请猛击这里 查看以上面框架之间的比较。

4、图表、报表、图像

JFreeChart：用于创建如条形图、折线图、饼图等图表。

JFreeReport：创建于输出PDF格式的报表。

JGraphT：创建图像，其中只包含由线段连接的点集。

5、窗口

Swing：SDK提供的GUI库。（示例）

SWT：Eclipse提供的GUI库。

SWT与Swing的比较。（链接）

6、GUI框架

Eclipse RCP。（示例）

7、自然语言处理

OpenNLP：来自Apache的自然语言处理库。 （示例）

Stanford Parser：斯坦福大学提供的自然语言处理库。（示例）

如果你是一名NLP专家，请猛击这里 查看更多工具库介绍。

8、静态分析

Eclipse JDT：由IBM提供的静态分析库，可以操作Java源代码。（示例）

WALA：可以处理jar包文件（即字节码）的工具库。（示例）

9、JSON

Jackson： 用于处理JSON数据格式的多用途的Java库。Jackson 旨在快速、准确、轻量、对开人员友好之间找到最好的平衡点。

XStream：一个简单用于对象和XML互相转换的库。

Google Gson：一个专门用于Java对象和Json对象相互转换的工具库。（示例）

JSON-lib：用于 beans、maps、collections、java arrays、XML 和 JSON 之间相互转换操作的工具库。

10、数学

Apache Commons Math：提供数学计算和数值统计需函数的工具库。

11、日志

Apache Log4j：风行一时的日志记录操作库。 （示例）

Logback：当前流行的log4j项目的继任者。

SLF4J（The Simple Logging Facade for Java）： 各种日志框架的一个简单的外观或抽象（如java.util.logging 、logback、log4j等），允许用户在部署时加入需要的日志框架。

12、Office

Apache POI：利用其提供的APIs，可以使用纯Java代码操作各种基于微软OLE2合成文档格式的文档。

Docx4j：一个用于创建、操作微软公开的XML文件的库（支持Word docx、 Powerpoint pptx和Excel xlsx）。

13、日期和时间

Joda-Time：如有质量问题包退包换的Java日期和时间类。

14、数据库

Hibernate、EclipseLink、JPA

JDO

jOOQ

SpringJDBC、Spring Data

Apache DbUtils

15、开发工具

Lambok： 旨在减少代码编写的Java开发库。

java地图多个矩形计算亩数

* 多边形线、多边形面的关系,并计算折线长度和多边形的面积的公式。

* 主入口类是GeoUtils，

* 基于Baidu Map API 1.2。

*

* @author Baidu Map Api Group

* @version 1.2

*/

//BMapLib.GeoUtils.degreeToRad(Number)

//将度转化为弧度

//BMapLib.GeoUtils.getDistance(Point, Point)

//计算两点之间的距离,两点坐标必须为经纬度

//BMapLib.GeoUtils.getPolygonArea(polygon)

//计算多边形面或点数组构建图形的面积,注意：坐标类型只能是经纬度，且不适合计算自相交多边形的面积(封闭的面积)

//BMapLib.GeoUtils.getPolylineDistance(polyline)

//计算折线或者点数组的长度

//BMapLib.GeoUtils.isPointInCircle(point, circle)

//判断点是否在圆形内

//BMapLib.GeoUtils.isPointInPolygon(point, polygon)

//判断点是否多边形内

//BMapLib.GeoUtils.isPointInRect(point, bounds)

//判断点是否在矩形内

//BMapLib.GeoUtils.isPointOnPolyline(point, polyline)

//判断点是否在折线上

//BMapLib.GeoUtils.radToDegree(Number)

//将弧度转化为度

/**

* @namespace BMap的所有library类均放在BMapLib命名空间下

*/

var BMapLib = window.BMapLib = BMapLib || {};

(function () {

/**

* 地球半径

*/

var EARTHRADIUS = 6370996.81;

/**

* @exports GeoUtils as BMapLib.GeoUtils

*/

var GeoUtils =

/**

* GeoUtils类，静态类，勿需实例化即可使用

* @class GeoUtils类的入口。

* 该类提供的都是静态方法，勿需实例化即可使用。

*/

BMapLib.GeoUtils = function () {

}

/**

* 判断点是否在矩形内

* @param {Point} point 点对象

* @param {Bounds} bounds 矩形边界对象

* @returns {Boolean} 点在矩形内返回true,否则返回false

*/

GeoUtils.isPointInRect = function (point, bounds) {

//检查类型是否正确

if (!(point instanceof BMap.Point) ||

!(bounds instanceof BMap.Bounds)) {

return false;

}

var sw = bounds.getSouthWest(); //西南脚点

var ne = bounds.getNorthEast(); //东北脚点

return (point.lng = sw.lng point.lng = ne.lng point.lat = sw.lat point.lat = ne.lat);

}

/**

* 判断点是否在圆形内

* @param {Point} point 点对象

* @param {Circle} circle 圆形对象

* @returns {Boolean} 点在圆形内返回true,否则返回false

*/

GeoUtils.isPointInCircle = function (point, circle) {

//检查类型是否正确

if (!(point instanceof BMap.Point) ||

!(circle instanceof BMap.Circle)) {

return false;

}

//point与圆心距离小于圆形半径，则点在圆内，否则在圆外

var c = circle.getCenter();

var r = circle.getRadius();

var dis = GeoUtils.getDistance(point, c);

if (dis = r) {

return true;

} else {

return false;

}

}

/**

* 判断点是否在折线上

* @param {Point} point 点对象

* @param {Polyline} polyline 折线对象

* @returns {Boolean} 点在折线上返回true,否则返回false

*/

GeoUtils.isPointOnPolyline = function (point, polyline) {

//检查类型

if (!(point instanceof BMap.Point) ||

!(polyline instanceof BMap.Polyline)) {

return false;

}

//首先判断点是否在线的外包矩形内，如果在，则进一步判断，否则返回false

var lineBounds = polyline.getBounds();

if (!this.isPointInRect(point, lineBounds)) {

return false;

}

//判断点是否在线段上，设点为Q，线段为P1P2 ，

//判断点Q在该线段上的依据是：( Q - P1 ) × ( P2 - P1 ) = 0，且 Q 在以 P1，P2为对角顶点的矩形内

var pts = polyline.getPath();

for (var i = 0; i

var curPt = pts[i];

var nextPt = pts[i + 1];

//首先判断point是否在curPt和nextPt之间，即：此判断该点是否在该线段的外包矩形内

if (point.lng = Math.min(curPt.lng, nextPt.lng) point.lng = Math.max(curPt.lng, nextPt.lng)

point.lat = Math.min(curPt.lat, nextPt.lat) point.lat = Math.max(curPt.lat, nextPt.lat)) {

//判断点是否在直线上公式

var precision = (curPt.lng - point.lng) * (nextPt.lat - point.lat) - (nextPt.lng - point.lng) * (curPt.lat - point.lat);

if (precision -2e-10) {//实质判断是否接近0

return true;

}

}

}

return false;

}

/**

* 判断点是否多边形内

* @param {Point} point 点对象

* @param {Polyline} polygon 多边形对象

* @returns {Boolean} 点在多边形内返回true,否则返回false

*/

GeoUtils.isPointInPolygon = function (point, polygon) {

//检查类型

if (!(point instanceof BMap.Point) ||

!(polygon instanceof BMap.Polygon)) {

return false;

}

//首先判断点是否在多边形的外包矩形内，如果在，则进一步判断，否则返回false

var polygonBounds = polygon.getBounds();

if (!this.isPointInRect(point, polygonBounds)) {

return false;

}

var pts = polygon.getPath(); //获取多边形点

//下述代码来源：，进行了部分修改

//基本思想是利用射线法，计算射线与多边形各边的交点，如果是偶数，则点在多边形外，否则

//在多边形内。还会考虑一些特殊情况，如点在多边形顶点上，点在多边形边上等特殊情况。

var N = pts.length;

var boundOrVertex = true; //如果点位于多边形的顶点或边上，也算做点在多边形内，直接返回true

var intersectCount = 0; //cross points count of x

var precision = 2e-10; //浮点类型计算时候与0比较时候的容差

var p1, p2; //neighbour bound vertices

var p = point; //测试点

p1 = pts[0]; //left vertex

for (var i = 1; i = N; ++i) {//check all rays

if (p.equals(p1)) {

return boundOrVertex; //p is an vertex

}

p2 = pts[i % N]; //right vertex

if (p.lat Math.max(p1.lat, p2.lat)) {//ray is outside of our interests

p1 = p2;

continue; //next ray left point

}

if (p.lat Math.min(p1.lat, p2.lat) p.lat

if (p.lng = Math.max(p1.lng, p2.lng)) {//x is before of ray

if (p1.lat == p2.lat p.lng = Math.min(p1.lng, p2.lng)) {//overlies on a horizontal ray

return boundOrVertex;

}

if (p1.lng == p2.lng) {//ray is vertical

if (p1.lng == p.lng) {//overlies on a vertical ray

return boundOrVertex;

} else {//before ray

++intersectCount;

}

} else {//cross point on the left side

var xinters = (p.lat - p1.lat) * (p2.lng - p1.lng) / (p2.lat - p1.lat) + p1.lng; //cross point of lng

if (Math.abs(p.lng - xinters)

return boundOrVertex;

}

if (p.lng

++intersectCount;

}

}

}

} else {//special case when ray is crossing through the vertex

if (p.lat == p2.lat p.lng = p2.lng) {//p crossing over p2

var p3 = pts[(i + 1) % N]; //next vertex

if (p.lat = Math.min(p1.lat, p3.lat) p.lat = Math.max(p1.lat, p3.lat)) {//p.lat lies between p1.lat p3.lat

++intersectCount;

} else {

intersectCount += 2;

}

}

}

p1 = p2; //next ray left point

}

if (intersectCount % 2 == 0) {//偶数在多边形外

return false;

} else { //奇数在多边形内

return true;

}

}

/**

* 将度转化为弧度

* @param {degree} Number 度

* @returns {Number} 弧度

*/

GeoUtils.degreeToRad = function (degree) {

return Math.PI * degree / 180;

}

/**

* 将弧度转化为度

* @param {radian} Number 弧度

* @returns {Number} 度

*/

GeoUtils.radToDegree = function (rad) {

return (180 * rad) / Math.PI;

}

/**

* 将v值限定在a,b之间，纬度使用

*/

function _getRange(v, a, b) {

if (a != null) {

v = Math.max(v, a);

}

if (b != null) {

v = Math.min(v, b);

}

return v;

}

/**

* 将v值限定在a,b之间，经度使用

*/

function _getLoop(v, a, b) {

while (v b) {

v -= b - a

}

while (v

v += b - a

}

return v;

}

/**

* 计算两点之间的距离,两点坐标必须为经纬度

* @param {point1} Point 点对象

* @param {point2} Point 点对象

* @returns {Number} 两点之间距离，单位为米

*/

GeoUtils.getDistance = function (point1, point2) {

//判断类型

if (!(point1 instanceof BMap.Point) ||

!(point2 instanceof BMap.Point)) {

return 0;

}

point1.lng = _getLoop(point1.lng, -180, 180);

point1.lat = _getRange(point1.lat, -74, 74);

point2.lng = _getLoop(point2.lng, -180, 180);

point2.lat = _getRange(point2.lat, -74, 74);

var x1, x2, y1, y2;

x1 = GeoUtils.degreeToRad(point1.lng);

y1 = GeoUtils.degreeToRad(point1.lat);

x2 = GeoUtils.degreeToRad(point2.lng);

y2 = GeoUtils.degreeToRad(point2.lat);

return EARTHRADIUS * Math.acos((Math.sin(y1) * Math.sin(y2) + Math.cos(y1) * Math.cos(y2) * Math.cos(x2 - x1)));

}

/**

* 计算折线或者点数组的长度

* @param {Polyline|Array} polyline 折线对象或者点数组

* @returns {Number} 折线或点数组对应的长度

*/

GeoUtils.getPolylineDistance = function (polyline) {

//检查类型

if (polyline instanceof BMap.Polyline ||

polyline instanceof Array) {

//将polyline统一为数组

var pts;

if (polyline instanceof BMap.Polyline) {

pts = polyline.getPath();

} else {

pts = polyline;

}

if (pts.length

return 0;

}

//遍历所有线段将其相加，计算整条线段的长度

var totalDis = 0;

for (var i = 0; i

var curPt = pts[i];

var nextPt = pts[i + 1]

var dis = GeoUtils.getDistance(curPt, nextPt);

totalDis += dis;

}

return totalDis;

} else {

return 0;

}

}

/**

* 计算多边形面或点数组构建图形的面积,注意：坐标类型只能是经纬

度，且不适合计算自相交多边形的面积

* @param {Polygon|Array} polygon 多边形面对象或者点数

组

* @returns {Number} 多边形面或点数组构成图形的面积

*/

GeoUtils.getPolygonArea = function (polygon) {

//检查类型

if (!(polygon instanceof BMap.Polygon)

!(polygon instanceof Array)) {

return 0;

}

var pts;

if (polygon instanceof BMap.Polygon) {

pts = polygon.getPath();

} else {

pts = polygon;

}

if (pts.length

return 0;

}

var totalArea = 0; //初始化总面积

var LowX = 0.0;

var LowY = 0.0;

var MiddleX = 0.0;

var MiddleY = 0.0;

var HighX = 0.0;

var HighY = 0.0;

var AM = 0.0;

var BM = 0.0;

var CM = 0.0;

var AL = 0.0;

var BL = 0.0;

var CL = 0.0;

var AH = 0.0;

var BH = 0.0;

var CH = 0.0;

var CoefficientL = 0.0;

var CoefficientH = 0.0;

var ALtangent = 0.0;

var BLtangent = 0.0;

var CLtangent = 0.0;

var AHtangent = 0.0;

var BHtangent = 0.0;

var CHtangent = 0.0;

var ANormalLine = 0.0;

var BNormalLine = 0.0;

var CNormalLine = 0.0;

var OrientationValue = 0.0;

var AngleCos = 0.0;

var Sum1 = 0.0;

var Sum2 = 0.0;

var Count2 = 0;

var Count1 = 0;

var Sum = 0.0;

var Radius = EARTHRADIUS; //6378137.0,WGS84椭球半径

var Count = pts.length;

for (var i = 0; i

if (i == 0) {

LowX = pts[Count - 1].lng * Math.PI / 180;

LowY = pts[Count - 1].lat * Math.PI / 180;

MiddleX = pts[0].lng * Math.PI / 180;

MiddleY = pts[0].lat * Math.PI / 180;

HighX = pts[1].lng * Math.PI / 180;

HighY = pts[1].lat * Math.PI / 180;

}

else if (i == Count - 1) {

LowX = pts[Count - 2].lng * Math.PI / 180;

LowY = pts[Count - 2].lat * Math.PI / 180;

MiddleX = pts[Count - 1].lng * Math.PI / 180;

MiddleY = pts[Count - 1].lat * Math.PI / 180;

HighX = pts[0].lng * Math.PI / 180;

HighY = pts[0].lat * Math.PI / 180;

}

else {

LowX = pts[i - 1].lng * Math.PI / 180;

LowY = pts[i - 1].lat * Math.PI / 180;

MiddleX = pts[i].lng * Math.PI / 180;

MiddleY = pts[i].lat * Math.PI / 180;

HighX = pts[i + 1].lng * Math.PI / 180;

HighY = pts[i + 1].lat * Math.PI / 180;

}

AM = Math.cos(MiddleY) * Math.cos(MiddleX);

BM = Math.cos(MiddleY) * Math.sin(MiddleX);

CM = Math.sin(MiddleY);

AL = Math.cos(LowY) * Math.cos(LowX);

BL = Math.cos(LowY) * Math.sin(LowX);

CL = Math.sin(LowY);

AH = Math.cos(HighY) * Math.cos(HighX);

BH = Math.cos(HighY) * Math.sin(HighX);

CH = Math.sin(HighY);

CoefficientL = (AM * AM + BM * BM + CM * CM) / (AM * AL + BM * BL + CM * CL);

CoefficientH = (AM * AM + BM * BM + CM * CM) / (AM * AH + BM * BH + CM * CH);

ALtangent = CoefficientL * AL - AM;

BLtangent = CoefficientL * BL - BM;

CLtangent = CoefficientL * CL - CM;

AHtangent = CoefficientH * AH - AM;

BHtangent = CoefficientH * BH - BM;

CHtangent = CoefficientH * CH - CM;

AngleCos = (AHtangent * ALtangent + BHtangent * BLtangent + CHtangent * CLtangent) / (Math.sqrt(AHtangent * AHtangent + BHtangent * BHtangent + CHtangent * CHtangent) * Math.sqrt(ALtangent * ALtangent + BLtangent * BLtangent + CLtangent * CLtangent));

AngleCos = Math.acos(AngleCos);

ANormalLine = BHtangent * CLtangent - CHtangent * BLtangent;

BNormalLine = 0 - (AHtangent * CLtangent - CHtangent * ALtangent);

CNormalLine = AHtangent * BLtangent - BHtangent * ALtangent;

if (AM != 0)

OrientationValue = ANormalLine / AM;

else if (BM != 0)

OrientationValue = BNormalLine / BM;

else

OrientationValue = CNormalLine / CM;

if (OrientationValue 0) {

Sum1 += AngleCos;

Count1++;

}

else {

Sum2 += AngleCos;

Count2++;

}

}

var tempSum1, tempSum2;

tempSum1 = Sum1 + (2 * Math.PI * Count2 - Sum2);

tempSum2 = (2 * Math.PI * Count1 - Sum1) + Sum2;

if (Sum1 Sum2) {

if ((tempSum1 - (Count - 2) * Math.PI)

Sum = tempSum1;

else

Sum = tempSum2;

}

else {

if ((tempSum2 - (Count - 2) * Math.PI)

Sum = tempSum2;

else

Sum = tempSum1;

}

totalArea = (Sum - (Count - 2) * Math.PI) * Radius * Radius;

return totalArea; //返回总面积

}

})(); //闭包结束

java怎么求点到线段的距离

import java.util.Scanner;

public class Distance {

public static void main(String[] args) {

Line L = new Line(2,3,5);

Scanner sc = new Scanner(System.in);

System.out.println("输入点的x坐标：");

double x = sc.nextDouble();

System.out.println("输入点的y坐标：");

double y = sc.nextDouble();

System.out.println(distence(x,y,L));

}

public static double distence(double x,double y,Line L){

return Math.abs(L.A*x+L.B*y+L.C)/Math.sqrt(L.A*L.A+L.B*L.B);

}

}

class Line{//直线类,方程为：Ax+By+C=0

double A;

double B;

double C;

public Line(double A,double B,double C){

this.A = A;

this.B = B;

this.C = C;

}

}

Java 通过类的继承，求直线的长度。

继承是继承父类的方法,而子类相当于有一个"隐藏"的父类的方法,只是不用再写罢了.这时候我们声明子类时,父类里边的方法都可以调取.

通常父类里边放的东西是你定义的一个通用标准,而子类,相当于特例,当不在通用时,就该写子类了!

比如求直线长度,假设我们定义了一条标准线段,那么直线就是无数个线段构成;标准线段就是通用的,可以为父类方法,直线的长度方法为子类方法,那么求直线长度就容易了.

这时如果求其他线段长度,因为标准线段以及定义,所以需要建一个子类继承它,就可以求线段长度了!

至于题目,应该是有问题的,但不影响里边的逻辑

跪求JAVA高手，我有几个程序想要高手帮忙编一下！急急急！QQ：362168209~

Point类

/**

*

* @author MrCao.tk

*

*/

public class Point {

private float x;

private float y;

public float getX() {

return x;

}

public void setX(float x) {

this.x = x;

}

public float getY() {

return y;

}

public void setY(float y) {

this.y = y;

}

public Point(float x, float y) {

super();

this.x = x;

this.y = y;

}

public Point() {

super();

}

}

-------------------------------------

Line类

/**

*

* @author MrCao.tk

*

*/

public class Line {

private Point a;

private Point b;

public Point getA() {

return a;

}

public void setA(Point a) {

this.a = a;

}

public Point getB() {

return b;

}

public void setB(Point b) {

this.b = b;

}

public Line() {

super();

}

public Line(Point a, Point b) {

super();

this.a = a;

this.b = b;

}

/**

* 计算直线的长度

* @return 长度

*/

public float getLength() {

float _x = (a.getX() - b.getX()) * (a.getX() - b.getX());

float _y = (a.getY() - b.getY()) * (a.getY() - b.getY());

return (float)Math.sqrt(_x + _y);

}

/**

* 线段中点到坐标原点的距离

* @return 距离

*/

public float getOriginalPointLength() {

//计算出中点

Point midpoint = new Point((a.getX() + b.getX() / 2) , (a.getY() + b.getY()) / 2);

//把中点与原点组装成直线

Line line = new Line(new Point(0 , 0), midpoint);

return line.getLength();

}

}

-------------------------------------

Triangle类

/**

*

* @author MrCao.tk

*

*/

public class Triangle {

private Point a;

private Point b;

private Point c;

public Point getA() {

return a;

}

public void setA(Point a) {

this.a = a;

}

public Point getB() {

return b;

}

public void setB(Point b) {

this.b = b;

}

public Point getC() {

return c;

}

public void setC(Point c) {

this.c = c;

}

public Triangle(Point a, Point b, Point c) {

super();

this.a = a;

this.b = b;

this.c = c;

}

public Triangle() {

super();

}

/**

* 计算三角形的周长

* @return 周长

* @throws Exception

*/

public float getLength() throws Exception {

if(isTriangle() == false) {

throw new Exception("不是三角形");

}

Line line1 = new Line(a, b);

Line line2 = new Line(b, c);

Line line3 = new Line(c, a);

return line1.getLength() + line2.getLength() + line3.getLength();

}

/**

* 计算三角形面积

* @return 面积

* @throws Exception

*/

public float getAcreage() throws Exception {

if(isTriangle() == false) {

throw new Exception("不是三角形");

}

//用海伦公式计算

Line line1 = new Line(a, b);

Line line2 = new Line(b, c);

Line line3 = new Line(c, a);

float p = (line1.getLength() + line2.getLength() + line3.getLength()) / 2;

return (float) Math.sqrt(p * (p - line1.getLength()) * (p - line2.getLength()) * (p - line3.getLength()));

}

/**

* 判断是否三角形

* @return 能否组成三角形

* @throws Exception

*/

public boolean isTriangle() {

Line line1 = new Line(a, b);

Line line2 = new Line(b, c);

Line line3 = new Line(c, a);

try {

if(line1.getLength() + line2.getLength() line3.getLength()

line1.getLength() + line3.getLength() line2.getLength()

line2.getLength() + line3.getLength() line1.getLength()

line1.getLength() - line2.getLength() line3.getLength()

line1.getLength() - line3.getLength() line2.getLength()

line2.getLength() - line3.getLength() line1.getLength()

line2.getLength() - line1.getLength() line3.getLength()

line3.getLength() - line1.getLength() line2.getLength()

line3.getLength() - line2.getLength() line1.getLength()) {

return true;

}

} catch(Exception e) {

return false;

}

return false;

}

}

谁知道用java编写计算平面内两条线段的最短距离，求解啊，急急急急急急急急啊~！！！十万火急啊~！！！！

求他们的4个端点坐标的距离。

假设:

线段一的2端坐标是(10,10)(20,25)

线段二的2端坐标是(39,40)(60,60)

现判断是否相交。相交的话最短距离是0。

不是相交的话。计算2个线段的端点距离。

端点距离可能有一下四种组合：

线段一(10,10)和线段二的(39,40)的距离

线段一(10,10)和线段二的(60,60)的距离

线段一(20,25)和线段二的(39,40)的距离

线段一(20,25)和线段二的(60,60)的距离

求2点之间的距离就不用我说了吧。求出以上4个距离值。最小的那个就是最短距离

计算线段长度java代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java求线段的长度、计算线段长度java代码的信息别忘了在本站进行查找喔。