Java的大数值和数组

女爷i 2022-08-23 05:44 136阅读 0赞

# 1.Java的大数值 #

当基本类型的整型和浮点型的精度不能满足业务需要的时候，就要用到大数值，即BigInteger和BigDecimal。BigInteger实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点数运算。BigDecimal类型在实际开发中用的比较多，因为涉及一些高精度的数值计算。

使用valueOf方法可以将普通数值转换为大数值。比如：BigInteger bi = BigInteger.valueOf(100);

但是，不能用平时最常见的+、-、\*、/来对大数值进行计算，而是必须用大数值对象的add、subtract、multiply、divide方法进行运算。（以下方法是java.math.BigInteger 1.1）

<table> 
 <tbody> 
  <tr> 
   <td>BigInteger &nbsp;add(BigInteger other)</td> 
  </tr> 
  <tr> 
   <td>BigInteger &nbsp;subtract(BigInteger other)</td> 
  </tr> 
  <tr> 
   <td>BigInteger &nbsp;multiply(BigInteger other)</td> 
  </tr> 
  <tr> 
   <td>BigInteger &nbsp;divide(BigInteger other)</td> 
  </tr> 
  <tr> 
   <td>BigInteger &nbsp;mod(BigInter other)</td> 
  </tr> 
 </tbody> 
</table>

以上方法，返回大整数和大整数 other的和、差、积、商、余数。

<table> 
 <tbody> 
  <tr> 
   <td>int &nbsp;compareTo(BigInteger other)<br> 如果这个大整数和另一个大整数other相等，返回0；<br> 如果这个大整数大于另一个大整数other，返回正数；<br> 如果这个大整数小于另一个大整数other，返回负数；</td> 
  </tr> 
  <tr> 
   <td>static BigInteger &nbsp;valueOf( long x)<br> 返回值等于x的大整数；</td> 
  </tr> 
 </tbody> 
</table>

关于BigDecimal大实数的一些常见方法如下。（以下方法是java.math.BigDecimal 1.1）

<table> 
 <tbody> 
  <tr> 
   <td>BigDecimal &nbsp;add(BigDecimal other)</td> 
  </tr> 
  <tr> 
   <td>BigDecimal &nbsp;subtract(BigDecimal other)</td> 
  </tr> 
  <tr> 
   <td>BigDecimal &nbsp;multiply(BigDecimal other)</td> 
  </tr> 
  <tr> 
   <td>BigDecimal &nbsp;divide(BigDecimal other, RoundingMode mode)<br> 以上方法返回大实数和另一个大实数other的和、差、积。除法计算，必须给出舍入方式。RoundingMode.HALF_UP是最常见的四舍五入方式（0-4舍去，5-9进位）。其他的舍入方式查阅官方API。</td> 
  </tr> 
  <tr> 
   <td>int &nbsp;compareTo(BigDecimal other)<br> 如果这个大实数和另一个大实数other相等，返回0；<br> 如果这个大实数大于另一个大实数other，返回正数；<br> 如果这个大实数小于另一个大实数other，返回负数；</td> 
  </tr> 
  <tr> 
   <td>static BigDecimal &nbsp;valueOf(long x)</td> 
  </tr> 
  <tr> 
   <td>static BigDecimal valueOF(long x, int scale)<br> 以上两种方法返回一个x的大数值，返回一个x的scale次方的大数值。</td> 
  </tr> 
 </tbody> 
</table>

# 2.Java的数组 #

数组是一种数据结构，是用来存储同一类型的集合。可以通过一个整数下标，来访问数组中的每一个值。

声明一个数组变量时，要指明是哪个类型，且其后要跟着一个\[\]符号，接下来是数组变量名。比如：int\[\] a; 那么a就是一个int类型的数组变量。但a并没有初始化，还不是一个真正的数组，初始化一个数组变量要用new，比如：int\[\] a = new int\[10\]; 创建了可以存储10个int整型的数组。需要注意的是数组的下标是0~9，而不是1~10。

在创建一个数组时，所有的数值数组默认初始化值都是0，boolean数组初始化值都是false，对象数组的元素初始化值都是null。

在java的数组初始化中，a = new int\[n\]，n可以是整型常量，也可以是已经初始化过的整型变量。

## 2.1 for each循环（针对数组的特殊的for循环） ##

java的这种功能很强的循环结构，可以用来依次处理数组中的每个元素，而不用为其指定数组下标。语法格式如：for( variable : collection )\{ statement \}

int[] a = new int[10];
    for(int va : a)
    {
       System.out.println(va);
    }
    // 将输出十个连续的0

虽然这个for循环结构功能很强，但在很多场合下仍然要使用传统的for循环结构，比如说不希望遍历数组中的每个元素，或者在循环内部需要用到数组的下标。这里提示，如果要打印一个数组中的所有元素，可以用Arrays类的toString(a)方法，打印之后的结果是这样的：“\[0,0,0,0,0,0,0,0,0,0\]”。

## 2.2数组的初始化和匿名数组 ##

数组的初始化可以是这样的：int\[\] a = new int\[10\]\{1,2,3,4,5\}，也可以是这样的：int\[\] a = \{1,2,3,4\}。那么两者有什么区别呢？前者是定义了一个能存储10个整型的数组，并且前5个元素为1、2、3、4、5，后五个元素都为0。而后者数组，是定一个能存储4个元素的整型数组，并且已经初始化为1、2、3、4。这就是他们的区别。后者在初始化的同时，也固定了数组的大小。

