day03-函数和数组

最新推荐文章于 2024-10-01 09:29:45 发布
最新推荐文章于 2024-10-01 09:29:45 发布
阅读量349 收藏
点赞数
分类专栏： Java SE 文章标签： java se java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LASTSTARTDUST/article/details/77925656
版权

2.7函数

  • 函数定义
  • 函数特点
  • 函数应用
  • 函数重载 

2.7.1函数定义

  • 什么是函数？ 
    • 函数就是定义在类中的具有特定功能的一段独立小程序。 
    • 函数也称为方法。
  • 函数的格式： 
    修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，) 
    { 
    执行语句; 
    return 返回值; 
    }

返回值类型：函数运行后的结果的数据类型。 
参数类型：是形式参数的数据类型。 
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数。 
实际参数：传递给形式参数的具体数值。 
return：用于结束函数。 
返回值：该值会返回给调用者。

2.7.2函数的特点

  • 定义函数可以将功能代码进行封装，便于对该功能进行复用。
  • 函数只有被调用才会被执行。
  • 函数的出现提高了代码的复用性。
  • 对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一 
    行可以省略不写。
  • 注意： 
    1.函数中只能调用函数，不可以在函数内部定义函数。 
    2. 定义函数时，函数的结果应该返回给调用者，交由调用者处理。

2.7.3函数的应用

  • 两个明确： 
    1.明确要定义的功能最后结果是什么？ 
    （明确返回值类型） 
    2.明确在定义的功能中，是否需要其他未知内容参与运算。 
    （明确参数列表）

  • 示例： 
    需求：定义一个功能，可以实现两个整数的加法运算。 
    分析： 
    1. 该功能的运算结果是什么？ 
    是两个数的和 是int型 （返回值类型为int）。 
    2.在实现该功能的过程中是否有未知内容参与运算？ 
    需要两个整数，被加数和加数是不确定的（参数列表 （int a，int b））。 
    代码：
    int add(int a,int b){ 
    return a+b; 
    }

2.7.4函数的重载

  • 定义：在同一个类中，允许存在一个以上的同名函数，只要他们的 参数个数或者 参数类型不同即可。
  • 重载的特点： 
    与函数的返回值类型无关，只和参数列表有关。
  • 重载的好处： 
    方便于阅读，优化了程序设计。
  • 重载示例： 
    返回两个int型数的和 
    int add(int a,int b){ return a+b; } 
    返回两个double型数的和 
    double add(double a,double b){ return a+b; } //与第一个相比，参数类型 不同 
    返回三个int型数的和 
    int add(int a,int b,int c){ return a+b+c;} //与第一个相比，参数个数 不同哦，多了个参数c。

2.8数组

  • 数组的定义
  • 数组的内存分配及特点
  • 数组操作常见问题
  • 数组常见操作
  • 数组中的数组

2.8.1 数组的定义

概念：同一种类型数据的集合。其实数组就是一个容器。

数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1： 
元素类型[] 数组名 = new 元素类型[元素个数或数组长度]; 
示例：int[] arr = new int[5]; 
格式2： 
元素类型[] 数组名 = new 元素类型[]{元素，元素，……}; 

int[] arr = new int[]{3,5,1,7}; 
int[] arr = {3,5,1,7};

2.8.2数组的内存分配及特点

 int[] arr = new int[4];

1.arr引用 
new int[3],返回地址给arr引用。 
arr通过地址指向对应的实体数组的首地址。 

2.8.2.1内存结构

Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空 
间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内 
存管理方式。

  • 栈内存 
    用于存储局部变量，当数据使用完，所占空间会自动释放。
  • 堆内存 
    数组和对象，通过new建立的实例都存放在堆内存中。 
    每一个实体都有内存地址值。 
    实体中的变量都有默认初始化值。 
    实体不在被使用，会在不确定的时间内被垃圾回收器回收。
  • 方法区，本地方法区，寄存器

