bigdecimal可以用等号比较大小么

BigDecimal a = new BigDecimal("1.00");x0dx0aBigDecmial b = new BigDecimal(1);x0dx0a想比较一下a和b的大小，一般都会用equalsx0dx0aSystem.out.println(a.equals(b));x0dx0a但是输出结果是：falsex0dx0a原因是：BigDecimal比较时，不仅比较值，而且还比较精度？x0dx0aif(a.compareTo(b)==0) 结果是truex0dx0a比较大小可以用 a.compareTo(b) x0dx0a返回值 -1 小于 0 等于 1 大于

在bigdecimal的对比大小中，建议使用compare而不是使用equals。按理说0和0.00应该是相等，但在上图中发现返回结果却是false。equals源码： 可以发现当小数位scale不等时，自动返回了false。 compare源码： signnum源码： compare源码可见，先对小数位scale进行了对比，如果不等，又将两个数进行了转换，转成int，对比int的大小。

BigDecimal a = new BigDecimal (101.00); BigDecimal b = new BigDecimal (111.00); if(a.compareTo(b) == -1){ System.out.println("a小于b"); } if(a.compareTo(b) == 0){ System.out.println("a等于b"); } if(a.compareTo(b) == 1){ System.out.println("a大于b"); } if(a.compareTo(b) > -1){ System.out.println("a大于等于b"); } if(a.compareTo(b) < 1){ System.out.println("a小于等于b"); }

一、构造方法 BigDecimal的构造方法有很多种，大家最常用的如下方式: BigDecimal bd1=new BigDecimal(10); BigDecimal bd2=new BigDecimal("10"); 二、四则预算 加法:bigDecimal1.add(bigDecimal2); 减法:bigDecimal1.subtract(bigDecimal2); 乘法:bigDecimal1.multiply(bigDecimal2); 除法:bigDecimal1.divide(bigDecimal2); 三、对小数的处理 (1).DecimalFormat类 例： DecimalFormat df =new DecimalFormat("#.00"); df.format(3.1415926); 结果输出3.14 (2)setScale方法 double f = 111231.5585; BigDecimal b = new BigDecimal(f); double f1 = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue(); //保留2位小数 四、比较大小 BigDecimal比较大小不能使用equals因为不仅比较值还比较精度 这里使用BigDecimal自带方法compareTo 例: BigDecimal a = new BigDecimal("1.00"); BigDecmial b = new BigDecimal(1); a.compareTo(b)==0结果是true 这里返回值含义: -1小于 0等于 1大于

int 、float等基本数据类型用==string 用eques

几乎所有数字类型的，同类型的，可以直接比较如 a , b 两个比较类似如下：if(a>b){}不同类型，一般按照大的那个类型来比较海枫科技

import java.math.BigDecimal;public class Case5 {public static void main(String[] args) {test1();}public static void test1() {BigDecimal base39 = new BigDecimal(39);BigDecimal base40 = new BigDecimal(40);base39 = base39.pow(40);base40 = base40.pow(39);System.out.println("39的40次方="+base39);System.out.println("40的39次方="+base40);String result = base39.compareTo(base40)>0? "39的40次方 比 40的39次方大" : "40的39次方 比 39的40次方大";System.out.println(result);}}39的40次方=439121075102077650905178851056667333727749210354866416338812640140的39次方=30223145490365729367654400000000000000000000000000000000000000039的40次方 比 40的39次方大任何非零数的0次方都等于1。原因如下通常代表3次方5的3次方是125，即5×5×5=1255的2次方是25，即5×5=255的1次方是5，即5×1=5由此可见，n≧0时，将5的（n+1）次方变为5的n次方需除以一个5，所以可定义5的0次方为：5 ÷ 5 = 1

js的Number精度明显达不到你的要求，不能实现 。 你应该考虑一下为什么需要转换成数字？实在没有其他途径的时候可以采用bigdecimal的工具库

理论上可以这样实现，不过我还没有测试private static int compare(Number v1 , Number v2){BigDecimal v11 = new BigDecimal(v1.toString());BigDecimal v22 = new BigDecimal(v2.toString());return v11.compareTo(v22);}

