经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
java基础------函数与数组
来源：cnblogs　　作者：菜鸟|　　时间：2018/10/8 9:19:41　　对本文有异议

函数（方法）

　　　　　　定义：如果一个功能的代码要被复用起来，那么这时候可以把这里的功能代码封装起来，在java中把功能代码封装起来的是以函数的形式体现的。

　　　　　　函数的格式：

　　　　　　　　　　修饰符　返回值类型　函数名（形式参数.....）{

　　　　　　　　　　　　　　需要被封装的功能代码；

　　　　　　　　　　　　　　return 结果；

　　　　　　　　　　　　　　　　}

　　　　　　例如：

　　　　　　　　　　public static int add（）{

　　　　　　　　　　　　　　int a=2；

　　　　　　　　　　　　　　int b=3；

　　　　　　　　　　　　　　return a+b；

　　　　　　　　　　　　　　}

　　　　　　分析函数：

　　　　　　　　　　修饰符：public static

　　　　　　　　　　返回值类型：int  返回值类型就是指函数运行完毕后，返回结果的数据类型。

　　　　　　　　　　　　　　　　注意： 某些函数是没有结果返回给调用者的,那么这时候返回值类型是void。

　　　　　　　　　　函数名：add

　　　　　　　　　　　　　　函数名的作用：如果需要调用该函数就需要使用的函数名。 函数名只要符合标识符的命名规则即可。 

　　　　　　　　　　　　　　函数名的命名规范： 首单词全部小写，其他单词的首字母大写，其他小写。

　　　　　　　　　　形式参数： 如果一个函数在运行的时候，存在的数据是要调用者确定的，那么这时候就应该定义形式参数。

　　　　　　　　　　return：把一个结果返回给调用者。

　　　　　　函数的作用：提高功能代码的复用性

　　　　　　函数的特点：

　　　　　　　　　　1. 函数的作用就是把一个功能代码给封装起来，已达到提高功能代码的复用性。

　　　　　　　　　　2.函数定义好之后是需要被调用才会执行的。其中main函数是由jvm调用的，不需要我们手动调用。

　　　　　　　　　　3.如果一个函数没有返回值返回给调用者，那么返回值类型必须是使用void表示。　

　　　　　　如何定义一个函数：
　　　　　　　　　　1. 返回值类型。
　　　　　　　　　　2. 是否存在未知的参数(是否存在要由调用者确定的参数)。---->形式参数

  1. class Demo1
  2. {
  3.     public static void main(String[] args) 
  4.     {
  5.         //int max = getMax(14,5); //调用了需求1的函数，括号内填写的是实际参数，实际参数由调用者确定
  6.         //System.out.println("最大值："+ max);//输出需求1的结果 结果为14
  8.         getMax(3,7);//调用了需求2的函数
  9.     }    
  11. /*
  12.     //需求1： 定义一个函数比较两个int类型的数据大小，把最大值返回给调用者。
  13.     public static int  getMax(int a, int b){  // 形式参数
  14.         int max = 0; //定义一个变量用于保存最大值的
  15.         if(a>b){
  16.             max = a;
  17.         }else{
  18.             max = b;
  19.         }
  20.         return max;//把结果返回给调用者
  21.     }
  22. */
  23.  
  24.     //需求2：定义一个函数比较两个int类型的数据大小，不需要把最大值返回给调用者,直接打印即可。
  25.     public static void getMax(int a, int b){
  26.         int max = 0; //定义一个变量用于保存最大值的
  27.         if(a>b){
  28.             max = a;
  29.         }else{
  30.             max = b;
  31.         }
  32.         System.out.println("最大值："+ max);
  33.     }
  35. }
