黑马程序员_JAVA基础-函数与数组

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------

函数部分:

     

      (1)函数的调用

            A:有明确返回值

                  a:单独调用   一般没有意义。

                        举例: sum(2,3);//直接调用计算2+3的和.

                  b:输出调用   但是如果想拿结果继续操作，就有问题了。所以，不好。

                        举例: System.out.println(sum(2,3));

                  c:赋值调用   推荐方式。

                        举例: int c = sum(2,3); //把计算结果赋值给c

 

            B:void类型

                  单独调用, 把结果直接打印在控制台上.

      (2)函数重载

            A:函数名相同,参数列表不同(个数不同,对应的类型不同)。

              与返回值类型无关。

 

            B:举例：

      已知函数 : void show(int a, int b, float c){}  哪个答案和show不是函数重载。

 

      函数名相同

      参数对应列表不同（个数和类型）

 

      A.voidshow(int a,float c,int b){ }

 

      B,voidshow(int x,int y,float z){ }

 

      C.intshow(int a, float c, int b){return a;}

 

      D.intshow(int a, float c ){return a;}

 

2：数组

      (1)定义 : 数组是存储同一种类型的多个元素的容器。

      (2)好处 : 数组中的元素会被自动从0开始编号，方便我们获取。

      (3)格式：

            A:int[] arr = newint[3];  //只定义了数组的长度

            B:int arr[] = new int[3];  //不建议使用

            C:int[] arr = new int[]{1,2,3};  //定义了数组的内容,但是格式麻烦

            D:int[] arr ={1,2,3};    //定义了数组的内容, 省事, 建议使用.

 

            老程序猿推荐: A和D。

 

      (4)Java内存图：

            A:栈     存储局部变量使用。

                  使用完毕，立马消失。

 

            B:堆     所有new出来的都在堆里面。

                  a:每一个实体都有地址值

                  b:每一个实体内的内容都有默认值

                        整数：0

                        浮点数：0.0

                        字符：'\u0000'

                        布尔：false

                  c:在垃圾回收器空闲的时候被回收。

 

            C:方法区

            D:本地方法区

            E:寄存器

      (5)常见操作：

           

            获取数组的长度。

                  数组名.length; 举例: int[] arr ={1,2,3};  int c = arr.length;

 

            A:数组的遍历

public static void printArr(int[] arr)       {             System.out.print("[");             for (int i=0; i<arr.length; i++)             {                   if (i != arr.length-1 )                   {                         System.out.print(arr[i]+",");                   }else{                         System.out.print(arr[i]);                   }             }             System.out.println("]");       }

 

 

 

            B:数组获取最大值

/*             明确; 1,返回值类型为int.               2.参数类型为int[].       */       public static int getMax(int[] arr)       {             //我们假设最大值就是arr[0].             int max = arr[0];             //遍历数组,把数组中每个元素都跟max进行对比             for (int i=1; i<arr.length; i++)   //arr[0]不需要和max对比.             {                   if (arr[i]>max)                   {                         max = arr[i];                   }             }             return max;       }

 

 

 

 C:在给定数组中查找指定元素的位置

public static int getIndex(int a, int[] arr)       {             for (int i=0; i<arr.length; i++)             {                   if (a == arr[i]) //当a等于arr[i],那就返回 i 的值                   {                         return i;                   }             }             System.out.println("您要查找的元素不在给定的数组中");             return -1;  //开发的时候,如果发现没有找到元素,那么默认返回-1 .       }

 

 

D: 数组之查表法与递归的了解

public static void printWeek()       {             //查表法,顾名思义,首先要有表,由于要求打印出汉字"星期几",所以建立String[]类型数组.             String[] strArr = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"};             Scanner sc = new Scanner(System.in);             System.out.println("请输入您要查找的数字: 1-7");             int i = sc.nextInt();             if (i>=1 && i<=7)             {                   System.out.println(strArr[i]);  //先写i,运行后结果不对,发现还需要-1. atrArr[i-1]               }             else             {                   System.out.println("您输入的数字有误,请重新输入");             //先不写下面的代码,这样发现,用户无法再输入了,于是引出再调用一次自己,也就是递归.                   printWeek(); //再调用自己一次,这样用户就可以重新输入数据了.其实这就是传说中的递归!             }       }

 

      (6)二维数组：

            格式：

                  A:int[][]arr = new int[3][2];

                  B:int[][]arr = new int[3][];

                  C:int[][] arr = {{1,2,3},{4,5},{6,7,8,9}};

 

 

            遍历：

//二维数组的遍历             int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};               //arr.length 获取二维数组的长度，其实也就是一维数组的个数             //arr[x].length 获取的是每一个一维数组的长度             //arr[x][y] 获取的是二维数组的元素               for(int x=0; x<arr.length; x++)             {                   for(int y=0; y<arr[x].length; y++)                   {                         System.out.print(arr[x][y]+"\t");                   }                   System.out.println();             }

 

           

 

  应用:数据加密

思路：             A:数据是小于8位的整数,这个数据可以手动给出，也可以通过Scanner给出             B:把数据存储到数组中             C:把数组中的元素倒序             D:把元素加5，然后对10取余替换元素。             E:把数组中第一位元素和最后一位元素交换。             F:遍历数组         举例：             给出的数据：                   123456             加密后：                   倒序：                         654321                   规则：                         109876                   交换：                         609871 */ class JiaMi {       public static void main(String[] args)       {             //定义数据    --    改进成Scanner版本。             //int number = 123456;             //int number = 1234567;             int number = 1234;               //把数据存储到数组中                         //定义数组             int[] arr = new int[8];               //赋值             //arr[0] = number/10/10/10/10/10%10;             //System.out.println(arr[0]);             //arr[1] = number/10/10/10/10%10;             //arr[2] = number/10/10/10%10;             //arr[3] = number/10/10%10;             //arr[4] = number/10%10;             //arr[5] = number%10;               //改进版             //定义一个索引从0开始             /*             int index = 0;             arr[index++] = number/10/10/10/10/10%10;             //System.out.println(arr[0]);             arr[index++] = number/10/10/10/10%10;             arr[index++] = number/10/10/10%10;             arr[index++] = number/10/10%10;             arr[index++] = number/10%10;             arr[index++] = number%10;             */               //改进版             int index = 0;             while(number>0)             {                   arr[index++] = number%10; //获取个位,获取十位...                   number/=10; //number值变化为除以10,                     /*                         第一次：                               number=123456,index=0                                 arr[0]=6;    index=1，number=12345                         第二次：                               index=1，number=12345                                 arr[1] = 5;  index=2，number=1234                         ...                           arr[0] = 6                         arr[1] = 5;                         arr[2] = 4                         ...                           index = 6                         number = 0                   */             }                         //数组遍历             /*             for(int x=0; x<index; x++)             {                   System.out.println(arr[x]);             }             */               //规则             for(int x=0; x<index; x++)             {                   arr[x] += 5;                   arr[x] %= 10;             }               /*             for(int x=0; x<index; x++)             {                   System.out.println(arr[x]);             }             */               //交换             int temp = arr[0];             arr[0] = arr[index - 1];             arr[index - 1] = temp;               for(int x=0; x<index; x++)             {                   System.out.print(arr[x]);             }             System.out.println();       } }

---------------------- <a href="http://www.itheima.com"target="blank">ASP.Net+Unity开发</a>、<a href="http://www.itheima.com"target="blank">.Net培训</a>、期待与您交流！ ----------------------