double a = 0.001; double b = 0.0011; BigDecimal data1 = new BigDecimal(a); BigDecimal data2 = new BigDecimal(b); data1.compareTo(data2) 非整型数，运算由于精度问题，可能会有误差，建议使用BigDecimal类型！

1. publicclassIntegerTypeTest01{2. publicstaticvoidmain(

根据规则，重载是根据传入的参数不同而出现的类似于只能判断吧在这里先解决一下重载的问题，你可以试着用数据类型int和double去重载方法就是不同类型的数和不同类型的数去做比较下一步在方法中把三个数字放在数组中然后使用排序算法或者数组本身的那个排序函数，这里有冒泡排序和其他方式然后把最大值返回出去，或者在重载方法最后敲一句打印这X,Y,Z三个值中最大值是：？的话。有帮助别忘记采纳亲！

up 看完上面的应该知道够用了

你会被鄙视的 又到一年答辩论文时 不会你就拿这东西当论文吧！？？？

参考jdk中的BigInteger和BigDecinal类，它们定义了你所需要的大数运算

把0转成BigDecimal不就可以比了吗

int[] a = { 5, 4, 2, 4, 9, 1 }; Arrays.sort(a); // 进行排序 for (int i : a) { System.out.print(i); }

负数？x最小值都只能取到0啊

下面是我刚刚写的1和1比较的代码，自己观察一下就会了import java.math.BigDecimal;public class Main { public static void main(String args[]){ BigDecimal a; a = BigDecimal.ONE; System.out.println(a.compareTo(BigDecimal.valueOf(1))); }}

不管是不是用JAVA，其实方法都一样，利用数组比如说长度为一千的数字，可以这个 int[] number = new int[1000];相加的思路是，首先两个数组的长度必须是一致，位数不同的话，前面补0，内存有点浪费，但是计算起来比较方便。然后让它们从0到最高位，每位进行相加并保存相应的位置上。最后一步是从0开始判断有没有大于10的数字，如果有就向前面进位（前一个加1，当前位减10），这样就可以。如果是相减，其实思路还是一样的，每位先相减，再判断是否有小于0的，如果有则向前面一位借1（前一位减1，当前位加10）如果是相乘，和上面一样，不过要注意的是进位的时候，不止进一位，比如5*6，就要向前进3位了（前一位加3，当前位减30）除就比较麻烦点，要涉及到精确度问题，得看实际需要 输出就更容易了，直接for循环数组 特别要注意的是，如果最高位有进位的时候，这个是比较容易出错的地方 思路在上面，如果实现不了请留言

我晕，你直接在我上次的回答上追问就行拉，这些放在按钮的事件里面，比如说:procedure Tmainform.printButtonClick(Sender: TObject);begini := Printer.Printers.IndexOf("printer name"); // 代入打印机名字if i >= 0 then Printer.PrinterIndex := i; // 设定打印机Printer.Orientation := poLandscape; //设定横向打印Printer.BeginDoc; // 设定打印内容 // Set up a large blue font Canvas.Font.Size := 20; Canvas.Font.Color := clBlue; // Write out the page size Canvas.TextOut(20, 20, "Page width = "+IntToStr(PageWidth)); // Finish printingPrinter.EndDoc;end;

Java 语言支持两种基本的浮点类型： float 和 double ，以及与它们对应的包装类 Float 和 Double 。它们都依据 IEEE 754 标准，该标准为 32 位浮点和 64 位双精度浮点二进制小数定义了二进制标准。 IEEE 754 用科学记数法以底数为 2 的小数来表示浮点数。IEEE 浮点数用 1 位表示数字的符号，用 8 位来表示指数，用 23 位来表示尾数，即小数部分。作为有符号整数的指数可以有正负之分。小数部分用二进制（底数 2）小数来表示，这意味着最高位对应着值 ?(2 -1)，第二位对应着 ?(2 -2)，依此类推。对于双精度浮点数，用 11 位表示指数，52 位表示尾数。IEEE 浮点值的格式如图 1 所示。 图 1. IEEE 754 浮点数的格式 因为用科学记数法可以有多种方式来表示给定数字，所以要规范化浮点数，以便用底数为 2 并且小数点左边为 1 的小数来表示，按照需要调节指数就可以得到所需的数字。所以，例如，数 1.25 可以表示为尾数为 1.01，指数为 0： (-1) 0*1.01 2*2 0 数 10.0 可以表示为尾数为 1.01，指数为 3： (-1) 0*1.01 2*2 3 特殊数字除了编码所允许的值的标准范围（对于 float ，从 1.4e-45 到 3.4028235e+38），还有一些表示无穷大、负无穷大、 -0 和 NaN（它代表“不是一个数字”）的特殊值。这些值的存在是为了在出现错误条件（譬如算术溢出，给负数开平方根，除以 0 等）下，可以用浮点值集合中的数字来表示所产生的结果。 这些特殊的数字有一些不寻常的特征。例如， 0 和 -0 是不同值，但在比较它们是否相等时，被认为是相等的。用一个非零数去除以无穷大的数，结果等于 0 。特殊数字 NaN 是无序的；使用 == 、 < 和 > 运算符将 NaN 与其它浮点值比较时，结果为 false 。如果 f 为 NaN，则即使 (f == f) 也会得到 false 。如果想将浮点值与 NaN 进行比较，则使用 Float.isNaN() 方法。表 1 显示了无穷大和 NaN 的一些属性。 表 1. 特殊浮点值的属性表达式 结果 Math.sqrt(-1.0) -> NaN 0.0 / 0.0 -> NaN 1.0 / 0.0 -> 无穷大 -1.0 / 0.0 -> 负无穷大 NaN + 1.0 -> NaN 无穷大 + 1.0 -> 无穷大 无穷大 + 无穷大 -> 无穷大 NaN > 1.0 -> false NaN == 1.0 -> false NaN < 1.0 -> false NaN == NaN -> false 0.0 == -0.01 -> true 基本浮点类型和包装类浮点有不同的比较行为使事情更糟的是，在基本 float 类型和包装类 Float 之间，用于比较 NaN 和 -0 的规则是不同的。对于 float 值，比较两个 NaN 值是否相等将会得到 false ，而使用 Float.equals() 来比较两个 NaN Float 对象会得到 true 。造成这种现象的原因是，如果不这样的话，就不可能将 NaN Float 对象用作 HashMap 中的键。类似的，虽然 0 和 -0 在表示为浮点值时，被认为是相等的，但使用 Float.compareTo() 来比较作为 Float 对象的 0 和 -0 时，会显示 -0 小于 0 。 浮点中的危险由于无穷大、NaN 和 0 的特殊行为，当应用浮点数时，可能看似无害的转换和优化实际上是不正确的。例如，虽然好象 0.0-f 很明显等于 -f ，但当 f 为 0 时，这是不正确的。还有其它类似的 gotcha，表 2 显示了其中一些 gotcha。 表 2. 无效的浮点假定这个表达式…… 不一定等于…… 当…… 0.0 - f -f f 为 0 f < g ! (f >= g) f 或 g 为 NaN f == f true f 为 NaN f + g - g f g 为无穷大或 NaN 舍入误差浮点运算很少是精确的。虽然一些数字（譬如 0.5 ）可以精确地表示为二进制（底数 2）小数（因为 0.5 等于 2 -1），但其它一些数字（譬如 0.1 ）就不能精确的表示。因此，浮点运算可能导致舍入误差，产生的结果接近 ― 但不等于 ― 您可能希望的结果。例如，下面这个简单的计算将得到 2.600000000000001 ，而不是 2.6 ： double s=0; for (int i=0; i<26; i++) s += 0.1; System.out.println(s);类似的， .1*26 相乘所产生的结果不等于 .1 自身加 26 次所得到的结果。当将浮点数强制转换成整数时，产生的舍入误差甚至更严重，因为强制转换成整数类型会舍弃非整数部分，甚至对于那些“看上去似乎”应该得到整数值的计算，也存在此类问题。例如，下面这些语句： double d = 29.0 * 0.01; System.out.println(d); System.out.println((int) (d * 100));将得到以下输出：0.29 28这可能不是您起初所期望的。浮点数比较指南由于存在 NaN 的不寻常比较行为和在几乎所有浮点计算中都不可避免地会出现舍入误差，解释浮点值的比较运算符的结果比较麻烦。最好完全避免使用浮点数比较。当然，这并不总是可能的，但您应该意识到要限制浮点数比较。如果必须比较浮点数来看它们是否相等，则应该将它们差的绝对值同一些预先选定的小正数进行比较，这样您所做的就是测试它们是否“足够接近”。（如果不知道基本的计算范围，可以使用测试“abs(a/b - 1) < epsilon”，这种方法比简单地比较两者之差要更准确）。甚至测试看一个值是比零大还是比零小也存在危险 ―“以为”会生成比零略大值的计算事实上可能由于积累的舍入误差会生成略微比零小的数字。NaN 的无序性质使得在比较浮点数时更容易发生错误。当比较浮点数时，围绕无穷大和 NaN 问题，一种避免 gotcha 的经验法则是显式地测试值的有效性，而不是试图排除无效值。在清单 1 中，有两个可能的用于特性的 setter 的实现，该特性只能接受非负数值。第一个实现会接受 NaN，第二个不会。第二种形式比较好，因为它显式地检测了您认为有效的值的范围。清单 1. 需要非负浮点值的较好办法和较差办法 // Trying to test by exclusion -- this doesn"t catch NaN or infinity public void setFoo(float foo) { if (foo < 0) throw new IllegalArgumentException(Float.toString(f)); this.foo = foo; } // Testing by inclusion -- this does catch NaN public void setFoo(float foo) { if (foo >= 0 && foo < Float.INFINITY) this.foo = foo; else throw new IllegalArgumentException(Float.toString(f)); }不要用浮点值表示精确值一些非整数值（如几美元和几美分这样的小数）需要很精确。浮点数不是精确值，所以使用它们会导致舍入误差。因此，使用浮点数来试图表示象货币量这样的精确数量不是一个好的想法。使用浮点数来进行美元和美分计算会得到灾难性的后果。浮点数最好用来表示象测量值这类数值，这类值从一开始就不怎么精确。用于较小数的 BigDecimal从 JDK 1.3 起，Java 开发人员就有了另一种数值表示法来表示非整数： BigDecimal 。 BigDecimal 是标准的类，在编译器中不需要特殊支持，它可以表示任意精度的小数，并对它们进行计算。在内部，可以用任意精度任何范围的值和一个换算因子来表示 BigDecimal ，换算因子表示左移小数点多少位，从而得到所期望范围内的值。因此，用 BigDecimal 表示的数的形式为 unscaledValue*10 -scale 。 用于加、减、乘和除的方法给 BigDecimal 值提供了算术运算。由于 BigDecimal 对象是不可变的，这些方法中的每一个都会产生新的 BigDecimal 对象。因此，因为创建对象的开销， BigDecimal 不适合于大量的数学计算，但设计它的目的是用来精确地表示小数。如果您正在寻找一种能精确表示如货币量这样的数值，则 BigDecimal 可以很好地胜任该任务。 所有的 equals 方法都不能真正测试相等如浮点类型一样， BigDecimal 也有一些令人奇怪的行为。尤其在使用 equals() 方法来检测数值之间是否相等时要小心。 equals() 方法认为，两个表示同一个数但换算值不同（例如， 100.00 和 100.000 ）的 BigDecimal 值是不相等的。然而， compareTo() 方法会认为这两个数是相等的，所以在从数值上比较两个 BigDecimal 值时，应该使用 compareTo() 而不是 equals() 。 另外还有一些情形，任意精度的小数运算仍不能表示精确结果。例如， 1 除以 9 会产生无限循环的小数 .111111... 。出于这个原因，在进行除法运算时， BigDecimal 可以让您显式地控制舍入。 movePointLeft() 方法支持 10 的幂次方的精确除法。 使用 BigDecimal 作为互换类型SQL-92 包括 DECIMAL 数据类型，它是用于表示定点小数的精确数字类型，它可以对小数进行基本的算术运算。一些 SQL 语言喜欢称此类型为 NUMERIC 类型，其它一些 SQL 语言则引入了 MONEY 数据类型，MONEY 数据类型被定义为小数点右侧带有两位的小数。 如果希望将数字存储到数据库中的 DECIMAL 字段，或从 DECIMAL 字段检索值，则如何确保精确地转换该数字？您可能不希望使用由 JDBC PreparedStatement 和 ResultSet 类所提供的 setFloat() 和 getFloat() 方法，因为浮点数与小数之间的转换可能会丧失精确性。相反，请使用 PreparedStatement 和 ResultSet 的 setBigDecimal() 及 getBigDecimal() 方法。 对于 BigDecimal ，有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入，另一个以整数和换算因子作为输入，还有一个以小数的 String 表示作为输入。要小心使用 BigDecimal(double) 构造函数，因为如果不了解它，会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。 构造 BigDecimal 数对于 BigDecimal ，有几个可用的构造函数。其中一个构造函数以双精度浮点数作为输入，另一个以整数和换算因子作为输入，还有一个以小数的 String 表示作为输入。要小心使用 BigDecimal(double) 构造函数，因为如果不了解它，会在计算过程中产生舍入误差。请使用基于整数或 String 的构造函数。 如果使用 BigDecimal(double) 构造函数不恰当，在传递给 JDBC setBigDecimal() 方法时，会造成似乎很奇怪的 JDBC 驱动程序中的异常。例如，考虑以下 JDBC 代码，该代码希望将数字 0.01 存储到小数字段： PreparedStatement ps = connection.prepareStatement("INSERT INTO Foo SET name=?, value=?"); ps.setString(1, "penny"); ps.setBigDecimal(2, new BigDecimal(0.01)); ps.executeUpdate();在执行这段似乎无害的代码时会抛出一些令人迷惑不解的异常（这取决于具体的 JDBC 驱动程序），因为 0.01 的双精度近似值会导致大的换算值，这可能会使 JDBC 驱动程序或数据库感到迷惑。JDBC 驱动程序会产生异常，但可能不会说明代码实际上错在哪里，除非意识到二进制浮点数的局限性。相反，使用 BigDecimal("0.01") 或 BigDecimal(1, 2) 构造 BigDecimal 来避免这类问题，因为这两种方法都可以精确地表示小数。

JAVA中一样也的 会进行由低到高自动转换public class TestTranform { public static void main(String[] args) { char b="c"; int a=4; int d= a+b; System.out.println (d); }}

在java中提供了大数字的操作类，即java.math.BinInteger类和java.math.BigDecimal类。这两个类用于高精度计 算，其中BigInteger类是针对大整数的处理类，而BigDecimal类则是针对大小数的处理类。下边我们介绍BigDecimal类： BigDecimal的实现利用到了BigInteger，不同的是BigDecimal加入了小数的概念。一般的float型和Double型数据只可 以用来做科学计算或者是工程计算，由于在商业计算中，要求的数字精度比较高，所以要用到java.math.BigDecimal类，它支持任何精度的定 点数，可以用它来精确计算货币值。Double（双精度浮点型）是计算机使用的一种资料型别。比起单精度浮点数(float)，Double(双精度浮点数)使用 64 位（8字节） 来储存一个浮点数。 它可以表示十进制的15或16位有效数字，负值取值范围为 -1.79769313486231570E+308 到 -4.94065645841246544E-324，正值取值范围为 4.94065645841246544E-324 到 1.79769313486231570E+308

所有的小数都要保留。一般用BigDecimal比较好

double？ 直接 a ==0 判断

Integer不是基本类型，是int的包装类，无法把包装当做基本类型来用。比如，char a = "c"; int b = (Integer)a; 这样也是回报cannot cast错误的。必须是(int)a，用基本类型才能转。这是第一个问题。第二个问题 你的list.get(i).get("goods_amout")得到的应该是BigDecimal类型的，这个类型，不能用基本类型强转的。举个简单的例子，string a = "c"; int b = (int)a; 可以这样吗？ 要转化这个，用intValue()，也就是：list.get(i).get("goods_amout").intValue() 这样得到的就是个int 的值了。

if((x>100)&&(x<=200)){ system.out.println("在a区间");}else if((x>200)&&(x<=300))){ system.out.println("在b区间");}else if((x>300)&&(x<=400))){ system.out.println("在c区间");}else{ system.out.println("不符合区间");}