View Code
  1. class Demo2 
  2. {
  3.     public static void main(String[] args) {
  4.         //String result = getGrade(91);//调用了需求1的函数，并把结果赋值给result
  5.         //System.out.println(result);//输出的结果为：A等级
  7.         print(7);//调用了需求2的函数
  8.     }
  10. //需求1： 定义一个函数判断一个分数的等级，把分数的等级返回给调用者。
  11.     public static String getGrade(int score){
  12.         String grade = "";    //定义一个变量存储等级
  13.         if(score>=90&&score<=100){
  14.             grade = "A等级";
  15.         }else if(score>=80&&score<=89){
  16.             grade = "B等级";
  17.         }else if(score>=70&&score<=79){
  18.             grade = "C等级";
  19.         }else if(score>=60&&score<=69){
  20.             grade = "D等级";
  21.         }else if(score>=0&&score<=59){
  22.             grade = "E等级";
  23.         }else{
  24.             grade = "补考等级";
  25.         }
  26.         return grade;//把等级返回给调用者
  27.     }
  29.     //需求2： 定义一个函数打印一个乘法表，不需要返回任何数据。 
  30.     public static void  print(int row){
  31.         for(int i = 1 ; i<= row ; i++){
  32.             for (int j = 1 ;j<=i  ;j++ ){
  33.                 System.out.print(i+"*"+j+"="+i*j+"\t");
  34.             }
  35.             //换行
  36.             System.out.println();
  37.         }
  38.     }
  40. }
View Code

　　　　　　注意： 如果一个函数的返回值类型是具体的数据类型，那么该函数必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）

  1. class Demo3{
  2.     public static void main(String[] args) 
  3.     {
  4.         String result = getGrade(10);//调用函数
  5.         System.out.println("对应的等级是："+ result );
  6.     }
  7.     public static String getGrade(int score){//未知的参数定义在形参中，由函数的调用者确定。
  8.         if(score>=90&&score<=100){
  9.             return "A等级";
  10.         }else if(score>=80&&score<=89){
  11.             return "B等级";
  12.         }else if(score>=70&&score<=79){
  13.             return "C等级";
  14.         }else if(score>=60&&score<=69){
  15.             return "D等级";
  16.         }else if(score>=0&&score<=59){
  17.             return "E等级";
  18.         }else{
  19.             //如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外）
  20.             return "补考等级";
  21.         }
  22.     }
  23. }
View Code

　　　　　　return 关键字的作用：

　　　　　　　　　　1. 返回数据给函数的调用者。

　　　　　　　　　　2. 函数一旦执行到了return关键字，那么该函数马上结束。 (能结束一个函数)

　　　　　　注意：如果一个函数的返回值类型是void，那么也可以出现return关键字，但是return关键字的后面不能有数据。

　　　　　　break关键字与return关键字的区别：

　　　　　　　　　　1.break关键字是结束一个循环。

　　　　　　　　　　2. return关键字是结束一个函数。

　　　　　　函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。

　　　　　　函数重载的要求：

　　　　　　　　　　1. 函数名一致。

　　　　　　　　　　2. 形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）

　　　　　　　　　　3. 与函数的返回值类型是无关的。

　　　　　　函数重载的作用： 同一个函数名可以出现不同的函数，以应对不同个数或者不同数据类型的参数。

  1. class Demo4 {
  2.     public static void main(String[] args) {
  3.         add1(1,2);//调用了含有两个参数的函数
  4.         add(1,2.0);//调用了含有三个参数的函数
  5.     }
  7.         // 一下两个函数都是以函数重载在做加法运算。
  8.     public static double add(int a, int b){
  9.         System.out.println("两个参数的总和: "+ (a+b));
  10.         return 3.14;
  11.     }
  13.     public static void add(int a , int b , int c){
  14.         System.out.println("三个参数的总和: "+ (a+b+c));
  15.     }
  17. }
View Code

数组

　　　　　　定义：数组是存储同一种数据类型数据的集合容器。

　　　　　　数组的定义格式：

　　　　　　　　　　数据类型[]  变量名 = new 数据类型[长度];

　　　　　　分析数组:

　　　　　　　　　　左边： int[] arr    声明了一个int类型的的数组变量，变量名为arr。

　　　　　　　　　　　　　　int : 表示该数组容器只能存储int类型的数据。

　　　　　　　　　　　　　　[] ： 这是一个数组类型。

　　　　　　　　　　　　　　arr ： 变量名。

　　　　　　　　　　右边：new int[50]　创建了一个长度为50的int类型数组对象。

　　　　　　　　　　　　　　new ： 创建数组对象的关键字。

　　　　　　　　　　　　　　int：表示该数组对象只能存储int类型数据。

　　　　　　　　　　　　　　[]： 表示是数组类型。

