黑马程序员——函数与数组 笔记第二篇

函数、数组

------- android培训、java培训、期待与您交流！ ----------

1 函数

1.1 函数的特点

1、定义函数可以将功能代码进行封装

2、便于对该功能进行复用

3、函数只有被调用才会被执行

4、函数的出现提高了代码的复用性

5、对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

6、主函数是一个比较特殊的函数，不需要你手动调用，主函数是由java虚拟机调用。

 

注意：

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

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

 

return关键字的作用：

    1.return关键字作用是返回一个数据给调用者。

    2. return关键字的另外一个作用就是结束一个函数。

函数：函数的作用是可以一个功能的代码封装起来已达到功能可以被复用。

 

练习：定义一个函数打印乘法表。

class Demo4

{

    public static void main(String[] args)

    {

       print(3);

    }

    public static void print(introws){

       for(inti = 1 ;i<=rows ;i++){ //行数

           for(intj = 1;j<=i ;j++){ //列数

              System.out.print(i+"*"+j+"="+i*j+"\t");

           }

           //换行

           System.out.println();

       }

    }

}

 

1.2 函数的重载

1、函数重载的定义：在同一个类中，有一个以上的同名函数，只要函数的参数列表或参数类型不一样即可，与返回值无关， 这些统称为方法的重载。

2、函数的重载存在的原因：为了增强方法的阅读性，优化了程序设计。

2 数组

2.1 数组的定义

格式1：动态初始化

元素类型[] 数组名 = new元素类型[元素个数或数组长度];

示例：int[] arr = new int[5];

格式2：静态初始化

元素类型[] 数组名 = new元素类型[]{元素，元素，……};

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

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

 

2.2 数组常见的问题： 

一 数组角标越界异常:，注意：数组的角标从0开始。

public static void main(String[] args) {

       int[] x = { 1, 2, 3 };

       System.out.println(x[3]);

       //java.lang.ArrayIndexOutOfBoundsException

}

 

二 空指针异常:

public static void main(String[] args) {

       int[] x = { 1, 2, 3 };

       x = null;

       System.out.println(x[1]);

       // java.lang.NullPointerException

    }

 

在函数的内部声明的变量都称作为局部变量。

局部变量一旦出了自己的作用域那么就是使用完毕。

垃圾对象就是没有引用类型变量执行的对象，该对象就是一个垃圾对象。

 

内存结构：

         栈内存：存储的是局部变量，变量使用完，离开自己的空间，马上自动释放内存

         堆内存：存储的是数组和对象，凡是new关键字创建的实体都是保存在堆内存中；每一个对象都有一个内存地址，对象都有默认的初始值。

 

2.3常见的排序算法

2.3.1直接排序：

使用数组中一个元素与其他位置的元素挨个比较一次，符合条件，交换位置。

/*

直接排序。

以一个角标的元素和其他元素进行比较，在内循环第一次结束，最值出现在头角标位置上

*/

public static void selectSort(int[] arr)

    {

       for(int x=0; x<arr.length-1; x++)

       {

           for(int y=x+1; y<arr.length; y++)//为什么y的初始化值是 x+1？        因为每一次比较，都用x角标上的元素和下一个元素进行比较。

           {

              if(arr[x]>arr[y])

              {

                  int temp = arr[x];

                  arr[x] = arr[y];

                  arr[y] = temp;

              }

           }

       }

      }

 

2.3.2冒泡排序：

/*

    冒泡排序。

    比较方式：相邻两个元素进行比较。如果满足条件就进行位置置换。

    原理：内循环结束一次，最值出现在尾角标位置。

    */

    public static void bubbleSort(int[] arr)

    {

       for(int x=0; x<arr.length-1; x++)

       {

           for(int y=0; y<arr.length-x-1; y++)//-x:让每次参与比较的元减。

                                          //-1:避免角标越界。

           {

              if(arr[y]>arr[y+1])

              {

                  int temp = arr[y];

                  arr[y] = arr[y+1];

                  arr[y+1] = temp;

              }

           }

       }

}

 

2.3.3折半查找(二分法)

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

public class Test {

    public static void main(String[] args)

    {

       int[] arr = {12,16,18,19,30};

       int index = halfSearch(arr,19);

       System.out.println("元素所在的索引值："+index);

    }

