Java核心技术——基本程序设计语法6

基本程序设计语法

大数值

1. BigInteger 类：实现任意精度的整数运算
2. BigDecimal 类：实现任意精度的浮点数运算
3. 使用静态的 valueOf 方法可以将普通的数值转换为大数值

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

数组

1. 数组是一种数据结构， 用来存储同一类型值的集合。通过一个整型下标可以访问数组中的每一个值。例如， 如果 a 是一个整型数组， a[i] 就是数组中下标为 i 的整数。在声明数组变量时， 需要指出数组类型 （ 数据元素类型紧跟 []) 和数组变量的名字。

   int[] a;// 声明数组，但是没有初始化 还可以这样声明：int a[];
   int[] a = new int[100];// 创建一个可以存储100个整数的数组，下标从0开始到n-1，
   

   • 创建一个数字数组时， 所有元素都初始化为 0。boolean 数组的元素会初始化为 fals% 对象数组的元素则初始化为一个特殊值 null, 这表示这些元素（还）未存放任何对象。
   2. 数组长度获取函数：array.length ，一旦创建了数组， 就不能再改变它的大小（尽管可以改变每一个数组元素），如果经常需要在运行过程中扩展数组的大小， 就应该使用另一种数据结构—数组列表（array list）。
2. foreach循环

   for (variable : collection) statement
   

   • 定义一个变量用于暂存集合中的每一个元素， 并执行相应的语句（当然，也可以是语句块)。collection 这一集合表达式必须是一个数组或者是一个实现了 Iterable 接口的类对象（例如ArrayList)。

   for (int element : a)
   	System.out.println(element);// 打印数组a中的每一个元素，一个元素占一行
   for (int i=0; i<a.length; i++)
   	System.out.println(a[i]);// 作用和上边相同，打印数组a中的每一个元素，一个元素占一行
   

   • 这个循环应该读作“ 循环 a 中的每一个元素”（for each element in a )。Java 语言的设计者
     认为应该使用诸如 foreach、 in 这样的关键字，但这种循环语句并不是最初就包含在 Java 语言中的，而是后来添加进去的， 并且没有人打算废除已经包含同名（例如 System.in ) 方法或变量的旧代码。
   • foreach 循环语句的循环变量将会遍历数组中的每个元素， 而不需要使用下标值。
3. 数组初始化以及匿名对象

   int[] samllPrimes = {2,3,5,7,11,13};// 数组初始化
   new int[] {17,19,23,29,31,37};// 初始化匿名数组
   samllPrimes = new int[]{17,19,23,29,31,37};// 不创建新变量的情况下初始化数组，数组大小就是初始值的个数
   int[] anonymous= {2,3,5,7,11,13};
   samllPrimes = anonymous;//和上边相同
   

   • 数组长度为 0 与 null 不同
4. 数组拷贝
   
   • 在Java中允许将一个数组变量拷贝给另一个数组变量，两个变量将引用同一个数组：

   int[] luckyNumbers = samllPrimes;
   luckyNumbers[5] = 12;// now samllPrimes[5] is also 12
   

   • 希望将一个数组的所有制拷贝到另一个数组中，使用 Arrays 类的 copyOf 方法

   int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length);// 第一个参数为待拷贝数组，第二个参数为新数组长度
   int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, 2*luckyNumbers.length);// 通常将增加新数组大小
   

   • 如果数组元素是数值型，那么多余的元素将被赋值为 0 ; 如果数组元素是布尔型，则将赋值为 false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。
   • Java 数组与 C++ 数组在堆栈上有很大不同， 但基本上与分配在堆（heap) 上的数组指针一样。int[] a = new int[100]; // Java不同于 int a[100];// C++ 而等同于 int* a = new int[100];// C++。Java 中的 [ ] 运算符被预定义为检查数组边界，而且没有指针运算， 即不能通过 a 加 1 得到数组的下一个元素。