　　　　　　　　　　　　　　50 : 该数组最多能存储50个数据。数组的容量。

　　　　　　数组的好处： 对分配到数组对象中的每一个数据都能够分配到一个索引值（编号、角标、下标）,索引值的范围是从0开始，最大是： 长度-1。

　　　　　　局部变量： 如果一个变量是在一个函数（方法）的内部声明的，那么该变量就是一个局部变量。

　　　　　　成员变量： 成员变量就是定义在方法之外，类之内的.

  1. class Demo5 {
  2.     public static void main(String[] args) 
  3.     {
  4.         //定义一个数组
  5.         int[] arr = new int[4];
  6.         arr[0] = 10;
  7.         arr[1] = 30;
  8.         arr[2] = 50;
  9.         arr[3] = 90; 
  10.         
  11.         //System.out.println("数组的容量："+ arr.length);    //数组里有一个length 的属性，可以查看数组的容量。
  12.         //System.out.println("arr[2] = "+ arr[2]);//查看索引值为2的数组的值    结果为：50
  13.         
  14.         //查看数组中的所有数据。
  15.         for(int index = 0 ; index<arr.length ; index++){
  16.             System.out.println(arr[index]);
  17.         }
  18.     }
  19. }
View Code

　　　　　　数组的内存分析图：

　　　　　　数组中常见的问题：

　　　　　　　　　　1. NullPointerException 空指针异常

　　　　　　　　　　原因： 引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。

　　　　　　　　　　2. ArrayIndexOutOfBoundsException 索引值越界。

　　　　　　　　　　原因：访问了不存在的索引值。

　　　　　　数组的初始方式：

　　　　　　　　　　动态初始化：数据类型[] 变量名 = new 数据类型[长度]；

　　　　　　　　　　静态初始化：数据类型[] 变量名 = {元素1，元素2.....}；

　　　　　　如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果一开始数据还不太明确，这时候就建议使用动态初始化。

  1. class Demo6{
  2.     public static void main(String[] args) 
  3.     {    
  4.             /*
  5.         //动态初始化
  6.         int[] arr = new int[10];
  7.         Scanner scanner = new Scanner(System.in);//创建扫描器对象
  8.         for(int i  = 0 ; i< arr.length ; i++){
  9.             arr[i] = scanner.nextInt();//调用扫描器的nextInt()扫描数据，并把数据赋值于数组中
  10.         }
  11.         */
  12.  
  13.         //静态初始化
  14.         int[] arr = {10,20,30,40,50};
  15.                 //查看数组的所有数据
  16.         for(int index = 0 ; index<arr.length ; index++){
  17.              System.out.print(arr[index]+",");
  18.         }
  21.     
  22.     }
  23. }
View Code
  1. /*
  2.     需求： 定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素并返回给调用者。
  3. */
  4. class Demo7 {
  5.     public static void main(String[] args) 
  6.     {
  7.         int[] arr = {-12,-14,-5,-26,-4};//静态初始化
  8.         int max = getMax(arr);
  9.         System.out.println("最大值："+ max); //结果为：-4
  10.     }
  12.     public static int  getMax(int[] arr){
  13.         int max = arr[0]; //用于记录最大值
  14.         for(int i = 1 ; i < arr.length ; i++){
  15.             if(arr[i]>max){  //如果发现有元素比max大，那么max变量就记录该元素。
  16.                 max = arr[i];
  17.             }
  18.         }
  19.         return max;//把max的值返回给调用者
  20.     }
  21. }
View Code

　　　　　　数组常见的操作：

　　　　　　　　　　选择排序(直接排序)：使用一个元素与其他的元素挨个比较一次，符合条件交换位置。