2.8.3数组操作常见问题

  • 数组脚标越界异常(ArrayIndexOutOfBoundsException)。 
    int[] arr = new int[2]; 
    System.out.println(arr[3]); 
    访问到了数组中的不存在的脚标时发生。
  • 空指针异常(NullPointerException) 
    int[] arr = null; 
    System.out.println(arr[0]); 
    arr 引用没有指向实体，却在操作实体中的元素时。

2.8.4数组常见操作

  • 获取最值（最大值和最小值）
  • 排序（选择排序，冒泡排序）
  • 查找（折半查找法）

获取最大值

方法一：交换数组中的具体数据实现

  
  
  1. public static int getMax(int[] arr){
  2.         int max = arr[0]; //交换数组中的具体数据实现
  3.         for(int i=1;i<arr.length;i++){
  4.             if(arr[i]>max){
  5.                 max=arr[i];
  6.             }
  7.         }
  8.         return max;
  9. }

方法二：交换数组的角标实现

  
  
  1. public static int getMaxByIndex(int[] arr){
  2.         int max = 0; //交换数组的角标实现
  3.         for(int i=1;i<arr.length;i++){
  5.             if(arr[i]>arr[max]){
  6.                 max=i;
  7.             }
  9.         }
  10.         return arr[max];
  11. }

获取最小值：

方法一：交换数组中的具体数据实现

  
  
  1. public static int getMin(int[] arr){
  2.         int min = arr[0]; //交换数组中的具体数据实现
  3.         for(int i=1;i<arr.length;i++){
  5.             if(arr[i]<min){
  6.                 min=arr[i];
  7.             }
  9.         }
  10.         return min;
  11. }

方法二：交换数组的角标实现

  
  
  1. public static int getMinByIndex(int[] arr){
  2.         int min = 0; //交换数组的角标实现
  3.         for(int i=1;i<arr.length;i++){
  5.             if(arr[i]<arr[min]){
  6.                 min=i;
  7.             }
  9.         }
  10.         return arr[min];
  11. }

2.8.5数组中的数组

二维数组 
格式1：int[][] arr = new int[3][2];

  • 定义了名称为arr的二维数组
  • 二维数组中有3个一维数组
  • 每一个一维数组中有2个元素
  • 一维数组的名称分别为arr[0], arr[1], arr[2]
  • 给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2：int[][] arr = new int[3][];

  • 二维数组中有3个一维数组
  • 每个一维数组都是默认初始化值null
  • 可以对这个三个一维数组分别进行初始化 
    arr[0] = new int[3]; 
    arr[1] = new int[1]; 
    arr[2] = new int[2]; 
    格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
  • 定义一个名称为arr的二维数组
  • 二维数组中的有3个一维数组
  • 每一个一维数组中具体元素也都已初始化 
    第一个一维数组 arr[0] = {3,8,2}; 
    第二个一维数组 arr[1] = {2,7}; 
    第三个一维数组 arr[2] = {9,0,1,6}; 
    第三个一维数组的长度表示方式：arr[2].length;

代码练习：

ForFor示例

   
   
  1. /*
  2. 打印：
  3.     ***
  4.     ***
  5.     ***
  6.     ***
  7.     ***
  9. */
  10. class ForForDemo{
  11.     public static void main(String[] args){
  13.         for(int x=0;x<5;x++){ //外循环--- 控制行数 
  15.             for(int y=0;y<3;y++){ //内循环-----控制列数
  16.                 System.out.print("*");
  17.             }
  19.             System.out.println();
  20.         }
  21.     }
  23. }

上三角 星型

——————————————————————————————————————————————————

   
   
  1. 上三角：
  2.         *
  3.         **
  4.         ***
  5.         ****
  6.         *****
  7.         分析：一共有五行，外循环5次，内循环每次递增 且和行数一致，第一行一个* 第二行两个* 
  8.           for(int x=1;x<=5;x++){
  9.             for(int y=1;y<=x;y++){//1-1 1-2 1-3 1-4 1-5  
  10.                 System.out.print("*");
  11.             }
  12.             System.out.println();
  13.         }