题目在哪里呢？？？

BigDecimal比大小，需要声明两个BigDecimal类型变量b1和b2，调用equals()方法比较大小。BigDecimal a = new BigDecimal("1.00");BigDecmial b = new BigDecimal(1);想比较一下a和b的大小，一般都会用equals。BigDecimal其他情况简介。使用BigDecimal类构造方法传入double类型时，计算的结果也是不精确的。因为不是所有的浮点数都能够被精确的表示成一个double 类型值，有些浮点数值不能够被精确的表示成 double 类型值，因此它会被表示成与它最接近的 double 类型的值。必须改用传入String的构造方法。这一点在BigDecimal类的构造方法注释中有说明。BigDecimal向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同。

BigDecimal比大小，需要声明两个BigDecimal类型变量b1和b2，调用equals()方法比较大小。BigDecimal a = new BigDecimal("1.00");BigDecmial b = new BigDecimal(1);想比较一下a和b的大小，一般都会用equals。BigDecimal其他情况简介。使用BigDecimal类构造方法传入double类型时，计算的结果也是不精确的。因为不是所有的浮点数都能够被精确的表示成一个double 类型值，有些浮点数值不能够被精确的表示成 double 类型值，因此它会被表示成与它最接近的 double 类型的值。必须改用传入String的构造方法。这一点在BigDecimal类的构造方法注释中有说明。BigDecimal向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同。