　　　　　　　　　　需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。

  1. class Demo8{
  2.     public static void main(String[] args) 
  3.     {
  4.         int[] arr = {12,5,17,8,9};  //对于有5个元素的数组，只需要找出4个最大值就可以排序了。
  5.         selectSort(arr);
  6.     }
  8.     public static void selectSort(int[] arr){
  9.         
  10.         //对以下注释的代码进行优化
  11.         for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
  12.             for(int i = j+1 ; i<arr.length ; i++){ //控制的是每次找出的最大值
  13.                 if(arr[i]>arr[j]){
  14.                     //交换位置
  15.                     int temp = arr[i];
  16.                     arr[i] = arr[j];
  17.                     arr[j] = temp;
  18.                 }
  19.             }
  20.         }
  21.         
  23. /*
  24.                 //把老大放在第一个位置
  25.                 for(int i=1;i<arr.length;i++）{
  26.                        if(arr[i]>arr[0]){
  27.                 int temp = arr[i];
  28.                 arr[i] = arr[0];
  29.                 arr[0] = temp;
  30.             }
  31.                  }
  32.                 
  33.         //把老二放在第二个位置
  34.         for(int i = 2  ; i< arr.length ; i++){
  35.             if(arr[i]>arr[1]){
  36.                 int temp = arr[i];
  37.                 arr[i] = arr[1];
  38.                 arr[1] = temp;
  39.             }
  40.         }
  41.         
  43.         //把老三放在第三个位置
  44.         for(int i = 3  ; i< arr.length ; i++){
  45.             if(arr[i]>arr[2]){
  46.                 int temp = arr[i];
  47.                 arr[i] = arr[2];
  48.                 arr[2] = temp;
  49.             }
  50.         }
  52.         //把老四放在第四个位置
  53.         for(int i = 4  ; i< arr.length ; i++){
  54.             if(arr[i]>arr[3]){
  55.                 int temp = arr[i];
  56.                 arr[i] = arr[3];
  57.                 arr[3] = temp;
  58.             }
  59.         }
  61. */
  62.  
  63.         //遍历数组，查看效果
  64.         System.out.print("目前的元素：");
  65.         for (int i = 0 ; i<arr.length  ;i++){
  66.             System.out.print(arr[i]+",");
  67.         }
  68.     }
  69. }
  70.
View Code

　　　　　　　　　　冒泡排序：冒泡排序的思想就是使用相邻的两个元素挨个比较一次，符合条件交换位置。

　　　　　　　　　　需求： 定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。

  1. class Demo9 {
  2.     public static void main(String[] args) 
  3.     {
  4.         int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
  5.          bubbleSort(arr);
  6.     }
  9.     public static void bubbleSort(int[] arr){
  10.         //对以下注释的代码进行优化
  11.         for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
  12.             for(int i = 0 ; i<arr.length-1-j  ; i++){  //控制找出一个最大值  
  13.                 //相邻的元素比较
  14.                 if(arr[i]>arr[i+1]){
  15.                     int temp  = arr[i];
  16.                     arr[i] = arr[i+1];
  17.                     arr[i+1] = temp;
  18.                 }
  19.             }
  20.         }
  22. /*
  23.                 // 把最大值放在最后一个位置
  24.             for(int i = 0 ;  i <arr.length-1-0 ; i++){
  25.                 if(arr[i]>arr[i+1]){
  26.                 int temp = arr[i];
  27.                 arr[i] = arr[i+1];
  28.                 arr[i+1] = temp;
  29.             }    
  30.         }
  32.         //把老二放在倒数第二个位置上。
  33.         for(int i = 0 ;  i <arr.length-1-1 ; i++){
  34.             if(arr[i]>arr[i+1]){
  35.                 int temp = arr[i];
  36.                 arr[i] = arr[i+1];
  37.                 arr[i+1] = temp;
  38.             }    
  39.         }
  41.         //把老三放在倒数第三个位置上。
  42.         for(int i = 0 ;  i <arr.length-1-2 ; i++){
  43.             if(arr[i]>arr[i+1]){
  44.                 int temp = arr[i];
  45.                 arr[i] = arr[i+1];
  46.                 arr[i+1] = temp;
  47.             }    
  48.         }
  50.         //把老四放在倒数第四个位置上。
  51.         for(int i = 0 ;  i <arr.length-1-3 ; i++){
  52.             if(arr[i]>arr[i+1]){
  53.                 int temp = arr[i];
  54.                 arr[i] = arr[i+1];
  55.                 arr[i+1] = temp;
  56.             }    
  57.         }
  59. */
  60.  
  61.         //遍历数组，查看效果
  62.         System.out.print("目前的元素：");
  63.         for (int i = 0 ; i<arr.length; i++){
  64.             System.out.print(arr[i]+",");
  65.         }
  66.     }
  67. }
