精华内容
下载资源
问答
  • 大数据运算 当数字,超过long的取值范围,这样的...构造方法: new BigInteger(String yal)参数是字符串类型,可以写任意的长度,但是必须是数字 创建BigInteger对象,封装超级大数 方法:+ - * / 返回值 方法名 方法解

    大数据运算

    当数字,超过long的取值范围,这样的数据是真实存在的,Java认为,超过long的取值范围不称为数字,称为超级大数对象,对象是由类产生:
    java.math.BigInteger超级大整数
    java.math.BigDecimal超级大的浮点数(精确的浮点运算)

    BigInteger

    构造方法: new BigInteger(String yal)参数是字符串类型,可以写任意的长度,但是必须是数字
    创建BigInteger对象,封装超级大数
    方法:+ - * /

    返回值方法名方法解释
    BigIntegeradd(BigInteger big)两个大数求和
    BigIntegersubstract(BigInteger big)两个大数减法
    BigIntegermultiply(BigInteger big)两个大数乘法
    BigIntegerdivide(BigInteger big)两个大数除法
    public static void main(String[] args) {
    	//创建BigInteger大数对象,构造方法中,传递字符串
    	BigInteger big1 = new BigInteger("1234567890987654321234567890");
    	BigInteger big2 = new BigInteger( "23245678908765432456786543");
    	//求和big1 + big计算结果,是BigInteger对象
    	BigInteger bigAdd = big1 . add(big2);
    	System . out . print1n(bigAdd) ;
    	//减法big1 - big2
    	BigInteger bigSub = big1 . subtract(big2);
    	System. out. println(bigSub);
    	//乘法big1*big2
    	BigInteger bigMul = big1 . multiply(big2);
    	System. out. print1n(bigMu1) ;
    	//除法big1 / big2
    	BigInteger bigDiv = big1. divide(big2);
    	System . out . println(bigDiv) ;
    }

    BigDecimal

    精确的浮点数运算.计算财务问题
    构造方法:BigDecimal(String val)传递字符串,保证精度,可以任意长度
    四则运算和BigInteger几乎一样的
    区别在除法运算,出现无限小数

    方法返回值方法名解释
    BigDecimaldivide(BigDecimal big)两个大数的除法运算高精度
    BigDecimaldivide(BigDecimal big,int scale,int round)参数含义:自定义的精度计算,(取舍)
    static intROUND_DOWN舍入模式,直接舍去
    static intROUND_UP舍入模式,向上+1
    static intROUND_HALF_UP舍入模式,四舍五入
    public static void main(String[] args) {
    	BigDecimal big1 = new BigDecimal("5.55");
    	BigDecimal big2 = new BigDecimal("1 .0005");
    	BigDecimal bigMul = big1 . multiply(big2);
    	System. out . print1n(bigMul);
    	BigDecimal big4 = new BigDecimal("3.55" );
    	BigDecimal big5 = new BigDecimal("1.35");
    	//除法计算big4 / big5
    	BigDecimal bigDiv = big4. divide(big5);
    	System. out . print1n(bigDiv);
    	//2.62962962962963
    	/*
    	*
    	BigDecimal divisor, int scale, int roundingMode)
    	*
    	divisor被除数big5
    	* scale要保留的位数
    	* roundingMode 舍入模式ROUND_ DOWN直接舍去
    	* roundingMode舍入模式ROUND_UP向.上+1
    	* roundingMode舍入模式 ROUND_ _HALF_ _UP 四舍五入向上+1
    	*/
    	BigDecimal bigDiv = big4. divide(big5,2, BigDecimal . ROUND_ DOWN) ;
    	System. out . println(bigDiv);//2.62
    	BigDecimal bigDiv = big4.divide(big5, 4, BigDecimal . ROUND_ UP) ;
    	System . out . println(bigDiv);//2.6297
    	BigDecimal bigDiv = big4. divide ( big5, 3, BigDec imal . ROUND_ HALF_ UP
    );
    	System . out . println(bigDiv);//2.630
    }

    基本数据类型包装类

    基本数据类型,提供的功能基本都是运算为主.实际工作中这些功能是不够的,因此提供了一套包装类,作用将基本数据类型变成对象,对象具有的功能就会更多
    基本类型包装类:主要实现了一个非常关键的功能:基本类型和字符串之间的互相转换"1"
    包装类都在java.lang

    基本数据类型对应的包装类
    byteByte
    shortShort
    intInteger
    longLong
    floatFloat
    doubleDouble
    charCharacter
    booleanBoolean

    int类型的包装类Integer类,其他的包装类的用法基本都一样的

    Integer类的使用

    内部包装了一个int数据类型,变成了对象

    • 字符串String转成基本数据类型int
      。Integer类静态方法:static int parseInt(String s)字符串转成基本类型int,字符串必须是数字格式
    public static void main(String[ ] args) {
    	//传递的参数是100,返回值基本类型int
    	System . out. println( Integer .parseInt("100" ));//100
    }

    。Integer对象转换:static Integer valueOf(String val)字符串必须数字格式
    。Integer对象的方法: int intValue()字符串转成基本类型int
    。Integer转String

    public static void main(String[] args) {
    	//传递的参数是100,返回值基本类型int
    	int i = . Integer . parseInt( "100");
    	System . out . println(i+1);
    	//创建Integer对象
    	Integer integer = new Integer("10");
    	//对象的方法intValue(),构造方法中的字符串,转成基本类型
    	int j = integer . intValue();
    	System. out . print1n(j+1);//11
    	//Integer类的静态方法valueOf创建出Integer的对象
    	Integer integer2 = Integer . value0f("20");
    	int k = integer2. intValue();
    	System . out . print1n(k+1);//2
    }
    //方法一:
    Integer类的静态方法toString()
    Integer a = 2;
    String str = Integer.toString(a) 
    //方法二:
    Integer类的成员方法toString()
    Integer a = 2;
    String str = a.toString(); 
    //方法三:
    String类的静态方法valueOf()
    Integer a = 2;
    String str = String.valueOf(a);
    

    自动装箱和自动拆箱

    自动的装箱和拆箱,无需程序人员参与这个过程但是原理要学习.
    是JDK1.5出现
    自动装箱:基本数据类型.自动变成对象
    自动拆箱:对象,自动变成基本数据类型

    //自动装箱和自动拆箱
    //好处:实现了基本类型和引用类型的直接计算
    public static void main(String[] args) {
    	//自动装箱, 基本类型自动变成对象
    	/* Integer是类名,引用数据类型
    	*引用数据类型变量i指向一个对象
    	* 1是基本类型,自动装箱成为对象I
    	*/
    	Integer i= 1;
    	/*
    	*i变量是引用类型,保存是内存地址
    	*能和1相加吗
    	*引用类型变量i自动拆箱,对象变成基本类型1了
    	*1+1=2,2赋值变量i
    	*i=2计算,进行自动装箱
    	*/
    	i=i+1;
    	System . out . println(i);
    }

    自动装箱和自动拆箱面试

    public static void main(String[] args) {
    	Integer i = new Integer(100);
    	Integer j = new Integer(100);
    	System . out . print1n( i == j); // ==引用类型,比较内存地址false
    	System . out . println(i. equals(j)); // equals方法继承父类重写true
    	Integer ii = 200; // value0f() = new Integer()
    	Integer jj = 200;
    	System. out . println(ii == jj); // ==引用类型,比较内存地址false
    	System . out . println(ii.equals(jj)); // equals方法继承父类重写true
    	Integer iii = 100;
    	Integer jjj =100 ;
    	System. out . println(iii == jjj); //== 引用类型,比较内存地址true
    	System . out. println(iii. equals(jjj)); // true
    	//装箱,范围是byte之间,不new对象
    	//Integer a = Integer. valueof(1); //源码中value0f方法 里面new Integer对象
    }
    展开全文
  • 在实际程序使用中,程序界面上用户输入的数据都是以字符串类型进行存储的,需要把字符串数据,根据需求转换成指定的基本数据类型,如年龄需要转换成int类型,考试成绩需要转换成double类型等。 *b 八种基本类型对应...

    一、基本数据类型对象包装类概述

    *a 基本类型包装类的产生:
           在实际程序使用中,程序界面上用户输入的数据都是以字符串类型进行存储的,需要把字符串数据,根据需求转换成指定的基本数据类型,如年龄需要转换成int类型,考试成绩需要转换成double类型等。
    *b 八种基本类型对应的包装类:
              char    Character
              int     Integer
              byte    Byte
              short   Short
              long    Long
              float   Float
              double  Double
              boolean Boolean
    *c 基本数据类型对象包装类特点:用于在基本数据和字符串之间进行转换。
    

    以Integer类为例

    ​ 以下介绍的Integer方法,在另七种包装类中也有相应的方法。

    1、Integer类parseInt方法

    //字符串"123"转换为int类型的数字123,结果为125
    System.out.println(Integer.parseInt("123")+ 2);
    /*
    * Integer类静态方法parseInt(String s, int radix)
    * radix基数,进制
    * "110",2 含义 前面的数字是二进制的,但是方法parseInt运行结果都是十进制
    *  指定进制的字符串转换为十进制的整数
    */
    public static void function_1(){
        int i = Integer.parseInt("110", 2);
        System.out.println(i);//6
    }

    2、Integer类int转成字符串

      *1: 使用+与字符串拼接
            int i = 3;
            String s = i+"";
            System.out.println(s+1);//"31"
      
      *2: toString(int i) 
              返回一个表示指定整数的 String 对象。
              
      *3: static String toString(int i, int radix) 
              返回用第二个参数指定基数表示的第一个参数的字符串表示形式。 

    3、Integer类构造方法

     *A:Integer类构造方法
        /*
         *  Integer类构造方法
         *   Integer (String s)
         *   将数字格式的字符串,传递到Integer类的构造方法中
         *   创建Integer对象,包装的是一个字符串
         *   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的, intValue()
         */
        public static void function_3(){
            Integer in = new Integer("100");
            int i = in.intValue();
            System.out.println(--i);//99
        }

    4、Integer类其他方法

    /*
    * Integer类的3个静态方法
    * 做进制的转换
    * 十进制转成二进制  toBinarString(int)
    * 十进制转成八进制  toOctalString(int)
    * 十进制转成十六进制 toHexString(int)
    * 三个方法,返回值都是以String形式出现
    */
    
    a:十进制转二,,十六进制
    
    public static void function_1(){
    
        System.out.println(Integer.toBinaryString(99));
        System.out.println(Integer.toOctalString(99));
        System.out.println(Integer.toHexString(999));
    
    }
    
    b:获取int的最大值和最小值
    
    /*
    *   Integer类的静态成员变量
    *   MAX_VALUE
    *   MIN_VALUE
    */
    
    public static void function(){
    
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
    
    }
    

    5、自动装箱和自动拆箱

    ​ 优点: 基本类型和引用类直接运算

    ​ 自动装箱:基本数据类型直接变成对象 自动拆箱:对象中的数据变回基本数据类型

    public static void function(){
            
        //引用类型 , 引用变量一定指向对象
        //自动装箱, 基本数据类型1, 直接变成了对象
        Integer in = 1; // Integer in = new Integer(1)
            
        //in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型
        //in+1  ==> in.inValue()+1 = 2    
        //in = 2    自动装箱
        in = in + 1;
        System.out.println(in);
        
    }

    二、大数据运算

    (一)、BigInteger类概述和构造方法

    ​ java中long型为最大整数类型,对于超过long型的整数已经不能被称为整数了,它们被封装成BigInteger对象。在BigInteger类中,实现四则运算都是方法来实现,并不是采用运算符。

    2.1.1、BigInteger类的常用构造方法:传递字符串,要求数字格式,没有长度限制
    public static void function(){
        BigInteger b = new      BigInteger("8465846668464684562385634168451684568645684564564");
        System.out.println(b);
        BigInteger b1 = new     BigInteger("5861694569514568465846668464684562385634168451684568645684564564");
        System.out.println(b1);
    }

    2.1.2、BigInteger类四则运算

    /*
     * 调用方法计算,计算结果也只能是BigInteger对象
     */
    public static void function_1(){
    
         BigInteger b1 = new BigInteger("5665464516451051581613661405146");
         BigInteger b2 = new BigInteger("965855861461465516451051581613661405146");
        
         //计算 b1+b2对象的和,调用方法 add
         BigInteger bigAdd = b1.add(b2);//965855867126930032902103163227322810292
         System.out.println(bigAdd);
         
         //计算b1-b2对象的差,调用方法subtract
         BigInteger bigSub = b1.subtract(b2);
         System.out.println(bigSub);
         
         //计算b1*b2对象的乘积,调用方法multiply
         BigInteger bigMul = b1.multiply(b2);
         System.out.println(bigMul);
         
         //计算b2/b1对象商,调用方法divied
         BigInteger bigDiv = b2.divide(b1);
         System.out.println(bigDiv);
    }

    (二)、精确的小数计算BigDecimal

    double和float类型在运算中很容易丢失精度,造成数据的不准确性,Java提供了BigDecimal类可以实现浮点数据的高精度运算。

    2.2.1BigDecimal类实现加法减法乘法
    /*
     *BigDecimal实现加、减、乘
     */
    public static void function(){
        BigDecimal b1 =  new BigDecimal("0.09");
        BigDecimal b2 =  new BigDecimal("0.01");
        //计算b1+b2的和,调用方法add
        BigDecimal bigAdd = b1.add(b2);
        System.out.println(bigAdd);
    
        BigDecimal b3 = new BigDecimal("1");
        BigDecimal b4 = new BigDecimal("0.32");
        //计算b3-b2的差,调用方法subtract
        BigDecimal bigSub = b3.subtract(b4);
        System.out.println(bigSub);
    
        BigDecimal b5 = new BigDecimal("1.015");
        BigDecimal b6 = new BigDecimal("100");
        //计算b5*b6的成绩,调用方法 multiply
        BigDecimal bigMul = b5.multiply(b6);
        System.out.println(bigMul);
    }
    2.2.2、BigDecimal类实现除法

    ​ 对于浮点数据的除法运算,和整数不同,可能出现无限不循环小数,因此需要对所需要的位数进行保留和选择舍入模式。

     /*
      * BigDecimal实现除法运算
      * divide(BigDecimal divisor, int scale, int roundingMode) 
      * int scale : 保留几位小数
      * int roundingMode : 保留模式
      * 保留模式:
      *     static int ROUND_UP  向上+1
      *     static int ROUND_DOWN 直接舍去
      *     static int ROUND_HALF_UP  >= 0.5 向上+1(四舍五入)
      *     static int ROUND_HALF_DOWN   > 0.5 向上+1 ,否则直接舍去
      */
     public static void function_1(){
        BigDecimal b1 = new BigDecimal("1.0301");
        BigDecimal b2 = new BigDecimal("100");
        //计算b1/b2的商,调用方法divied
        BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//0.01301
        System.out.println(bigDiv);
     }


    展开全文
  • 概述:Math类型是一个包含执行基本数字运算的方法的类型 特点: (1)该类是一个工具类,类中全是静态方法 (2)该类在java.lang包,使用时不需要导包 静态字段:常量 E 自然对数的底数 PI 圆周率 常用方法: ...

    1 Math类型

    1. 概述:Math类型是一个包含执行基本数字运算的方法的类型
    2. 特点:
      (1)该类是一个工具类,类中全是静态方法
      (2)该类在java.lang包,使用时不需要导包
    3. 静态字段:常量
      E 自然对数的底数
      PI 圆周率
    4. 常用方法:
    方法名作用
    abs(参数)返回参数的绝对值
    ceil(double a)向上取整
    floor(double a)向下取整
    max(float a, float b)求出两个数的最大值
    min(a,b)求出两个数组的最小值
    pow(double a, double b)求出参数a的b次方
    round(float a)求出a的四舍五入的结果
    random()获取一个随机数 0.0—1.0之间

    代码

    package demos2_Math;
    
    public class Demo01 {
        public static void main(String[] args) {
            //返回自然对象的基数
            System.out.println(Math.E);
            //返回圆周率
            System.out.println(Math.PI);
            //绝对值
            System.out.println(Math.abs(-100));
            System.out.println(Math.abs(-10.34));
            //向上取整
            System.out.println(Math.ceil(10.01));
            //向下取整
            System.out.println(Math.floor(10.99));
            //3的4次方
            System.out.println((int)Math.pow(3,4));
            //四舍五入取整
            System.out.println(Math.round(10.99));
            System.out.println(Math.round(10.44));
            //获取一个随机小数:范围0.0————1.0之间
            System.out.println(Math.random());
        }
    }
    

    2 System类型

    1. 概述:System是和系统资源交互使用的一个类型
      类型中定义了几个有用的字段和方法
    2. 常用的字段:
      in :标准输入流,可以从键盘上读取数据
      一般和Scanner类结合使用,可以录入各种数据类型
      out:标准输出流,可以将数据输出到控制台打印
      一般和println方法结合使用,可以打印各种类型的数据
      err:标准错误输出流,默认关联到控制台
      以红色字体打印,一般是系统默认调用
    3. 方法:
      (1)gc()
      强制运行垃圾回收器,强制回收堆内存中的对象垃圾
      (2)currentTimeMillis() :
      返回从1970年0时0分0秒到当前时间的毫秒值

    代码

    package demos3_System;
    
    public class Demo02 {
        public static void main(String[] args) {
            //返回1970年1月1日0时0分0秒-------当前时刻的毫秒值
            //计算机元年到当前时刻的毫秒值
            long time = System.currentTimeMillis();
            System.out.println(time/1000/60/60/24/365);
    
            new Demo();
            //强制运行垃圾回收器回收堆内存中的对象
            System.gc();
        }
    }
    
    class Demo{
        //重写父类中的方法
        //特点:如果该类的对象被回收,会自动调用该方法
        @Override
        protected void finalize() throws Throwable {
            System.out.println("该类的对象被回收了");
        }
    }
    

    3 Scanner类型

    1. 概述:可以录入各种数据类型的数据
    2. 方法:
      nextInt()
      nextDouble()
    3. 特点:
      (1)如果需要录入基本数据类型,录入结束的标志:
      既可以以换行结束,也可以以空格结束
      (2)如果需要录入字符串:
      可以使用nextLine,只能以换行做为一次录入结束
      可以使用next,既可以以空格结束一次录入,也可以以换行结束
      (3)注意事项:
      在使用以空格结束的方法之后,再使用nextLine方法,无法正常录入字符串
    4. 解决方案:
      (1)在使用nextLine方法之前,多使用一次nextLine方法
      (2)分别使用两个Scanner对象录入

    4 BigInteger类型

    1. 概述:BigInteger是java.math包提供的处理大整数类型,实现了大整数的存储
    2. 特点:
      (1)表示的整数可以超过long表示的范围
      (2)java.math包,需要导包
      (3)提供了操作大整数的各种简单方法

    4.1 定义BigInteger对象

    1. 方法:BigInteger(String val)
      概述:将BigInteger的十进制字符串表示形式转换为BigInteger。

    2. 方法:BigInteger(String val, int radix)
      概述:将指定基数中的BigInteger的String表示形式转换为BigInteger。

    代码

    package demos4_big;
    
    import java.math.BigInteger;
    
    public class Demo01 {
        public static void main(String[] args) {
            byte b = 127;
            System.out.println(b);
            short s = 32767;
            System.out.println(s);
            int i = Integer.MAX_VALUE;
            System.out.println(i);
            long g = Long.MAX_VALUE;
            System.out.println(g);
    
            //将一个比较大的整数,进行封装(参数必须是字符串类型表示)
            BigInteger bi1 = new BigInteger("92233720368547758080001");
            System.out.println(bi1);
            //将传递的参数,当做指定的进制转为10进制的对象
            BigInteger bi2 = new BigInteger("100", 2);
            System.out.println(bi2);
        }
    }
    

    4.2 常用方法

    方法名作用
    public BigInteger abs()返回BigInteger对象的绝对值
    public BigInteger negate()取该对象的反数
    public BigInteger add(BigInteger val)加法运算
    public BigInteger subtract(BigInteger val)减法运算
    public BigInteger multiply(BigInteger val)乘法运算
    public BigInteger divide(BigInteger val)除法运算

    代码

    package demos4_big;
    
    import java.math.BigInteger;
    
    public class Demo02 {
        public static void main(String[] args) {
            BigInteger bi1 = new BigInteger("100000000000000000000");
            //绝对值
            System.out.println(bi1.abs());
            //取反数
            System.out.println(bi1.negate());
    
            BigInteger bi2 = new BigInteger("9999");
            //两个过大的整数相加
            BigInteger bi3 = bi1.add(bi2);
            System.out.println(bi3);
            //两个过大的整数相减
            BigInteger bi4 = bi1.subtract(bi2);
            System.out.println(bi4);
            //两个过大的整数相乘
            BigInteger bi5 = bi1.multiply(bi2);
            System.out.println(bi5);
            //两个过大的整数相除
            BigInteger bi6 = bi1.divide(bi2);
            System.out.println(bi6);
        }
    }
    

    5 BigDecimal类型

    1. 概述:可以准确操作浮点数类型数据所属的类型
    2. 特点:
      (1)在Java.math包,使用需要导包
      (2)可以精确表示小数的位数
      (3)提供了操作小数的各种常用方法

    5.1 定义BigDecimal对象

    方法名作用
    1、public BigDecimal(String val)将String类型的数据转换成BigDecimal对象

    5.2 常用方法

    方法名作用
    public BigDecimal add(BigDecimal augend)加法运算
    public BigDecimal subtract(BigDecimal subtrahend)减法运算
    public BigDecimal multiply(BigDecimal multiplicand)乘法运算
    public BigDecimal divide(BigDecimal divisor)除法运算,如果除不尽运行错误
    public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)精确除法运算
    注意事项:
        (1)参数作用: 除数  精确位数   舍入方式
        (2)常用舍入模式: BigDecimal.ROUND_UP  向上取整
                            	BigDecimal.ROUND_FLOOR 向下取整法     
    							BigDecimal.ROUND_HALF_UP 四舍五入
    

    代码

    package demos4_big;
    
    import java.math.BigDecimal;
    
    public class Demo03 {
        public static void main(String[] args) {
            float f = 12.123456789F;
            System.out.println(f);
            double d = 12.123456789123456789;
            System.out.println(d);
            //创建一个可以保留精确度的BigDecimal对象
            BigDecimal bd1 = new BigDecimal("12.1234567891234567890010001002");
            System.out.println(bd1);
            //小数相加
            BigDecimal bd2 = new BigDecimal("1.0");
            BigDecimal bd3 = bd1.add(bd2);
            System.out.println(bd3);
            //相减
            BigDecimal bd4 = bd1.subtract(bd2);
            System.out.println(bd4);
            //相乘
            BigDecimal bd5 = bd1.multiply(bd2);
            System.out.println(bd5);
            //相除:两个数相除,能除尽,使用该方法
            BigDecimal bd6 = bd1.divide(bd2);
            System.out.println(bd6);
            //如果两个数除不尽,使用该方法指定保留多少位,以及如何保留
            BigDecimal bd7 = new BigDecimal("3.0");
            System.out.println(bd2.divide(bd7,3,BigDecimal.ROUND_HALF_UP));
        }
    }
    
    展开全文
  • BigInteger 是java.math包中的一个类,今天通宵网吧无聊,就顺便看去看了以下,学习了以下基本用法,担心以后忘记可以回来看看。 基本方法: import java.util.*; import java.math.*; public class main{ public ...

    BigInteger

    BigInteger 是java.math包中的一个类,今天通宵网吧无聊,就顺便看去看了以下,学习了以下基本用法,担心以后忘记可以回来看看。

    基本方法:

    import java.util.*;
    import java.math.*;
    
    public class main{
    	public static void main(String[] args){
    		Scanner in = new Scanner(System.in);
    		String big_a = in.nextLine();
    		String big_b = in.nextLine();
    		
    		BigInteger test_a = new BigInteger(big_a);
    		BigInteger test_b = new BigInteger(big_b);
    		
    		System.out.println("加法操作"+test_a.add(test_b));
    		System.out.println("加法操作"+test_a.add(new BigInteger("100")));
    		//BigInteger的操作都是针对BigInteger类操作的,所以如果是普通的int类型要转换成BigInteger类的,以下都是
    
    		System.out.println("减法操作"+test_a.subtract(test_b));
    		System.out.println("乘法操作"+test_a.multiply(test_b));
    		System.out.println("除法操作"+test_a.divide(test_b));//取商
    		System.out.println("取商操作"+test_a.divideAndRemainder(test_b)[0]);
    		System.out.println("取余操作"+test_a.divideAndRemainder(test_b)[1]);
    		System.out.println("做2次方操作"+test_a.pow(2));
    		System.out.println("取相反数"+test_a.negate());
    		//感觉divide()和divideAndRemainder()其实很相似,divide()是单纯的除法,divideAndRemainder()是一个数组,
    		//类似于带余除法,一个数组来记录商和余数的值
    		//这个数组也是BigInteger的
    		//我举个例子
    		//比如BigInteger[] bigInteger = test_a.divideAndRemainder(test_b);
    	}
    }
    

    然后就没了,感觉一般我暂时会用的就是这些
    这里面有很多的java包的详细讲解

    展开全文
  • 首先我们知道基本类型只能表示一定范围内的数值。 byte (-128-127); long (-9223372036854774808~9223372036854774807) 如果超出范围了该怎么办呢? 比如如何来表示 123123456789123456789。 更正一下...
  • BigInteger 大数据类型

    2020-08-18 09:09:09
    1 方法声明 public String toString(int radix) radix - 该字符串表示形式的基数(进制)... BigInteger bi1 = new BigInteger("16"); BigInteger bi2 = new BigInteger("-16"); // create 2 String objects St
  • 达内课程-基本类型包装类BigInteger、BigDecimal使用
  • 2、基本类型和对象转换 3、自动装箱拆箱 二、System 类 三、Math 类 四、Arrays 类 五、BigInteger 类 六、BigDecimal 类 一、基本类型包装类 在实际开发中,往往需要将数据转换成字符串类型进行存储,会...
  • BigInteger

    千次阅读 2019-05-20 15:47:57
    在Java中有两个类BigInteger和BigDecimal分别表示大整数类和大浮点数类,可以让超过Integer范围内的数据进行运算,至于两个类的对象能表示最大范围不清楚,理论上能够表示... 将参数转换为制定的类型 比如 int a=3;...
  • BigInteger(Sring str,int radix) //把radix进制的字符串str转化BigInteger add() //加 subtract() //减 multiply() //乘 divide() //除 mod() //取模 remainder() //取余 pow() //平方 abs() //绝对值 negate() ...
  • Java BigInteger学习小结

    2020-04-28 09:22:23
    BigInteger用于表示任意大小的整数。 BigInteger是不变类,并且继承自Number。...将BigInteger转换成基本类型时可使用longValueExact()等方法保证结果准确。 更多具体内容请扫描关注公众号 ...
  • 数据类型BigInteger

    2020-08-20 16:04:43
    8种基本数据类型BigInteger:表示任意大小的整数。 String = "1233343434344343433434344343434334"; //创建大整数对象 BigInteger bi = new BigInteger(str); //一些方法,直接查看API文档更清晰 bi.add(new ...
  • 基本类型包装类 System Math Arrays BigInteger BigDecimal 基本类型包装类 大家回想下,在第二天我们学习Java中的基本数据类型时,说Java中有8种基本的数据类型,可是这些数据是基本数据,想对其进行复杂操作,变...
  • 一、基本类型包装类 在实际程序使用中,程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中,我们需要把字符串数据,根据需求转换成指定的基本数据类型,如年龄需要转换成int类型,考试成绩需要...
  • java.Math.BigInteger转 int类型

    千次阅读 2018-12-03 10:39:42
    使用spring data jpa 查询数据库统计查询数据的总条数返回一个BigInteger类型,无法强转为int类型,此时需要进行如下转换。 import java.math.BigInteger; public class Test {  public static void main(String...
  • BigInteger类型的数字范围比较Integer类型的数字范围要大的多,BigInteger支持任意精度的整数,也就是说,在运算中BigInteger类型可以准确的表示任何大小的整数值而不会丢失信息。在BigInteger类型中封装了多种操作...
  • BigInteger

    2021-04-04 16:49:35
    BigInteger不是基本数据类型之一,是Java里的一个类,它有点像像String,然而它的初始化方式却没有String那么方便可以直接赋值,而是跟其他自定义的类一样,要调用它的构造器进行初始化。这个类的取值范围原则上是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,207
精华内容 3,682
关键字:

biginteger转换成基本类型