当然是使用compareTo：new BigDecimal(1).compareTo(new BigDecimal("1.0"))但是，注意：compareTo 其实也有坑。如果试用：new BigDecimal(1) 与new BigDecimal("1.00")，结果是true. 但是换成 new BigDecimal(1.2).compareTo(new BigDecimal("1.20"))，结果就是false.这时问题又来了。所以保险的办法是把小数位去掉再比较。比如*100。都升到个位数。或者统一使用setScale定好小数位。我之前就不知这个坑，搞了好久。

BigDecimal比大小，需要声明两个BigDecimal类型变量b1和b2，调用equals()方法比较大小。BigDecimal a = new BigDecimal("1.00");BigDecmial b = new BigDecimal(1);想比较一下a和b的大小，一般都会用equals。BigDecimal其他情况简介。使用BigDecimal类构造方法传入double类型时，计算的结果也是不精确的。因为不是所有的浮点数都能够被精确的表示成一个double 类型值，有些浮点数值不能够被精确的表示成 double 类型值，因此它会被表示成与它最接近的 double 类型的值。必须改用传入String的构造方法。这一点在BigDecimal类的构造方法注释中有说明。BigDecimal向“最接近的”数字舍入，如果与两个相邻数字的距离相等，则向相邻的偶数舍入。如果舍弃部分左边的数字为奇数，则舍入行为与 ROUND_HALF_UP 相同。