View Code

　　　　　　　　　　二分查找法：定义三个变量分别记录要查找元素的范围最大索引值、中间索引值、最小索引值，每次都是使用中间索引值的元素与目标元素比较一次，如果不是我们所需要的元素，那么缩小查找的范围。

　　　　　　　　　　注意：使用二分查找法的前提必须是有序的数组。

　　　　　　　　　　需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。

  1. class Demo10 {
  2.     public static void main(String[] args) 
  3.     {
  4.         int[] arr = {12,16,19,23,54};
  5.         //int index = searchEle(arr,23);//调用searchEle（），但是效率低
  6.         int index = halfSearch(arr,116);
  7.         System.out.println("元素所在的索引值是："+ index);
  8.     }
  9.     
  10.         
  11.     public static int halfSearch(int[] arr, int target){
  12.         //定义三个变量分别记录最大、最小、中间的查找范围索引值
  13.         int max = arr.length-1;
  14.         int min = 0;
  15.         int mid = (max+min)/2;
  16.         while(true){
  17.             if(target>arr[mid]){
  18.                 min = mid+1;
  19.             }else if(target<arr[mid]){
  20.                 max = mid -1;
  21.             }else{
  22.                 //找到了元素
  23.                 return mid;
  24.             }
  26.             //没有找到的情况
  27.             if (max<min){
  28.                 return -1;
  29.             }
  31.             //重新计算中间索引值
  32.             mid = (min+max)/2;
  33.         }
  34.     
  35.     }
  36. /*
  37.     public static int searchEle(int[] arr, int target){
  38.         for(int i = 0 ; i<arr.length ; i++){
  39.             if(arr[i]==target){
  40.                 return i;
  41.             }
  42.         }
  43.         return -1;
  44.     }
  45. */
  46. }
View Code
  1. /*
  2. 需求： 定义 一个函数接收一个char类型的数组对象,然后翻转数组中的元素。    
  3. 例如：char[] arr = {'a','b','c','d','e'};翻转元素后的结果为e、d、c、b、a
  4. */
  5. class Demo11{
  6.     public static void main(String[] args){
  7.         char[] arr = {'a','b','c','d','e'};
  8.         reverse(arr);
  9.     }
  11.     public static void reverse(char[] arr){
  12.         for(int startIndex = 0 ,endIndex = arr.length-1 ;   startIndex<endIndex ; startIndex++,endIndex--){
  13.             char temp = arr[startIndex];
  14.             arr[startIndex] = arr[endIndex];
  15.             arr[endIndex] = temp;
  16.         }
  18.         //遍历数组，查看效果
  19.         System.out.print("目前的元素：");
  20.         for (int i = 0 ; i<arr.length  ;i++){
  21.             System.out.print(arr[i]+",");
  22.         }
  24.     }
  25. }
View Code

 　　　　　　二维数组：二维数组就是数组中的数组。

　　　　　　二维数组的定义格式：数据类型[][] 变量名 = new 数据类型[长度1][长度2]；

　　　　　　二维数组的初始化方式：

　　　　　　　　　　动态初始化：数据类型[][] 变量名 = new 数据类型[长度1][长度2]；

　　　　　　　　　　静态初始化：数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..}；

　　　　　　二维数组的内存分析图：

　　　　　　数组的特点：

　　　　　　　　　　1. 数组只能存储同一种数据类型的数据。

　　　　　　　　　　2. 数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；

　　　　　　　　　　3. 数组一旦初始化，长度固定。

　　　　　　　　　　4. 数组中的元素与元素之间的内存地址是连续的。

  1. class Demo12{
  2.     public static void main(String[] args) 
  3.     {    
  4.         //定义了一个二维数组
  5.         int[][] arr = new int[3][4];
  6.         arr[1][1] = 100;
  7.         /*
  8.         System.out.println("二维数组的长度："+ arr.length);  //长度为3
  9.         System.out.println("二维数组的长度："+ arr[1].length); //长度为4
  10.         */
  11.         System.out.println("数组的元素："+ arr[1][1]);结果为100
  12.         
  13.     }
  14. }
View Code

 

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号