第二种方法：

   
   
  2.         for(int x=1;x<=5;x++){
  3.             for(int y=x;y>0;y--){   /* 1-1 2-1 3-1 4-1 5-1
  4.                                                         * y=1 1>0; * 0=y-- 0>0; 
  5.                                         y=2 2>0; * 1=y-- 1>0; * 0=y--  0>0;                             */
  7.                 System.out.print("*");
  8.             }
  9.             System.out.println();
  10.         }

下三角 星星

——————————————————————————————————————————————————————

   
   
  1. 下三角：
  2.         *****
  3.         ****
  4.         ***
  5.         **
  6.         *
  7.    for(int x=1;x<=5;x++){
  8.        for(int y=x;y<=5;y++){//1-5 2-5 3-5 4-5 5-5
  9.            System.out.print("*");
  10.        }
  11.        System.out.println();
  12.    }

第二种：

   
   
  1.     for(int x=1;x<=5;x++){
  2.          for(int y=5;y>=x;y--){//5-1 5-2 5-3 5-4 5-5
  3.                System.out.print("*");
  4.          }
  5.          System.out.println();
  6.    }

——————————————————————————————————————————————————

99乘法表

99乘法表：

   
   
  1.     1*1=1
  2.     1*2=2   2*2=4
  3.     1*3=3   2*3=6   3*3=9
  4.     1*4=4   2*4=8   3*4=12  4*4=16
  5.     1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
  6.     1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
  7.     1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
  8.     1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
  9.     1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

分析： 
从形式看，与上三角型相识，先打印上三角形，确定大概布局 
外循环分析：行数一共有9行，外循环要循环9次 
内循环分析：对第四行 每一列，被乘数都是从1开始递增到4（与行数相同？），乘数都是4（与行数相同）

所以形式是
for(i=1;i<=9;i++){ //控制外循环 9次
    for(y=1;y<=x;y++){ //内循环 上三角形式

    }
}

源代码：

   
   
  1. public class ForFor99{
  2.     public static void main(String[] args){
  3.         for(int x=1;x<=9;x++){
  4.             for(int y=1;y<=x;y++){
  5.                 System.out.print(y+"*"+x+"="+y*x);
  6.                 System.out.print("\t");//制表符 严格按表格划分
  7.             }
  8.             System.out.println();//换行
  9.         }
  10.     }
  11. }

函数

需求1： 定义一个功能，完成两个整数的和的获取。

  • 明确一：这个功能的结果是什么？ 
    结果是和，是int型。
  • 明确二：这个功能实现过程中是否需要未知内容参与运算？ 
    有，被加数和加数。明确参数列表。
   
   
  1. public static int add(int a, int b){ //static 修饰符 使得此方法为静态方法，可以被其它静态方法调用。
  2.         return a+b;
  3. }

需求2： 定义一个功能，画一个矩形在控制台。

  • 明确一：这个功能的结果是什么？ 
    是一个矩形图案，无返回值，
  • 明确二：这个功能实现过程中是否需要未知内容参与运算？ 
    有，矩形的长和宽，具体值不确定，（类型int型）
   
   
  1. public static void drawRectangle(int length,int width){
  3.         for(int x=1;x<=width;x++){
  4.             if(x==1||x==width){ //第一行和最后一行都是 ********* 中间没有空格
  5.                 for(int y=1;y<=length;y++){
  6.                     System.out.print("*");
  7.                 }
  9.             }else{                   //第一列和最后一列有星号，形式 *      *
  10.                 for(int y=1;y<=length;y++){  
  11.                     if(y==1||y==length)
  12.                         System.out.print("*");
  13.                     else
  14.                         System.out.print(" ");
  15.                 }
  16.             }
  18.             System.out.println();
  20.         }
  21. }

需求3： 定义一个功能，比较两个数是否相等。

    明确一：这个功能的结果是什么？
                结果是true 或者false，是boolean类型
    明确二：这个功能实现过程中是否需要

   
   
  1. public static boolean equals(int a,int b){
  2.         return a==b;
  3. }