BigDecimal a = new BigDecimal("1.00");BigDecmial b = new BigDecimal(1);想比较一下a和b的大小，一般都会用equalsSystem.out.println(a.equals(b));但是输出结果是：false原因是：BigDecimal比较时，不仅比较值，而且还比较精度？if(a.compareTo(b)==0) 结果是true比较大小可以用 a.compareTo(b) 返回值 -1 小于 0 等于 1 大于

可以这么比较啊，不会有什么异常，把上下代码贴上来看看

标准做法int r=big_decimal.compareTo(BigDecimal.Zero); //和0，Zero比较if(r==0) //等于if(r==1) //大于if(r==-1) //小于或者if(big_decimal.equals(BigDecimal.Zero)) //是否等于0

标准做法x0dx0aintr=big_decimal.compareTo(BigDecimal.Zero);//和0，Zero比较x0dx0aif(r==0)//等于x0dx0aif(r==1)//大于x0dx0aif(r==-1)//小于x0dx0ax0dx0a或者x0dx0aif(big_decimal.equals(BigDecimal.Zero))//是否等于0

1.大约在30000年以前，人类从亚洲北部前往美国。今天，我门都称这些人为印第安人。印第安人去美洲是因为气候开始改变。北亚变得寒冷。所有的东西都结冰了。他们不得不迁移否则他们就要死亡。第一批印第安人是怎么去美国的呢？他们走路去！之后哥伦布在1942年发现了新大陆。首先，只有一些欧洲人去了。他们坐船去了美国。在之后的300年里，大约32000000欧洲人前往美国。这些人来自法国，意大利和其他的国家。这些欧洲人说许多种不同的语言。他们中的大多数几乎没带钱。他们去美国是为了寻找更好的生活。2.金一家是美国人。他们现在在北京。他们是第一次来中国。所以他们在中国呆6个月。他们想在中国看最美丽的地方。金先生驾驶技术很好。他架车参观了北京的许多工厂。金夫人在美国的一所学校教书。她将带她的女儿祖到中国来看朋友。他们将带走许多照片。他们向他们的朋友们展示（照片）当他们回美国的时候。他们想让美国人更多的了解中国。完了，好累啊，再多给点分好吗？