5. 命令行参数

   • 每个Java应用程序都带有一个String arg[] 参数的main方法。这个参数表明main方法将接收一个字符串数组，也就是命令行参数。

     public class Message {
         public static void main(String[] args){
             if (args.length == 0 || args[0].equals("-h"))
                 System.out.print("Hello,");
             else if (args[0].equals("-g"))
                 System.out.print("Goodbye,");
             for (int i=1;i<args.length;i++)
                 System.out.print(" " + args[i]);
             System.out.print("!");
         }
     }
     // 显示 Goodbye, cruel world
     

       java Message -g cruel world
     

   • arg数组将包含下列内容：

     • arg[0]:"-g"
     • arg[1]:“cruel”
     • arg[2]:“world”

   • 在 Java 应用程序的 main 方法中， 程序名并没有存储在 args 数组中

6. 数组排序 ：对数值型数组进行排序，可以使用Arrays 类中的 sort 方法

   int[] a = new int[1000];
   ...
   Array.sort(a);
   

• 实例1：

  import java.util.*;
  
  
  public class LotteryDrawing {
      public static void main(String[] args){
          Scanner in = new Scanner(System.in);
  
          System.out.print("How many numbers do you need to draw? ");
          int k = in.nextInt();
  
          System.out.print("What is the highest number you can draw? ");
          int n = in.nextInt();
  
          // fill an array with numbers 1 2 3 ... n
          int[] numbers = new int[n];
          for (int i=0;i<numbers.length;i++)
          {
              numbers[i]=i+1;
          }
  
          //draw k numbers and put them into a second array
          int[] result = new int[k];
          for(int i=0;i<result.length;i++)
          {
              // make a random index between 0 and n-1
              int r = (int)(Math.random()*n);
  
              // pick the element at the random location
              result[i] = numbers[r];
  
              // move the last element into the random location
              numbers[r] = numbers[n-1];
              n--;
          }
          // print the sorted array
          Arrays.sort(result);
          System.out.println("Bet the following combination. It'll make you rich!");
          for (int r:result)
              System.out.println(r);
      }
  }
  /**
   * How many numbers do you need to draw? 6
   * What is the highest number you can draw? 50
   * Bet the following combination. It'll make you rich!
   * 19
   * 20
   * 25
   * 28
   * 33
   * 41
   */
  

7. 多维数组
   • 多维数组将使用多个下标访问数组元素， 它适用于表示表格或更加复杂的排列形式。

   double[][] balances;// 声明
   balances = new double[NYEARS][NYEARS];// 初始化
   int[][] magicSquare = 
   	{
   		{16, 3, 2, 13},
   		{5, 10, 11, 18},
   		{9, 6, 7, 12},
   		{4, 15, 14, 1},
   	};// 创建多维数组并进行初始化
   balances[i][j];// 访问多维数组的元素
   

   • 输出二维数组：for each 循环语句不能自动处理二维数组的每一个元素。它是按照行， 也就是一维数组处理的。

for(double[] row: a)
	for(double value: row)
		do something with value// 访问二维教组 a 的所有元素， 需要使用两个嵌套的循环
		
System.out.println(Arrays.deepToString(a));// 直接调用Arrays类的方法即可。

8. 不规则数组
   • Java 实际上没有多维数组，只有一维数组。多维数组被解释为“ 数组的数组”。
     
   • 表达式 balancesfi]引用第 i 个子数组， 也就是二维表的第 i 行。它本身也是一个数组，balances[i][j] 引用这个数组的第 j 项。
   • 构造一个“ 不规则” 数组， 即数组的每一行有不同的长度。

   public class LotteryArray {
       public static void main(String[] srgs){
           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();
           }
       }
   }
   /*
   *    1
      1   1
      1   2   1
      1   3   3   1
      1   4   6   4   1
      1   5  10  10   5   1
      1   6  15  20  15   6   1
      1   7  21  35  35  21   7   1
      1   8  28  56  70  56  28   8   1
      1   9  36  84 126 126  84  36   9   1
      1  10  45 120 210 252 210 120  45  10   1
   
   * */