匿名数组，初始化一个匿名数组：new int\[\] \{1,2,3\}。

在Java中也有空数组，数组的长度为空，但和null不同。声明一个空数组，比如：int\[\] a = new int\[0\];

## 2.3数组的拷贝 ##

在java中将一个数组变量拷贝给另一个数组变量，就是两个数组变量引用了同一个数组。

int[] a = new int[]{1,2,3,4,5,6};
    int[] b = new int[10];
    b=a;
    System.out.print(Arrays.toString(b));//输出 [1,2,3,4,5,6]
    a[0]=0;
    System.out.print(Arrays.toString(b));//输出 [0,2,3,4,5,6]

如果是将数组全部拷贝，可以用Arrays类的copyOf方法。比如：int\[\] b = Arrays.copyOf(a, a.length);java的数组与C++不一样。

int[] a = new int[10];//java
    //不同于
    int a[10];//c++
    //但等同于
    int* a = new [10];

## 2.4命令行参数 ##

在java中的main函数中 public static void main(String\[\] args); 其中args是一个字符串数组，用于命令行输入参数。在命令窗口中是这样使用的 java Abc a b 2 。解释一下，java是运行java的一个命令， Abc是类的名称，a、b、2是三个参数。“其实三个参数就被存储到了 args字符串数组中。

## 2.5数组的排序 ##

简单的介绍几个数组排序使用的函数Arrays类的sort(a)快速排序、Arrays类的binarySearch(a)二分法排序，排序的具体算法，可以去百度一下，随后的文章中我也会写上。（以下方法在java.util.Arrays 1.2）

<table> 
 <tbody> 
  <tr> 
   <td>static String toString(type[] a)<br> 返回包含a中元素的字符串，外面是中括号，里面元素用逗号隔开。比如："[1,2,3,4,5]"<br> type 可以是char、byte、short、int、long、float、double、boolean</td> 
  </tr> 
  <tr> 
   <td>static type copyOf(type a, int length)<br> static type copyOf(type a, int start, int end)<br> 返回与a类型相同的数组，长度为length或end-start，数组元素为a的值。<br> type 可以是char、byte、short、int、long、float、double、boolean<br> start &nbsp;起始下标（包含这个值）<br> end &nbsp;终止下标（不包含这个值）</td> 
  </tr> 
  <tr> 
   <td>static void sort(type[] a)<br> 对数组a进行快速排序。</td> 
  </tr> 
  <tr> 
   <td>static int binarySearch(type[] a)<br> static int binarySearch(type[] a, int start, int end, type t)<br> 采用二分搜索法查找t值。如果查找成功则返回t值所在的下标，否则返回一个负数值。注意：使用二分搜索法的前提是数组a是一个有序的数组，就是a已经排好序了。<br> type 可以是char、byte、short、int、long、float、double、boolean<br> start &nbsp;起始下标（包含这个值）<br> end &nbsp;终止下标（不包含这个值）</td> 
  </tr> 
  <tr> 
   <td>static void fill(type[] a, t)<br> 用t填充数组a。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>static boolean equals(type[] a, type[] b)<br> 如果两个数组的大小相等，并且下标相等的元素都对应相等，则返回true，否则返回false。<br> type 可以是char、byte、short、int、long、float、double、boolean</td> 
  </tr> 
 </tbody> 
</table>

## 2.6多维数组 ##

多维数组可以使用多个下标访问数组元素。目前为止，先学二维数组。声明一个二维数组是这样的：int\[\]\[\] a;与一维数组一样，这样初始化二维数组：a = new int\[n\]\[x\]，其中n和x可以是常量也可以是整型变量，但必须初始化。如果知道数组的元素，就不用new，可以这样声明并初始化：

int[][] a={
    {1,2,3},
    {2,2,2},
    {5,6,7}
    };

二维数组初始化过后，就可以通过下标来访问数组元素了。比如：int\[i\]\[j\]，比如：int\[0\]\[0\]=1;

### 2.6.1多维数组中使用for each循环 ###

针对数组的特殊for循环体，在这里也可以使用，比如：

int[][] a={
    {1,2,3},
    {2,2,2},
    {5,6,7}
    };
    
    for(int[] row : a)
    {
      for(int v : row)
      {
        System.out.print(v);
      }
    }

如果要打印二维数组中的所有元素，可以用Arrays类的deepToString(a)方法。打印出来的结果：“\[\[1,2,3\],\[2,2,2\],\[5,6,7\]\]”

## 2.7不规则数组 ##

所谓不规则数组，就是二维数组中每行的元素数量不一样。比如：

int[][] a={
    {1,2,3},
    {2,2,2,2},
    {5,6,7,8,9}
    };

要声明这样一个不规则数组，要先声明有多少行，然后再一行一行的声明。

int[][] a = new int[3][];  // 先声明了一共3行

声明了一共3行，然后再一行一行的声明。a\[0\]\[\]=\{1,2,3\}; a\[1\]\[\]=\{2,2,2,2\}; a\[2\]\[\]=\{5,6,7,8,9\};