1.buy英 [bau026a] 美 [bau026a] v.买;购买;够支付;买通;收买;贿赂n.合算的商品;买进(或出售)的东西;购买第三人称单数： buys 现在分词： buying 过去式： bought 过去分词： bought2.see英 [siu02d0] 美 [siu02d0] v.看见;见到;看出;看得见;看;有视力;观看(比赛、电视节目、演出等)n.主教(或大主教)教区;主教(或大主教)权限;牧座第三人称单数： sees 现在分词： seeing 过去式： saw 过去分词： seen3.write英 [rau026at] 美 [rau026at] v.书写;写字;写作;作曲;编写;写信第三人称单数： writes 现在分词： writing 过去式： wrote 过去分词： written4.take英 [teu026ak] 美 [teu026ak] v.携带;拿走;取走;运走;带去;引领;使达到，把…推向，把…带到(另一个层次、层面等)n.(不停机一次连续拍摄的)场景，镜头;收入额;进项;看法;意见第三人称单数： takes 现在分词： taking 过去式： took 过去分词： taken

http://www.pep.com.cn/ge/jszx/pg/xxb/jsys/

buy的过去式、过去分词都是bought，现在分词是buying。例如，He stopped and bought a newspaper.他停下来买了一张报纸。 buy含义及词性 英 [bau026a]美 [bau026a] v.买;购买;够支付;买通;收买;贿赂 n.合算的商品;买进(或出售)的东西;购买 第三人称单数： buys 现在分词： buying 过去式： bought 英[bu0254u02d0t];美[bu0254u02d0t] 过去分词： bought buy的用法及举例 给某人买某物 buy sb sth buy sth for sb 1. 用作动词，表示“买”，可带双宾语；若双宾易位，通常要用介词 for。如： 我叔叔为我买了本英语词典。 正：My uncle bought me an English dictionary. 正：My uncle bought an English dictionary for me. 2. 表示向某人买某物，通常用介词 from。如： He bought this watch from a friend. 他从一位朋友那儿买了这块手表。 3. 表示用多少钱买某物，通常用介词 for。如： I bought the computer for $600. 我花600美元买了这台电脑。 He bought it for very little money. 他买它只花了一点点钱。 【注】有时也用介词 at, 侧重指价格。如： He bought them for [at] 10p each. 他以每个10 便士的价格买下了它们。 4. 是终止性动词，因此在肯定句中不宜与一段时间连用。如： 这房子我已买了十年。 正：I bought this house ten years ago. 正：I have had this house for ten years. 正：It"s ten years since I bought this house.

这么难的问题居然没有分?

分别是 went hurt ride bought took eat

这句话的意思是：美国和美国人的繁荣富裕是欧亚诸国做梦也无法想象的这句话的主干就是America and Americans were prosperous beyond 作为介词，引导的介词短语beyond the dreams of the Europeans and Asians做状语

buy的过去式是bought，原形是buy。buy是一个英语单词，名词、动词，作名词时意思是“购买，买卖；所购的物品；合算的东西”，作及物动词时意思是“购买；获得；贿赂；相信”，作不及物动词时意思是“买，采购”。 扩展资料 过去式是英语语法的一种，表示过去某个时间里发生的动作或状态。一般过去式的动词通常用动词原形的过去式形式来表示，而动词的"过去式是在动词原形的基础上变化的。动词的过去式可分为规则动词和不规则动词。

wew

AmericansGermans...就是后面以an 结尾的基本上都要加拉Chinese不加S的

whose economies the war had destroyed是定语从句嘛 美国和美国人的繁荣超出了经济被战争摧毁了的欧洲人和亚洲人的预想。

什么啊，上面是题目啊，选一个？