[学习笔记]Java数组和方法

数组

概要

1. 和C++不同，Java中的数组是一种引用数据类型，类似C/C++中的数组指针，内存分配在堆区。
2. 数组长度不要求一定是常量，但是一旦创建了数组，就不能再改变它的大小。
3. 可以使用array.length获取数组中元素的个数。
4. Java中，数组可用for each循环：for(变量:数组名)执行语句（Java 5支持）。
   

   for (variable : collection) {
     statement;
   }

   其中collection必须是一个数组或者是一个实现了Iterable接口的类对象。
5. Java中，允许长度为0的数组，和null不同。
6. Java中，支持不规则二维数组，对每行的元素进行单独分配。

初始化

int n = 10;
int[] a1 = new int[10];
int[] a2 = new int[n];  // 可以使用变量申请数组
int[] a3 = {2, 3, 4, 1, 3};  // 不使用new，直接初始化数组
a3 = new int[] {1, 3, 4, 1, 3};  // 将一个匿名数组赋给一个已有变量，该方法不需要创建新变量
int[] a4 = new int[0];  // Java允许长度为0的数组，常用于方法返回值
int[][] a5 = new int[5][10];  // 创建一个5行10列的二维数组
int[][] a6 = {
  {85, 65, 10}
  {54, 69, 66}
}  // 不使用new，直接初始化一个二维数组

示例

public class ArrayDemo {
  public static void main(String[] args) {
    // 创建一个一维数组
    int[] array = {12, 54, 85, 63, 25, 95, 74, 62};
    // 使用for each循环输出该一维数组的值
    for (int i : array) {
      System.out.print(i + "\t");
    }
    System.out.println();
    System.out.println("-------------------");
    // 创建一个二维数组
    int[][] biArray = new int[3][5];
    // 对该二维数组赋值，其值就是其编号
    for (int i = 0; i < 3; i++) {
      for (int j = 0; j < 5; j++) {
        biArray[i][j] = i * 5 + j;
      }
    }
    // 使用for each循环输出该二维数组的值
    for (int[] is : biArray) {
      for (int i : is) {
        System.out.print(i + "\t");
      }
      System.out.println();
    }
    System.out.println("-------------------");
    // 创建一个不规则数组，该数组有n行，第i行有i个元素
    int n = 6;
    int[][] unArray = new int[n][];
    // 对该不规则数组赋值，每个元素的值就是其两个下标之和
    for (int i = 0; i < n; i++) {
      unArray[i] = new int[i + 1];
      for (int j = 0; j <= i; j++)
        unArray[i][j] = i + j;
    }
    // 使用for each循环输出该不规则数组的值
    for (int[] i : unArray) {
      for (int j : i)
        System.out.print(j + "\t");
      System.out.println();
    }
    System.out.println("-------------------");
  }
}

案例

/**
 * 实现十进制转为二进制，四进制，八进制或十六进制数据。
 * 
 * 思路：先通过进制数算出其所占二进制数据的位数offset，依次将源数据每offset位数据通过查表的方式得到对应
 * 要转换进制的字符并存入数组，最终得到要转换进制的数据。
 * 
 * 步骤：
 * 1. 通过右移次数算出1位要转换进制数据对应二进制数据的位数offset，以及offset位二进制数据都为1的掩码mask。
 * 2. 建立查询表格，鉴于最大要转换的进制为十六进制，所以字符最大到F。
 * 3. 使用循环，取低offset位查表获得对应进制的字符存储，并右移offset位，直到源数据为零为止。
 * 4. 输出数组中存储的已转换好的进制数据。
 * 
 * @author Jacob Yin
 *
 */
public class Trans {
  public static void main(String[] args) {
    String result = trans(6000, 8); // 将6000转换为8进制
    System.out.println(result);
  }
  public static String trans(int num, int code) {
    // 根据code计算掩码mask和占用二进制位数offset
    int offset = 0;
    int mask = code - 1;
    while (code != 0) {
      code = code >>> 1;
      offset++;
    }
    offset--;
    // 创建字符表格和存放结果的数组
    char[] chs = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    char[] arr = new char[32];
    int pos = 0;
    // 使用循环，取低offset位查表获得对应进制的字符存储，并右移offset位，直到源数据为零为止。
    while (num != 0) {
      int temp = num & mask;
      arr[pos++] = chs[temp];
      num = num >>> offset;
    }
    // 由于获得的数组中字符为倒序，所以需要将其再次倒序，利用StringBuilder中的倒序方法。
    return new StringBuilder(new String(arr)).reverse().toString();
  }
}

方法

定义

定义在类中的具有特定功能的一段独立小程序，也称之为函数。

格式

修饰符 返回值类型 方法名(参数类型 形式参数1, 参数类型 形式参数2, ……) {

  statement;

  return value;

}

返回值类型：函数运行后结果的数据类型。

参数类型：是形式参数的数据类型。

形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。

实际参数：传递给形式参数的具体数值。

return：用于结束函数。

返回值：该值会返回给调用者。

注意

定义方法可以将功能代码进行封装。

方法的出现提高了代码的复用性。

方法只有被调用才会被执行

对于方法没有具体返回值的情况，返回值类型用关键字void表示，那么该方法中的return语句如果在最后一行可以省略不写。

方法中只能调用方法，不可以在函数内部定义方法。

定义方法时，方法的结果应该返回给调用者，交由调用者处理。

定义方法时，应明确要定义的功能最后的结果是什么，明确在定义该功能的过程中，是否需要未知内容参与运算。

重载

1. 在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
2. 是否重载与返回值类型无关，只看参数列表。所以重载的方法可以更改返回值类型和权限修饰符。
3. 重载的方法可以抛出新的异常，与是否重载无关。
4. 重载可以发生在同一个类中或者子类中。
5. 方法重载方便于阅读，优化了程序设计。

示例

public class Overload {
  public static void main(String[] args) {
    System.out.println(max(5, 9));
    System.out.println(max(5.5, 9.9));
  }
  public static int max(int a, int b) {
    return a > b ? a : b;
  }
  public static float max(float a, float b) {
    return a > b ? a : b;
  }
  public static double max(double a, double b) {
    return a > b ? a : b;
  }
  public static long max(long a, long b) {
    return a > b ? a : b;
  }
}