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

最新推荐文章于 2020-09-07 16:59:16 发布

jacobvv

最新推荐文章于 2020-09-07 16:59:16 发布

阅读量1.2k

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/jacobvv/article/details/41787397

版权

Java 专栏收录该内容

34 篇文章 0 订阅

订阅专栏

数组

概要

和C++不同，Java中的数组是一种引用数据类型，类似C/C++中的数组指针，内存分配在堆区。
数组长度不要求一定是常量，但是一旦创建了数组，就不能再改变它的大小。
可以使用array.length获取数组中元素的个数。

Java中，数组可用for each循环：for(变量:数组名)执行语句（Java 5支持）。

     
     
      
      
       
       for (variable : collection) {
      
      
      
      
       
         statement;
      
      
      
      
       
       }

其中collection必须是一个数组或者是一个实现了Iterable接口的类对象。

Java中，允许长度为0的数组，和null不同。
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语句如果在最后一行可以省略不写。

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

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

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

重载

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

示例

   
   
    
    
     
     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;
    
    
    
    
     
       }
    
    
    
    
     
     }