锐客网

  1. 首页 > 生活百科 > it技术 > >

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

IT技术Point

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.lngpoint.lng = ne.lngpoint.lat = sw.latpoint.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[i1];
//首先判断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.latMath.max(p1.lat, p2.lat)) {//ray is outside of our interests
p1 = p2;
continue; //next ray left point
}
if (p.latMath.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.latp.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.latp.lng = p2.lng) {//p crossing over p2
var p3 = pts[(i1) % 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.latp3.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 (vb) {
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[i1]
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;
【计算线段长度java代码 java求线段的长度】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 = https://www.04ip.com/post/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[i1].lng * Math.PI / 180;
HighY = pts[i1].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 * AMBM * BMCM * CM) / (AM * ALBM * BLCM * CL);
CoefficientH = (AM * AMBM * BMCM * CM) / (AM * AHBM * BHCM * 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 * ALtangentBHtangent * BLtangentCHtangent * CLtangent) / (Math.sqrt(AHtangent * AHtangentBHtangent * BHtangentCHtangent * CHtangent) * Math.sqrt(ALtangent * ALtangentBLtangent * BLtangentCLtangent * 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 = https://www.04ip.com/post/ANormalLine / AM;
else if (BM != 0)
OrientationValue = https://www.04ip.com/post/BNormalLine / BM;
else
OrientationValue = https://www.04ip.com/post/CNormalLine / CM;
if (OrientationValue0) {
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 (Sum1Sum2) {
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编写计算平面内两条线段的最短距离，求解啊 ， 急急急急急急急急啊~?。。∈蚧鸺卑?。。。?/h2>求他们的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代码的信息别忘了在本站进行查找喔 。

    推荐阅读


    上一篇：电视怎么用优盘玩游戏机，电视插优盘玩游戏

    下一篇：钉钉直播课需要注意的事项，钉钉开直播课