Java函数和数组

函数使用

函数概念

package com.cloud.day3; /* 函数： 函数的作用：为了提高功能代码的复用性。 函数的定义格式:    修饰符  返回值类型  变量名(形式参数){       函数体    } 函数的特点：    1. 函数是把一个功能的代码封装起来以达到提高功能代码的复用性。    2. 函数定义好之后，需要调用才能执行的。    3. 如果一个函数没有返回值类型，那么就使用void关键字表示。 需求: 定义一个函数判断分数的等级，然后返回分数对应的等级。    "a等级" */ public class Demo1 {    public static void main(String[] args) {       String result = getScore(80);       System.out.println(result);    }    public static String getScore(int score){       if(score>100){         return "你很优秀...";       }else if(score<100 && score>60){         return "还不错...";       }else{         return "继续努力...";       }    } }

函数中return关键字

package com.cloud.day3; /* 注意：如果一个函数的返回值类型是具体的数据类型，那么该函数就必须要保证在任意情况下都保证有返回值。（除了返回值类型是void以外） return 关键字的作用：    1. 返回数据给函数的调用者。    2. 函数一旦执行到了return关键字，那么该函数马上结束。 (能结束一个函数) 注意：一个函数的返回值类型是void，那么也可以出现return关键字，但是return关键字的后面不能有数据。 break关键字与return关键字的区别：    1.break关键字是结束一个循环。    2. return关键字是结束一个函数。 */ public class Demo2 {    public static void main(String[] args) {       test1(0,1);       test2(1,0);    }    public static void test1(int a,int b){       if(a==0){         return ;//结束这个函数       }       System.out.println("not do this print!!");    }    public static void test2(int a,int b){       for(int i=0;i<3;i++){         System.out.println("hello");         break; //跳出这个循环       }       System.out.println("will do this print!");    } }

函数重载

package com.cloud.day3; /* 需求：定义一个函数做加法功能。 函数的重载：在一个类中出现两个或者两个以上的同名函数，这个称作为函数的重载。 函数重载的作用：同一个函数名可以出现了不同的函数，以应对不同个数或者不同数据类型的参数。 函数重载的要求：    1. 函数名一致。    2. 形参列表不一致。（形式参数的个数或者是对应的数据类型不一致）    3. 与函数的返回值类型是无关的。 */ public class Demo3 {    public static void main(String[] args) {       add(1,2);       add(1,2,3);    }    public static int add(int a,int b){       System.out.println("两个参数的和"+(a+b));       return 12;    }    public static double add(int a,int b,int c){       System.out.println(a+b+c);       return 3.14;    } }

数组的使用

数组基础

package com.cloud.day3; /* 数组：数组是存储同一种数据类型数据的集合容器。 数组的定义格式：    数据类型[]  变量名 = new 数据类型[长度]; 分析数组：       左边： int[] arr    声明了一个int类型的的数组变量，变量名为arr。       int : 表示该数组容器只能存储int类型的数据。       [] ：这是一个数组类型。       arr ：变量名.     右边：new int[50]; 创建了一个长度为50的int类型数组对象。       new ：创建数组对象的关键字。       int:  表示该数组对象只能存储int类型数据。       []：表示是数组类型。       50 : 该数组最多能存储50个数据。数组的容量。 数组的好处：对分配到数组对象中每一个数据都分配一个编号（索引值、角标、下标）,索引值的范围是从0开始，最大是：长度-1. 局部变量：如果一个变量是在一个方法（函数）的内部声明的，那么该变量就是一个局部变量。 成员变量：成员变量就是定义在方法之外，类之内的. */ public class Demo4 {    public static void main(String[] args) {       int[] arr = new int[4];       arr[0] = 1;       arr[1] = 2;       arr[2] = 3;       arr[3] = 4;       for(int index = 0;index<arr.length;index++){         System.out.println(arr[index]);       }    } }

数组中异常

package com.cloud.day3; /* 数组中最常见的问题：    1. NullPointerException 空指针异常    原因：引用类型变量没有指向任何对象，而访问了对象的属性或者是调用了对象的方法。    2. ArrayIndexOutOfBoundsException 索引值越界。    原因：访问了不存在的索引值。 */ public class Demo5 {    public static void main(String[] args) {       int[] arr = new int[5];       arr[0] = 1;       arr[1] = 2;       arr[2] = 3;       arr[3] = 4;       //java.lang.ArrayIndexOutOfBoundsException       //数组下表越界       //System.out.println(arr[7]);       //没有赋值的元素的默认的值是0       System.out.println(arr[4]);    } }

数组初始化方式

package com.cloud.day3; /* 数组的初始化方式    动态初始化:       数据类型[] 变量名 = new 数据类型[长度];    静态初始化：        数据类型[] 变量名 = {元素1，元素2.....}; 如果程序一开始你就已经确定了数据，那么这时候建议使用静态初始化。如果 数据一开始还不太明确，这时候就建议使用动态初始化。 */ public class Demo6 {    public static void main(String[] args) {       //静态初始化数组       int[] arr = {1,2,3,4,5};       for(int i=0;i<arr.length;i++){         System.out.print(arr[i]+";");       }       //动态初始化       int[] arr1 = new int[2];       arr1[0] = 2;       arr1[1] = 3;    } }

数组找最大

package com.cloud.day3; /* 需求：定义一个函数接收一个int类型的数组对象，找出数组对象中的最大元素返回给调用者。 */ public class Demo7 {    public static void main(String[] args) {       int[] arr={1,2,3,4};       int max = getMax(arr);       System.out.println("max="+max);    }    public static int getMax(int[] arr){       int max=arr[0];       for(int i=0;i<arr.length;i++){         if(arr[i]>max){            max = arr[i];         }       }       return max;    } }

冒泡排序

package com.cloud.day3; /* 需求：定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的第一位。 选择排序(直接排序)：使用一个元素与其他的元素挨个比较一次，符合条件交换位置。 */ public class Demo8 {    public static void main(String[] args) {       int[] arr={1,2,3,4,5};       sortArr(arr);    }    public static void sortArr(int[] arr){       int temp = 0;       for(int i=0;i<arr.length;i++){         for(int j=i+1;j<arr.length;j++){            if(arr[j]>arr[i]){               temp = arr[j];               arr[j] = arr[i];               arr[i] = temp;            }         }       }       //遍历数组       for(int i=0;i<arr.length;i++){         System.out.print(arr[i]+";");       }    } }

案例二：

package com.cloud.day3; /* 需求：定义一个函数接收一个int类型的数组对象, 把数组中的最大值放在数组中的最后一位。 冒泡排序：冒泡排序的思想就是使用相邻的两个元素挨个比较一次，符合条件交换位置。 */ public class Demo9 {    public static void main(String[] args) {       int[] arr={1,2,3,4,5};       bubbleArr(arr);    }    public static void bubbleArr(int[] arr){       for(int i=0;i<arr.length-1;i++){//控制循环次数         for(int j=0;j<arr.length-1-i;j++){//找出最大值            if(arr[j+1]>arr[j]){               int temp = arr[j+1];               arr[j+1] = arr[j];               arr[j] = temp;            }         }       }       //输出数组       for(int i=0;i<arr.length;i++){         System.out.print(arr[i]+";");       }    } }

二分法

package com.cloud.day3; /* 需求：定义一个函数接收一个数组对象和一个要查找的目标元素，函数要返回该目标元素在 数组中的索引值，如果目标元素不存在数组中，那么返回-1表示。 折半查找法(二分法): 使用前提必需是有序的数组。 */ public class Demo10 {    public static void main(String[] args) {       int[] arr = {1,2,3,4,5,6};       int mid = search(arr, 3);       System.out.println(mid);    }    public static int search(int[] arr,int target){       int max = arr.length-1;       int min = 0;       int mid = (min+max)/2;       while(true){         if(target>arr[mid]){            min = mid + 1;         }else if(target<arr[mid]){            max = mid -1;         }else{            return mid;         }         if(max<min){            return -1;         }         //重新计算中间的索引值         mid = (min+max)/2;       }    } }

数组反转

package com.cloud.day3; /* 需求：定义一个函数接收一个char类型的数组对象,然后翻转数组中的元素。 char[] arr = {'a','b','c','d','e'}; */ public class Demo11 {    public static void main(String[] args) {       char[] arr = {'a','b','c','d','e'};       convertArr(arr);    }    public static void convertArr(char[] arr){       for(int startIndex = 0,endIndex = arr.length-1;startIndex<endIndex;startIndex++,endIndex--){         char temp = arr[startIndex];         arr[startIndex] = arr[endIndex];         arr[endIndex] = temp;       }       //遍历数组       for(int i=0;i<arr.length;i++){         System.out.print(arr[i]+";");       }    } }

二维数组

package com.cloud.day3; /* 二维数组：二维数组就是数组中的数组。 一根           变量 一盒     20根       一维数组 一条     10包   20根   二维数组 二维数组的定义格式：    数据类型[][] 变量名 = new 数据类型[长度1][长度2];    长度1：一条烟有多少盒。    长度2：一盒烟有多少根。   二维数组的初始化方式：    动态初始化:       数据类型[][] 变量名 = new 数据类型[长度1][长度2];      静态初始化：       数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..} */ public class Demo12 {    public static void main(String[] args) {       /**       int[][] arr = new int[3][4];         1  2  3       1  100       2       3       4        */       int[][] arr = new int[3][4];       arr[1][1] = 100;       System.out.println("数组的元素："+ arr[1][1]);    }   }

二维数组初始化

package com.cloud.day3; /* 静态初始化：    数据类型[][]  变量名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...} ..} */ public class Demo13 {    public static void main(String[] args) {       int[][] arr = {{10,11,9},{67,12},{33,35,39,40}};       for(int i=0;i<arr.length;i++){         for(int j=0;j<arr[i].length;j++){            System.out.print(arr[i][j]+";");         }       }    } }

二维数组特点

package com.cloud.day3; /* 数组的特点：    1. 数组只能存储同一种数据类型的数据。    2. 数组是会给存储到数组中的元素分配一个索引值的，索引值从0开始，最大的索引值是length-1；    3. 数组一旦初始化，长度固定。    4. 数组中的元素与元素之间的内存地址是连续的。 */ class Demo14 {    public static void main(String[] args)    {       int[] arr = new int[3];       arr = new int[4];       System.out.println(arr.length);    } }