JAVA--(2)基本程序设计结构:大数值,数组

大数值

处理包含任意长度数字序列的数值
java.math.BigInteger 实现了任意精度的整数运算
java.math.BigDecimal 实现了任意精度的浮点数运算
不能使用算术运算符(eg.+,*)处理大数值，而需要使用大数值的add和multiply方法

BigInteger c = a.add(b); // c = a+b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); // d = c * (b + 2)

数组

数组是一种数据结构，用来存储同一类型值的集合
一旦创建了数组，就不能改变它的大小(进过可以改变每个数组元素)
数组列表(array list): 另一种数据结构，在运行过程中扩展数组的大小

声明数组

int[] a = new int[100]  //创建一个存储100个整数的数组
int[] a = new int[n] 	//创建一个长度为n的数组

数组初始化

创建一个数字数组时，所有元素都初始化为0
创建一个boolean数组时，所有元素都被初始化为false
创建一个对象数组时，所有元素则初始化为一个特殊值null,这表示这些元素还未存放任何对象

int[] smallPrimes = {2,3,5,7,11,13};

匿名数组
new int[] {17,19,23,29,31,37}
匿名数组的用法可以在不创建新变量的情况下重新初始化一个数组

smallPrimes = new int[] {17,19,23,29,31,37};

数组元素的个数

array.length

System.out.println(names.length);

遍历数组： for each循环

可以依次处理数组中的每个元素(其他类型的元素集合亦可)，而不必为指定的下标值分心
for(variable : collection) statement

variable 定义一个变量用于暂存集合中的每个元素，并执行响应语句
collection 这一集合表达式必须使一个数组或者是一个实现了Iterable接口的类对象(例如ArrayList)

查看 数组 所有值 Arrays.toString()

返回的是一个包含数组元素的字符串，这些元素被放置在括号内，并用逗号分隔

import java.util.Arrays;
System.out.println(Arrays.toString(smallPrimes));

数组拷贝

法1： 允许将一个数组考费给另一个数组变量。这两个变量引用同一个数组

int[] luckyNumbers = smallPrimes;
luckyNumbers[5]=100;
System.out.println(Arrays.toString(luckyNumbers));

法2：使用Arrays.copyOf()
第一个参数是要拷贝的数组，第二个参数是新数组的长度(通常用来增加数组的长度)

int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length);
System.out.println(Arrays.toString(copiedLuckyNumbers));

如果数组元素是数值型，那么多余的元素将被赋值为0
如果数组元素是布尔型，那么多余的元素将被赋值为false
如果长度小于原始数组的长度，则只拷贝最前面的数据元素

数组排序：Arrays.sort()

int[] result = {3,2,9,7,6,-1};
Arrays.sort(result);
System.out.println(Arrays.toString(result));  
for(int e:result)
	System.out.println(e);

得到一个 0 ~ (n-1) 之间的随机数

Math.random() 将返回一个0到1之间(包括0，不包括1)的随机数
用 n 乘以这个浮点数，就可以得到从 0 到 n-1 之间的一个随机数

Integer n=10;
System.out.println(Math.random());
//随机0到9之间的一个随机数
int r = (int) (Math.random()* n);
System.out.println(r);

java.util.Arrays 中的方法

static String toString(type[] a)
返回包含a中数据元素的字符串，这些数据元素被放在中括号内，并用逗号分隔

参数	说明
参数 a	类型为int,long,short,char,byte,boolean,float,double数组

static type copyOf(type[] a, int length)
static type copyOf(type[] a,int start int end)

参数	说明
a	类型为int,long,short,char,byte,boolean,float,double数组
start	起始下标(包含这个值)
end	终止下标(不包含这个值) 这个值可能大于a.length.这种情况下，结果为0或false
length	拷贝的数据元素长度. 如果length值大于a.length, 结果为0或false;否则只有前面length个元素的拷贝纸

static void sort(type[] a)
采用优化的快速排序算法对数组进行排序

参数	说明
a	类型为int,long,short,char,byte,boolean,float,double数组

static int binarySearch(type[] a, type v)
static int binarySearch(type[] a, int start, int end, type v)
采用二分搜索算法查找值v. 如果成功，则返回相应的下标值；否则，返回一个负数值 r.
-r -1 是为了保持a有序v应插入的位置

参数	说明
a	类型为int,long,short,char,byte,boolean,float,double数组
start	起始下标(包含这个值)
end	终止下标(不包含这个值)
v	同 a 的数据元素类型相同的值

static void fill(type[] a, type v)
将数组的所有元素值设置为 v

参数	说明
a	类型为int,long,short,char,byte,boolean,float,double数组
v	同 a 的数据元素类型相同的一个值

static boolean equals(type[] a, type[] b)
如果两个数组大小相等，并且下标相同的元素都对应相等，返回true

参数	说明
参数 a,b	类型为int,long,short,char,byte,boolean,float,double数组

多维数组

JAVA实际上并没有多维数组，只有一维数组。多维数组被解释为“数组的数组”

声明二维数组(矩阵)

double[][] balances = new double[10][6]  //10行6列

int[][] magicSquare = 
			{
					{16,3,2,13},
					{5,10,11,8},
					{9,6,7,12},
					{4,15,14,1}
			};

查看 二维数组 元素 Arrays.deepToString()

System.out.println(Arrays.deepToString(magicSquare));

遍历二维数组 元素 for each循环

按扫描线的顺序进行打印

for(int[] row : magicSquare)
	for(int value : row)
		System.out.println(value);

互换二维数组中的两行

System.out.println("==========互换二维数组三行和四行========");
Integer i=2;  //默认0索引，2表示第三行
int[] temp = magicSquare[i];
magicSquare[i] = magicSquare[i+1];
magicSquare[i+1] = temp;
System.out.println(Arrays.deepToString(magicSquare));

不规则数组

实现

public class LotteryArray
{
   public static void main(String[] args)
   {
      final int NMAX = 10;
      // allocate triangular array
      int[][] odds = new int[NMAX + 1][];
      for (int n = 0; n <= NMAX; n++)
         odds[n] = new int[n + 1];

      // fill triangular array
      for (int n = 0; n < odds.length; n++)
         for (int k = 0; k < odds[n].length; k++)
         {
            /*
             * compute binomial coefficient n*(n-1)*(n-2)*...*(n-k+1)/(1*2*3*...*k)
             */
            int lotteryOdds = 1;
            for (int i = 1; i <= k; i++)
               lotteryOdds = lotteryOdds * (n - i + 1) / i;

            odds[n][k] = lotteryOdds;
         }

      // print triangular array
      for (int[] row : odds)
      {
         for (int odd : row)
            System.out.printf("%4d", odd);
         System.out.println();
      }
   }
}