需求4： 定义一个功能，获取两个整数中较大的那个数。

    明确一：这个功能的结果是什么？
                结果是 最大的数，是int型
    明确二：这个功能实现过程中是否需要未知内容参与运算？  
                有，两个比较的数。int型

   
   
  1. public static int getNumMax(int num1,int num2){
  2.       return (num1>num2)?num1:num2;
  3. }

需求5：定义功能，打印99乘法表。

    明确一：这个功能的结果是什么？
                结果99乘法表，无返回值。
    明确二：这个功能实现过程中是否需要未知内容参与运算？
                可以不需要

   
   
  1. public static void multiTable99(){
  3.         for(int x=1;x<=9;x++){
  4.             for(int y=1;y<=x;y++){
  5.                 System.out.print(y+"*"+x+"="+y*x);
  6.                 System.out.print("\t");
  7.             }
  8.             System.out.println();
  9.         }
  10. }

需求6:根据考试成绩获取学生分数对应的等级

    90~100     A
    80~89      B
    70~79      C
    60~69      D
    60以下        E
    明确一：这个功能的结果是什么？
                结果是 等级 ，字符型
    明确二：这个功能实现过程中是否需要未知内容参与运算？
                有，学生分数

   
   
  1. public static char getRank(int grades){
  2.         char level;
  3.       /*if(grades>=90&&grades<=100){
  4.             level='A';
  5.         }else if(grades>=80&&grades<=89){
  6.             level='B';
  7.         }else if(grades>=70&&grades<=79){
  8.             level='C';
  9.         }else if(grades>=60&&grades<=69){
  10.             level='D';
  11.         }else 
  12.             level='E'; */
  15.         //使用switch实现
  16.         switch(grades/10){
  17.             case 9:
  18.                 level='A';
  19.                 break;
  20.             case 8:
  21.                 level='B';
  22.                 break;
  23.             case 7:
  24.                 level='C';
  25.                 break;
  26.             case 6:
  27.                 level='D';
  28.                 break;
  29.             default:
  30.                 level='E';
  31.                 break;
  32.         }
  33.         return level;
  35. }

——————————————————————————————————————————————————

数组

数组最值（最大值，最小值）

最大值：

   
   
  1. public static int getMax(int[] arr){
  2.     int max = arr[0]; //交换数组中的具体数据实现
  3.     for(int i=1;i<arr.length;i++){
  4.         if(arr[i]>max){
  5.             max=arr[i];
  6.         }
  7.     }
  8.     return max;
  9. }

最小值

   
   
  1. public static int getMin(int[] arr){
  2.     int min = arr[0]; //交换数组中的具体数据实现
  4.     for(int i=1;i<arr.length;i++){
  5.         if(arr[i]<min){
  6.             min=arr[i];
  7.         }
  8.     }
  9.     return min;
  10. }

1选择排序

思路； 
1.第一次外循环，先取第一个数 分别和之后的数比较，如果后面的数比第一个数大，就把数大的数值赋给第一个，以此类推。 
2.第二次外循环，取第二个数，分别和之后的数比较，如果后面的数比第一个数大，就把数大的数值赋给第一个，以此类推。 
3.。。。。。。。。。。 
4.直到取到最后一个数，结束循环。 
*/

   
   
  1. public static void selecSortaA(int[] arr){ //从小到大排序
  2.     for(int x=0;x<arr.length;x++){
  3.         for(int y=x+1;y<arr.length;y++){
  5.             if(arr[x]>arr[y]){  
  6.                 int temp=arr[x];
  7.                 arr[x]=arr[y];
  8.                 arr[y]=temp;
  10.             }
  11.         }
  12.     }
  13. }

2冒泡排序

