「java向量积」向量数量积的

今天给各位分享java向量积的知识，其中也会对向量数量积的进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、java 空间向量的点乘
• 2、java类方法？
• 3、在stackoverflow里一个关于Java和一个运算的问题

java 空间向量的点乘

如果是main函数直接调用的话，要加上static

public static double diancheng(MyVector x,MyVector y)

{

return x.a*y.a+x.b*y.b+x.c*y.c;

}

这样就可以调用了

java类方法？

emm...问题...不少。

1、这个构造函数问题就很大：

你传递一个r数组进来，然后你又让this.v1=v1，this.v2=v2，那么这个r的意义到底是什么？你构造出来的这个向量的v1和v2也还是根本没有任何值。

2、这。。这块问题太多了，我都不知道该怎么说，就全都不应该这么玩，下面加法也是一样的我就不圈出来了。

首先，非常不建议用null来声明任何变量，你声明r[]数组为null，下面又在循环里使用r[i]，r都不是一个东西（因为它是null，还真不是个东西 手动滑稽），r[i]必然导致万恶的空指针异常NullPointerException。然后前面第一点说了，你的v1和v2根本就没有值，其实他们也是null，所以v1.length也将产生空指针异常，你的for循环根本没法进行。好，就算假设你的v1和v2都声明为new double[0]了，他们不再是null了，那么你的这个方法最终有可能返回null，又来了又来了，不要随便使用null，一不小心可能导致你main方法中调用这个方法后再次造成空指针异常。所以你非要这样写的话也建议写成return new double[0];这样即使它是一个空的数组但最起码它已经是个对象了，不再是null了。

3、main方法中null又双叒来了：

null数组不能放任何东西进去，不然将导致空指针异常。

所以现在怎么办？我估计你也发现了，因为你不知道这个数组究竟有多少个数字所以无法准确地定义这个r的长度。

本来我认为最优的做法是利用java的几种数据结构来保存输入项就好了，但是我怕你还没学到，其中这几个数据结构都不需要指定长度就能保存数据，他们能保存的最大数据量为int的最大值：java.util.List（java的集合，特别好用）、java.util.Vector（没错，java本来就有向量这种数据结构，比你这个MyVector功能要多一些）、java.util.Stack（栈其实是继承了向量，是一种特殊的向量）、java.util.Queue（java的队列），常用的就这些。

另外一种方法就是指定r[]数组有一个较大的length，也就是一开始就声明的足够大，比如直接double[] r = new double[999]但是这种是非常不好的办法，一个是如果你最终只存储两三个数字，那么数组空间就浪费太多了，另外是如果超过了999个数字，又会导致数组溢出。

所有我下面采用了第三种直截了当的方法帮你改进为，一开始你要输入向量的长度，你要说明向量到底有多长，这样不就能准确地定义r[]数组了吗？look：

这样就稳得一批了。

4、再看你main方法的最后：

你这种设计方法根本没有体现出两个向量之间的运算关系啊，根本就是只有一个向量在这里。因此，你的运算函数应该修改为传入一个新的向量，也就是这样：

这样的话，main函数里就可以这样了：

看到没，是不是一眼就能看出是向量1和向量2相加、点积？

5、审题！审题！你的toString()方法呐？结果保留两位小数呐？see：

另外题目里还说要定义一个int n的成员变量表示维度。我没太明白这个维度是啥？这不就是一维向量吗？维度不就是1吗？

综上所述，代码被我整体修改为：

public class MyVector {

private double[] array;

private int n = 1;

public MyVector(double[] array) {

this.array = array;

}

public double[] getArray() {

return this.array;

}

public double[] MyVectorDott(MyVector myVector2) {

double[] array2 = myVector2.getArray();

double[] result = new double[this.array.length];

for (int i = 0; i this.array.length; i++) {

result[i] = this.array[i] * array2[i];

}

return result;

}

public double[] MyVectorAdd(MyVector myVector2) {

double[] array2 = myVector2.getArray();

double[] result = new double[this.array.length];

for (int i = 0; i this.array.length; i++) {

result[i] = this.array[i] + array2[i];

}

return result;

}

public String toString() {

String s = "(";

for (int i = 0; i this.array.length; i++) {

if (i this.array.length - 1) {

s += String.format("%.2f", this.array[i]) + ",";

} else {

s += String.format("%.2f", this.array[i]);

}

}

return s + ")";

}

public static void main(String[] args) {

System.out.print("请输入向量长度：");

Scanner input = new Scanner(System.in);

int length = input.nextInt();

double[] array1 = new double[length];

double[] array2 = new double[length];

System.out.print("请输入第一组向量值：");

input = new Scanner(System.in);

for (int i = 0; i length; i++) {

array1[i] = input.nextDouble();

}

System.out.print("请输入第二组向量值：");

input = new Scanner(System.in);

for (int i = 0; i length; i++) {

array2[i] = input.nextDouble();

}

input.close();

MyVector myVector1 = new MyVector(array1);

System.out.println("向量1为：");

System.out.println(myVector1.toString());

System.out.println("向量2为：");

MyVector myVector2 = new MyVector(array2);

System.out.println(myVector2.toString());

MyVector myVector3 = new MyVector(myVector1.MyVectorAdd(myVector2));

System.out.println("向量1与向量2求和为：");

System.out.println(myVector3.toString());

System.out.println("向量1与向量2点积为：");

MyVector myVector4 = new MyVector(myVector1.MyVectorDott(myVector2));

System.out.println(myVector4.toString());

}

}

运行结果：

代码老是会挤在一起，你自己整理一下

在stackoverflow里一个关于Java和一个运算的问题

看上去挺好玩的，我仔细研究了下，望采纳

基本思想: 向量AC + 向量AB缩放到圆周上 = 向量半径

如图，A(pointA.x, pointA.y), B(pointB.x, pointB.y)已知，圆C已知圆心(center.x, center.y),半径radius

double baX = pointB.x - pointA.x;

double baY = pointB.y - pointA.y;

向量AB的坐标表示

double caX = center.x - pointA.x;

double caY = center.y - pointA.y;

向量AC的坐标表示

double a = baX * baX + baY * baY;

向量AB的模的平方，|AB|*|AB|

double bBy2 = baX * caX + baY * caY;

表示向量AB与向量AC的数量积，几何意义为|AB|*|AC|*cosA=|AB|*|AF|

double c = caX * caX + caY * caY - radius * radius;

表示|AC|*|AC|-r*r

我们需要知道向量AB缩放到圆周上的缩放比例ScalingFactor，

即(|AF|+-|DF|)/|AB|

而|AF|/|AB|=bBy2/(|AB|*|AB|)= bBy2 / a

即pBy2=|AF|/|AB|，表示AF的缩放比例

接下来求|DF|/|AB|

|DF|*|DF|=r*r-|CF|*|CF|=r*r-(|AC|*|AC|-|AF|*|AF|)

两边同除以|AB|*|AB|得到

(|DF|/|AB|)^2=(r*r-|AC|*|AC|)/(|AB|*|AB|)+ pBy2 * pBy2

= -c / a +  pBy2 * pBy2

即

double disc = pBy2 * pBy2 - q;

当disc0时无交点，返回空的List

当disc=0时有一个交点

当disc0时有两个交点

我们这时可以得到ScalingFactor=pBy2+-sqrt(disc)

交点为(pointA.x + baX * ScalingFactor, pointA.y + baY * ScalingFactor)

也就是程序中的结果(因为ScalingFactor与程序中差一个负号)

java向量积的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于向量数量积的、java向量积的信息别忘了在本站进行查找喔。