    //方式2：二分查找法

    public static int halfSearch(int[]arr,inttarget){

       //定义三个变量记录最大、最小、中间的查找范围值。

       int max =arr.length-1;

       int min = 0 ;

       int mid = (max+min)/2;

 

       //使用target与中间值不断的对比

       while(true){

           if(target>arr[mid]){

              min = mid +1;

           }else if(target<arr[mid]){

              max = mid-1;

           }else{

              returnmid;//找到了目标元素

           }     

           //找不到的情况

           if(min>max){

              return -1;

           }

           //重新计算当前的中间值。

           mid = (min+max)/2;

       }  

    }

    //方式1：遍历法

    public static int search(int[]arr,inttarget){

       for(intindex = 0 ;index<arr.length ;index++){

           if (arr[index]==target){//如果找到了那么就返回元素的索引值

              returnindex;

           }

       }

       //如果for循环执行完毕还没有return的话，那么就意味没有这个元素存在。

       return -1;

    }

}

 

2.3.4数组翻转：

/*

    反转其实就是头角标和尾角标的元素进行位置的置换，

    然后在让头角标自增。尾角标自减。

    当头角标<尾角标时，可以进行置换的动作。

    */

    public static void reverseArray(int[] arr)

    {

       for(int start=0,end=arr.length-1;start<end; start++,end--)

       {

           swap(arr,start,end);

       }

    }

    //对数组的元素进行位置的置换。

    public static void swap(int[] arr,int a,int b)

    {

       int temp = arr[a];

       arr[a]= arr[b];

       arr[b]= temp;

               }

 

2.4二维数组:

class Demo3

{

    // 定义一个遍历二维数组的功能函数

    public static void printArr2( int [][] a ){

       // 1. 拆开二维数组

       for ( int i = 0 ; i < a.length ; i++ )

       {

          // 2. 拆开一维数组获取数据

          for (int j = 0 ; j < a[i].length ; j++ )

          {

              System.out.print( a[i][j]+" ," );

          }

       }

   

    }

    // 定义一个函数计算二维数组中的元素的累加和

    public static long getSum( int [][] a ){

       // 0. 定义一个结果变量

        long sum = 0L;

       // 1. 拆开二维数组

       for ( int i = 0 ; i < a.length ; i++ )

       {

          // 2. 拆开一维数组获取数据

          for (int j = 0 ; j < a[i].length ; j++ )

          {

              sum+=a[i][j];

          }

       }

       return sum;

    }

   

    // 统计二维数组中元素的个数

    public static int getDataCount( int [][] a ){

       // 0. 记录元素个数

       int  count = 0;

       // 1. 拆开二维数组

       for ( int i = 0 ; i < a.length ; i++ )

       {

          // 2. 拆开一维数组获取数据

          for (int j = 0 ; j < a[i].length ; j++ )

          {

              count++;

          }

       }

      return count;

    }

    public static void main(String[] args)

    {

      

       int [][] a =newint[][]{ {23,4,5},{2},{4,5,78,56,90} };

       printArr2( a );

        System.out.println();

       System.out.println("累加和是： "+getSum( a ) );

       System.out.println("统计元素个数： "+getDataCount( a ) );

       System.out.println("Hello World!");

      

      

    }

}

 

 

2.4.1数组（Arrays）的工具类:   

         1、toString(数组对象) 返回指定数组内容的字符串表示形式

         2、sort(数组对象) 对数组的元素进行排序。

         3、binarySearch(数组对象, 目标元素);   二分法查找目标元素  如果目标元素存在，那么就返回这个目标元素的索引值，如果不存在会返回一个负数。

import java.util.*;

class Demo13

{

    public static void main(String[] args)

    {

       //数组对象

       int[] arr = {12,45,11,78};

       /*

       //查看元素

       for(int index = 0 ; index<arr.length ; index++){

           System.out.print(arr[index]+",");

       }

       */

       Arrays.sort(arr);//排序

           //11, 12, 45, 78

       int index = Arrays.binarySearch(arr,46);

       System.out.println("索引值："+index);

 

       String str = Arrays.toString(arr);

       System.out.println(str);

    }

}