每一轮比较以后最大的数沉到底面（最后），因此，下一轮比较排除该数，体现在内循环减一。

   
   
  1. public static void bubbleSort(int[] arr){
  3.     for(int x=0;x<arr.length-1;x++){
  4.         for(int y=0;y<arr.length-1-x;y++){
  5.             if(arr[y]>arr[y+1]){
  6.                 //swap(arr,y,y+1);
  7.                 int temp=arr[y];
  8.                 arr[y]=arr[y+1];
  9.                 arr[y+1]=temp;
  10.             }
  11.         }
  12.     }
  14. }

折半查找（二分查找）

   
   
  1. public static int binarySearch_2(int[] arr,int key){
  2.     int mid,min,max;
  3.     min=0;
  4.     max=arr.length-1;
  6.     while(min<max){//如果遍历完整个数组，结束循环
  7.         mid=(min+max)/2;
  9.         if(key>arr[mid])
  10.             min=mid+1;
  11.         else if(key<arr[mid])
  12.             max=mid-1;
  13.         else             //此时key==arr[mid]
  14.             return mid;
  15.     }
  16.     return -1;
  17. }

一个整数如何转换为16进制数

转换的数存储在数组中

   
   
  1. public static char[] decToHex2(int num){
  2.     char[] tab ={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//表
  3.     char[] arr = new char[8];
  4.     int pos=arr.length;
  6.     while(num!=0){
  7.         int i = num&15;
  8.         arr[--pos]=tab[i];
  9.         num=num>>>4;
  10.     }
  11.     return arr; //返回引用
  12. }

转换的数存储在字符串中

   
   
  1. public static String decToHex(int num){
  3.     char[] tab ={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//表
  4.     String str="";
  5.     char temp =0;  //临时存储0到F字符
  6.     while(num!=0){
  7.         /*与1111（15）相与获得 4位二进制数，相当于一位1
  8.         6进制数，通过此数，去表里查
  9.         询对应的字符比如0对应0 10对应A
  10.         */
  11.         int i =num&15;
  12.         temp = tab[i];
  13.         str = str+temp;//将字符连接
  14.         num=num>>>4;    //右移4位
  15.     }
  17.     return reverse(str);
  18. }
  19. public static String reverse(String str){  //字符串反转
  20.     return new StringBuilder(str).reverse().toString();
  21. }

进制转换

   
   
  1. public static char[] toHex(int num){//十进制转十六进制
  2.     return binary(num,15,4);//与1111相与，每次获取为4位二进制数
  3. }
  5. public static char[] toOct(int num){//十进制转八进制
  6.     return binary(num,7,3);//与111相与，每次获取为3位二进制数
  7. }
  9. public static char[] toBin(int num){//十进制转二进制
  10.     return binary(num,1,1);//与1相与，每次获取为1位二进制数
  11. }
  13. public static char[] binary(int num,int base,int offect){//数，进制 ,位操作偏移量
  15.     char[] hextab ={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};//进制表
  16.     char[] temp= new char[32];
  17.     int pos=temp.length; 
  19.     while(num!=0){
  20.         int x=num&base;
  21.         temp[--pos]=hextab[x];//与b1111相与 获取4位二进制数，也即时是一位16进制数
  22.         num=num>>>offect; //右移offect位 
  23.     }
  24.     return temp;
  25. }

二维数组

   
   
  1. /**
  2. 二维数组
  4. */
  5. public class TwoArrayDemo{
  6.     public static void main(String[] args){
  8.         int[][] arr = new int[3][2];//定义一个二维数组，数组中有3个一维数组，每个一维数组有2个int型的元素
  9.         System.out.println(arr[0]);//
  11.         int[][] arr1 = new int[3][];
  12.         System.out.println(arr1[0]);//null
  14.         int[] arr3 =new int[3];
  15.         System.out.println(arr3[0]);//0
  16.     }
  17. }


LASTSTARTDUST
关注
专栏目录
Presto--数组函数和运算符
寸草心的博客
05-21 1万+
数组函数和运算符 下标运营商：[] 的[]操作者用于访问的阵列的元件和被索引从1开始： SELECT my_array [ 1 ] AS first_element 连接运算符：|| 的||操作者用来连接与数组或相同类型的元素的数组： SELECT ARRAY [ 1 ] || ARRAY [ 2 ]; - [1,2] SELECT ARRAY [ 1 ] || 2...
python自定义函数输出数组_Day7：自定义函数、数组
weixin_29304713的博客
12-23 1388
一、数组的遍历1、foreach关联数组(1)格式：foreach(数组 as 自定义变量){循环的代码}
javaSE 4.5
相对静止
04-27 420
/* 需求1： 定义一个功能，完成两个整数的和的获取。 思路：既然定义功能，就是可以用函数来体现。 如何定义一个函数呢？ 通过两个明确来完成。 明确一：这个功能的结果是什么？ 是和。是功能的结果，所以该功能的返回值类型是int 。 其实就是在明确函数的返回值类型。 明确二：这个功能实现过程中是否需要未知内容参与运算？ 有，加数和被加数。这就是函数的参数列表(参
Java 定义一个方法，该方法的功能是获取两个整数之和
喜龙的小站
12-14 1567
定义一个方法，该方法的功能是获取两个整数之和
我爱学习--函数封装数组求和-Day3
wzl0504的博客
08-30 261
封装函数数组求和案例
嵌入式学习Day11 C语言 --- 数组作为函数的形参、标识符的作用域与生命周期
ZGZM9的博客
01-28 1098
void printStr(char s[][10],int row) //注意需要传行数，因为操作多个字符串。//如果想在当前文件使用别的文件中的 全局变量 ，//相当于，把别的文件中的变量作用域扩展到当前文件。//表示 此时这个a 不是在当前文件中定义的 ，//指针变量 p 指向 了 int型变量a。//这个是一个自动变量 --- 栈上开辟的变量。
day01-leetcode（数组）
qq_46119546的博客
01-24 637
给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。思路：二分查找该题解使用都是左右闭区间[left,right]
day04-随机函数以及数组操作方法
m0_57852920的博客
07-05 979
一些常用的随机数。
一文理解函数和数组
qq_44588612的博客
03-26 819
本文主要讲解了数组和函数的相关内容
Java基础（10）----------反转数组reverse
在这个地方会介绍一些前端和后端的开发内容，暂时以springBoot和Vue为主。
04-14 533
1.for循环，倒序输出 package day01; public class Rev { public static void main(String[] args) { int[]arr = {1,3,5,7,9}; for (int i = arr.length-1; i >=0; i--) { System.out.print(arr[i]); } } } 2. 将最后一个值赋给第一个值
day5shell函数和数组shell编程.txt
03-19
day5shell函数和数组shell编程.txt
python 13、JAVASCRIPT基础3-1_函数、数组、字符串_Day03_AM.mp4
03-14
python 13、JAVASCRIPT基础3-1_函数、数组、字符串_Day03_AM.mp4
deinfra-dev-day-16-06-2015:基本数组方法
05-04
在JavaScript编程语言中，数组是一种常见的数据结构，用于存储一系列有序的...在"deinfra-dev-day-16-06-2015"的学习资料中，你可以找到关于这些方法的实例和更深入的讲解，帮助你更好地掌握JavaScript数组操作技巧。
java将word转pdf
紫月7575的博客
09-30 493
java将word转pdf
「Java开发指南」如何用MyEclipse为iPhone搭建Spring应用程序？
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
09-30 675
本教程将介绍如何用MyEclipse为iPhone搭建Spring应用程序，欢迎下载最新版IDE体验！
spring-boot 整合 mybatis
m0_72168501的博客
09-29 505
spring boot 整合 mybatis
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1124
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
Java内存布局
最新发布
阿呆的专栏
10-01 780
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 317
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
使用where函数定位数组元素：IDL教程
这一部分的教程着重于让学习者掌握如何在IDL中有效地定位数组元素，通过实践`where`函数和理解变量定义与命名规则，为后续的数据处理和分析打下坚实的基础。随着对IDL语言的深入学习，用户将能够处理各种复杂的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值